[AlternC-dev] La Constitution (was: alternc2.0 : architecture ??)

Retour à l'archive de la liste
Le site d'AlternC
Google Custom Search

Lunar lunar at anargeek.net
Ven 8 Déc 02:42:38 CET 2006


Le vendredi 08 décembre à 02:33 +0100, Lunar écrivait:
> Ci-joint le log IRC.

*ahem*

À peluche,
-- 
Lunar                                               http://anargeek.net/
                ·-|-·  無政府ハッカー  ·-|-·
-------------- section suivante --------------
23:24 < Lunar^> nil: Ta dernière remarque est vraiment intéressante, l'idée de découpler la gestion « administrative », c'est classe. Peut y avoir un comportement par défaut, mais tu peux surtout recabler ton modèle de gestion si t'as besoin
23:25 <@nil> Lunar^: oui, ca me semble important de separer les 2
23:25 < Lunar^> nil: Sauf que ça c'est une idée vraiment nouvelle ! :)
23:25 < Lunar^> nil: et c'est p'tet le seul cadre où je vois un vrai intérêt à avoir un "pluginage"
23:26 < Lunar^> qui soit pas du gadget
23:26 <@nil> Lunar^: vouloir avoir tout en un pousse plus ou moins a orienter la structure du modele en fonction des usages non-techniques
23:26 <@nil> c'est ce qui fait que l'infra de l'apinc marche pas pour globenet ni pour ouvaton
23:26 <@nil> et vice-versa
23:27 < Lunar^> oui oui !
23:27 <@nil> bon, rien a ajouter alors :)
23:27 < Lunar^> Par contre, ça complique beaucoup l'implémentation
23:27 < Lunar^> parce que, par exemple, ton accounting, ça peut être du quota
23:27 <@nil> pourquoi?
23:27 <@nil> oui
23:27 < Lunar^> ou ça peut être du « fair use »
23:27 <@nil> j'y ai pense
23:28 < Lunar^> Et qu'un moment, il faut définir une interface (ou plutôt une API, ici) pour que tu puisses spécifier des contraintes sur le modèle en fonction de tes processus
23:28 <@nil> en fait je me demande ou l'accounting va aller chercher ses infos
23:29 <@nil> sur le modele (fluctuant)
23:29 <@nil> ?
23:29 < Lunar^> genre délégation, "sudo" ou même juste contrainte d'intégrité (existe-t-il bien un compte derrière tel donnée du modèle)
23:29 < Lunar^> Ça veut dire une API turing-complete, ça....
23:29 <@nil> hihi
23:30 < Lunar^> J'veux dire, c'est pas un fichier de configuration, c'est forcément un bout de code
23:30 < Lunar^> Et il faut qu'il existe suffisament de hook pour que tu puissses associer les comportements adéquats
23:30 <@nil> qui integre des liens logiques entre les differents parametres d'accounting
23:30 < Lunar^> oui
23:31 < Lunar^> Bah ton modèle, il faut qu'il dispose d'une interface (celle qui est entre les humains et le modèle, dans ton schéma)
23:32 < Lunar^> qui permette d'intéroger sur les possibilités
23:32 < Lunar^> et le modèle doit générer les possibilités en fonction des contraintes d'accounting
23:32 <@nil> oui, donc ca va au-dela de la notion actuelle d'interface alternc qui ne peut qu'interroger sur ce qui existe
23:33 < Lunar^> mh.. bah il faudra considérer que des bouts du truc peuvent ou ne peuvent pas être actif selon les situations
23:33 < Lunar^> Mais là où ça devient impossible je pense
23:33 < Lunar^> (ou alors extrêment compliqué)
23:33 < Lunar^> c'est que certaines informations changent d'aspects à un moment
23:34 < Lunar^> typiquement si tu introduis une possibilité de délégation dans ton <rah, j'arrive pas à trouver un terme exact pour définir ces règles là, dont on parle>
23:34 <@nil> euh...
23:34 <@nil> les contraintes?
23:34 < Lunar^> workflow ?
23:35 <@nil> hmmm pas vraiment
23:35 < Lunar^> oui, hein
23:35 < Lunar^> rah.. merde
23:35 < Lunar^> "business logic"
23:35 <@nil> "mode de fonctionnement"
23:35 <@nil> bref, on sait de quoi on parle
23:35 < Lunar^> Il faut un terme
23:36 <@nil> :)
23:36 < Lunar^> tant que y a pas de terme, ça veut dire qu'on peut pas développer le concept
23:36 < Lunar^> programmer c'est beaucoup ça, hein, trouver le vrai nom des choses que tu veux faire
23:36 < Lunar^> une fois que la terminologie est bonne, le code coule
23:37 <@nil> la terminologie n'est que le lien entre ce que tu veux faire et le concept precis auquel ca correspond
23:37 <@nil> concept resume en un seul mot
23:37 < Lunar^> "processus de gestion" ?
23:37 <@nil> (au fait, en est utf8 sur #globenet maintenant?)
23:37 < Lunar^> Maybe I should try to think about it in english
23:37 < Lunar^> sometimes words just pop up better that way
23:38 <@nil> accounting and hierarchy model
23:38 <@nil> schema
23:38 < Lunar^> "accounting schema"... but let's say I'm doing the "null
23:38 < Lunar^> " schema
23:39 < Lunar^> like no users, everything is free for everyone
23:39 < Lunar^> (or more likely : i'm the only admin on the box, leave me alone doing my stuff){
23:39 < Lunar^> I will not be doing any kind of accounting, rigth?
23:39 < Lunar^> right
23:40 <@nil> right
23:41 <@nil> it's a matter of quota and privileges
23:41 <@nil> what you can do, what's the limit
23:41 < Lunar^> mhhh
23:41 < Lunar^> archy ?
23:42 < Lunar^> Comme dans hier-archie ?
23:42 <@nil> hihi
23:42 <@nil> ou an-archy
23:42 < Lunar^> http://fr.wiktionary.org/wiki/-archie
23:42 <@nil> The English suffix -archy (from Greek αρχη ruler) denotes leadership and government. See Political philosophy and politics. 
23:42 < Lunar^> « arkhein », du coup
23:43 < Lunar^> ça colle pas vraiment en fait
23:43 <@nil> bah si un peu
23:43 <@nil> c'est un ensemble de contraintes artificiellement imposees
23:43 <@nil> et un mode de fonctionnement
23:43 <@nil> un systeme politique + economique
23:44 <@nil> des pouvoirs, des quotas
23:44 < Lunar^> en fait, j'aimerais l'appeler « Modèle d'organisation » je crois
23:44 < Lunar^> mais « modèle », c'est les données faisant référence
23:44 < Lunar^> Eureka!
23:44 < Lunar^> C'est la constitution !
23:44 <@nil> hihihi
23:44 <@nil> oui!!!
23:45 < Lunar^> Du latin constitutĭo, -ōnis, « fait d'établir ensemble ».
23:45 < Lunar^> Ensemble des lois fondamentales qui dicte la politique d’un État ou d’un groupe d’états. 
23:45 < Lunar^> c'est le même terme en anglais
23:46 < Lunar^> le terme en anglais est même plus précis
23:46 < Lunar^> Même s'il reste encore la synonymie sur la santé
23:46 < Lunar^> http://en.wiktionary.org/wiki/constitution
23:47 <@nil> The formal or informal system of primary principles and laws that regulates a government or other institution
23:48 <@nil> bon, disons qu'on a la constutution du service, son modele, sa realite
23:48 < Lunar^> Bon, des gens moins ouverts auraient vraiment appelé ça « business logic » m'enfin
23:48 < Lunar^> :)
23:48 <@nil> business logic, ca va plus loin
23:49 <@nil> ca inclut l'interface avec le monde exterieur, toussa
23:49 < Lunar^> Maintenant on peut continuer le brainstorming :)
23:49 < Lunar^> oui tu as raison
23:50 < Lunar^> Du coup, quel template on lui impose à notre constitution
23:50 <@nil> alors, effectivement, je vois mal indiquer la constitution dans une base sql ou un fichier
23:50 <@nil> la constitution doit saboir repondre a des question du genre
23:50 <@nil> * est-ce que machin a le droit de faire le truc foo
23:50 < Lunar^> parce qu'une vraie constitution, par exemple, elle doit forcément prendre en compte le fait qu'il existe des êtres humains, genre
23:51 <@nil> * quelle quantite de bar est-ce que machin peut demander
23:51 < Lunar^> Tu réponds à ma question, vu que tu posos qu'il existe machin, foo et bar
23:51 < Lunar^> poses
23:52 <@nil> oui, elle doit prendre en compte les etres humains
23:52 <@nil> ou du moins les user/pwd qui vont se connecter
23:52 <@nil> + l'user anonyme
23:52 < Lunar^> mhh.. comment tu intercales les groupes ? 
23:52 < Lunar^> En fait, la vraie question, c'est comment tu associes (pour simplifier) la colonne UID du modèle à un élément de la constitution
23:53 < Lunar^> ou alors est-ce que toute la gestion des droits est déportée dans la constitution
23:53 <@nil> cette version permettrait un truc tres fin
23:53 <@nil> peut-etre trop fin
23:53 <@nil> trop fin pour les utilisateurices habitue.e.s a des trucs plus simples
23:54 <@nil> 1 admin, ou 1 groupe d'admin
23:54 < Lunar^> (Sans parler des admins !) Je pense que c'est intéressant de prendre en compte la possibilité d'administration collective
23:54 <@nil> je parlais d'admins de comptes
23:54 <@nil> pas d'admins de la machine
23:54 < Lunar^> je dis "trop fin" pour les admins sys aussi
23:54 < Lunar^> si t'es obligé de recoder un système d'ACL pour ton installation, c'est pas top :)
23:54 <@nil> permettre la delegation sur un compte dela gestion d'un domaine
23:55 <@nil> ou sous-domaine
23:55 <@nil> ou des mails
23:55 <@nil> ce serait bien
23:55 <@nil> en fait, on perd la notion de compte
23:55 < Lunar^> Si tu gères l'administration collective, tu peux gérer la délégation gratos
23:55 <@nil> on a juste des gens qui ont des droits
23:55 <@nil> et qui en accordent a d'autres
23:56 < Lunar^> ah.. ça c'est interne à la constitution pour moi, le fait d'en accorder à d'autres
23:56 <@nil> le droit d'accorder des droits, oui pour moi c'est constitutionnel
23:57 <@nil> ainsi que quels droits, et dans quelle limite
23:57 < Lunar^> c'est ça
23:57 < Lunar^> C'est bien, parce que ça permet d'implémenter un modèle unifié
23:57 < Lunar^> (en théorie, parce qu'en pratique je vois déjà des limitations rien qu'à y penser)
23:58 <@nil> oui, ca integre meme les admins sys
23:58 < Lunar^> je veux dire, on pourrait faire que l'accès à une boite mail en consultation
23:58 < Lunar^> ça passe aussi par une délégation constitutionnel
23:58 < Lunar^> (mais en vrai, ça marche vraiment pas)
23:58 <@nil> oh.... la CNT adoooorerait!
23:58 < Lunar^> mdr !
23:59 <@nil> (debian aussi, d'ailleurs)
23:59 < Lunar^> Ok, donc qu'elle est le vocabulaire qu'on peut employer dans la constitution
00:00 <@nil> pourquoi l'acces a une boite en consultation ne passe pas  en vrai?
00:00 < Lunar^> ah
00:00 < Lunar^> Parce que l'auth. se fait sur le couple email/password
00:00 < Lunar^> Pas sur le triplet login/password/boite
00:01 < Lunar^> enfin, si, en fait
00:01 <@nil> et une boite est accessible qu'a un seul couple login/pwd
00:01 < Lunar^> c'est possible d'encoder login+boite dans le login, en fait
00:01 < Lunar^> genre login : "lunar:lunar at anargeek.net"
00:01 < Lunar^> ou login : "lunar:support at globenet.org"
00:01 <@nil> ok
00:02 < Lunar^> mais ça serait encore plus compliqué pour les utilisateurices
00:02 < Lunar^> mais si on peut avoir une constitution suffisament souple pour permettre ça... waow
00:02 < Lunar^> mais c'est vraiment pas obligé
00:02 < Lunar^> gadget, quand même
00:02 < Lunar^> Le problème est le même pour les accès genre FTP, par contre
00:02 <@nil> je me dis aussi que ca va etre complique pour les "decideurs" de definir leur constitution
00:02 <@nil> je veux dire, l'interface pour ca
00:03 < Lunar^> Bah perso, les deux premières constitutions à écrire c'est « Anarchie » et « AlternC 1.0 »
00:03 < Lunar^> si on peut ajouter « CNT », c'est qu'on a un système qui tient la route, à priori
00:03 <@nil> hihi
00:03 <@nil> oui
00:04 < Lunar^> Si l'API est bien faites, ça devrait pas être trop compliqué
00:04 < Lunar^> mais là, il faudrait du Haskell pour faire une vraie bonne API
00:04 < Lunar^> avec des combinateurs et un système de typage pour valider
00:04 < Lunar^> m'enfin, je reviens sur terre
00:04 <@nil> je me demande comment integrer les questions de quota
00:05 <@nil> genre, parfois on a droit a 10 foo mais des fois uniquement 5
00:05 <@nil> euh...
00:05 <@nil> en fait, ce serait "l'utilisateur tout-puissant accorde a l'utilisateur lambda 10 droits d'usage du service foo"
00:06 < Lunar^> On peut essayer de définir un vocabulaire de base
00:06 <@nil> oui
00:06 < Lunar^> et ensuite voir qu'est-ce qui serait dans l'API, et qu'est-ce qui resterait interne au modèle
00:06 < Lunar^> Donc... on a le User, hein
00:06 <@nil> oui
00:07 < Lunar^> the User, même
00:07 < Lunar^> On a s'ez
00:07 < Lunar^> mince
00:07 < Lunar^> On a l'ensemble des services exposés par le modèle
00:07 <@nil> vi
00:07 < Lunar^> (dynamique, si je suis le reste des propositions pour AlternC 2.0, vu que y a des plugins)
00:07 <@nil> les quotas disques et bp peuvent-ils entrer dans la notion de service
00:08 <@nil> comme une boite mail ou un domaine
00:08 <@nil> parceque ce sont des services qui se consomment dans le temps
00:08 <@nil> sans action des Users
00:08 < Lunar^> ah... tiens, bone question
00:09 < Lunar^> est-ce que ça fait parti du modèle, en fait ?
00:09 <@nil> ca pourrait
00:09 <@nil> ca serait bien que ca puisse
00:10 <@nil> techniquement, c'est tres different
00:10 < Lunar^> oui, ça évolue dans le temps, mais tu peux considérer qu'ils sont pas en évolution constante, par exemple
00:10 <@nil> surtout pour la bp
00:10 < Lunar^> C'est de la convergence dans l'autre sens
00:10 < Lunar^> ton modèle est rafraichi par l'état du système sur ces points là
00:11 <@nil> ah oui
00:11 < Lunar^> ça parait cohérent, mais ça me satisfait pas complètement, je crois
00:12 <@nil> pour les quotas disque, y'a le probleme de l'inclusion des quotas dans les quotas
00:12 < Lunar^> Pour moi, c'était plutôt le modèle qui influençait le système, et plutôt à sens unique
00:12 < Lunar^> c'est un faux problème, ça
00:12 < Lunar^> Ta constitution, elle peut gérer le calcul comme t'as envie
00:12 < Lunar^> si ton modèle est capable de répondre à la question « Quelle place ça prend ce truc là sur le disque ? »
00:13 <@nil> oui mais si X doit specifier les quotas disque de toutes les boites qu'il accorde ou de tous les espaces ftp..
00:13 <@nil> euh
00:13 <@nil> il peut les predefinir en fait
00:14 < Lunar^> Non, c'est plutôt « Cet·te User a le droit à tel espace disque. », et le machin peut faire la somme
00:14 < Lunar^> ou négliger une partie
00:14 < Lunar^> ou alors tu peux pondérer en fonction de si c'est de l'espace disque sauvegardé, ou en RAID
00:14 < Lunar^> mais tu peux aussi limiter l'espace d'une boite mail indépendemment du général
00:14 < Lunar^> si la notion d'User englobe une personne apte à se connecter à une boite mail
00:15 <@nil> oui... dans l'ideal, ca ferait un truc super-fin... le host-manager ideal
00:15 < Lunar^> ou pas... pour boum on veut surtout pas que ce soit trop fin par exemple
00:15 < Lunar^> enfin, « on »... je suis plus dedans
00:15 <@nil> qui *pourrait* etre super-fin
00:15 < Lunar^> yep
00:15 < Lunar^> Je crois que j'ai la solution
00:16 <@nil> User, Service, ... + Privilege ?
00:16 < Lunar^> Il suffit que de considérer dans le modèle une colonne du style « Dernière validation »
00:16 < Lunar^> non
00:16 < Lunar^> attend
00:16 <@nil> oui
00:16 < Lunar^> enfin, si, mettons qu'on l'appel comme ça
00:17 < Lunar^> non ça colle pas
00:17 < Lunar^> merde.
00:17 < Lunar^> je l'avais, je l'ai plus
00:17 <@nil> Droit? Right?
00:17 < Lunar^> Alors, réformuler le problème
00:17 < Lunar^> Ton quota en bande passante
00:18 < Lunar^> Il doit te permettre de couper le site, ou alors de limiter la bande passante par la suite
00:18 < Lunar^> (ou de la limiter tout de suite)
00:18 <@nil> exactement
00:18 < Lunar^> s/tout de suite/tout le temps/
00:19 <@nil> ah oui
00:19 < Lunar^> Donc, ta constitution elle peut demander au modèle « Combien t'as consommé de bande passante ? », c'est la première étape
00:20 <@nil> oui...
00:20 < Lunar^> Est-ce qu'on veut que la constitution puisse modifier le modèle ?
00:21 < Lunar^> Parce que, si on reste sur le principe de « convergence »
00:21 <@nil> euh... je dirais non...
00:21 <@nil> mais brider la bp c'est modifier le modele
00:21 < Lunar^> c'est le seul moyen de limiter ou de couper le site, sinon
00:21 <@nil> voila
00:21 < Lunar^> yep
00:22 < Lunar^> parce qu'on peut pas formuler une condition constante, ça serait trop compliqué, je crois
00:22 <@nil> grrr.. ca c'est incontestablement le modele
00:22 <@nil> et la volonte que ce soit le systeme
00:22 < Lunar^> Parce que le principe de relation constitution<->modèle
00:22 < Lunar^> tel qu'on la dessine là
00:22 < Lunar^> c'est bien que le modèle interroge la constitution lorsqu'il est modifié
00:22 < Lunar^> pour savoir si la modification est possible ou pas
00:22 < Lunar^> pour résumer
00:22 <@nil> exactement
00:22 <@nil> c'est statique
00:23 <@nil> la bp ou le disque imposent une reevaluation reguliere
00:23 < Lunar^> hors, sur la BP on a une modification constante
00:23 <@nil> voire cotinue
00:23 < Lunar^> yep
00:23 < Lunar^> continue, c'est le mot
00:23 < Lunar^> On peut la rendre discontinue, hein, si on veut
00:23 <@nil> oui
00:23 < Lunar^> c'est la transformation de fourier appliqué à la BP :D
00:23  * Lunar^ sors
00:24 < Lunar^> sort, même
00:24 <@nil> ca c'est un peu repondre aux requetes de l'utilisateur anonyme
00:24 <@nil> aux requetes de "l'exterieur du systeme"
00:24 < Lunar^> j'suis pas sûr de suivre
00:25 <@nil> bah de la bp, c'est des fichiers qui sortent
00:25 <@nil> des fichiers demandes par quelau'un dehors
00:25 <@nil> l'utilisateur anonyme du systeme
00:25 < Lunar^> ah.. ça serait chouette de pouvoir le modéliser comme ça, mais c'est vraiment pas possible en terme d'implémentation à priori
00:25 <@nil> pis si on ajoute des contraintes d'usage cpu ou ram... :)
00:26 < Lunar^> Si tu veux limiter la bande passante, par exemple, tu vas modifier la valeur de la configuration de mod_bandwidth dans le vhost d'Apache
00:26 <@nil> em fonction des requetes auxquelles apache a repondu dans la periode de temps consideree
00:27 <@nil> on pourrait comencer par ne considerer que des services "discrets", on/off
00:27 < Lunar^> bah même topo
00:28 < Lunar^> tu peux renvoyer une 4XX  à coup de RewriteRule conditionnel, mais c'est chaud quoi
00:28 < Lunar^> ça parait plus réaliste de modifier l'état du système
00:28 <@nil> non, je voulais dire ignorer (temporairement) les quotas disque/bp/cpu/ram/toussa
00:28 < Lunar^> donc de modifier le modèle, si c'est que par lui que ça se fait
00:28 < Lunar^> ahh... pardon
00:28 < Lunar^> alors vas-y
00:29 <@nil> on a deja des Users et des Services
00:29 <@nil> fait des Privileges de deux types
00:29 <@nil> Privilege d'usage
00:29 <@nil> Privilege de delegation
00:29 <@nil> Privilege d'accorder des privileges, plutot
00:30  * nil se dit que les modeles sql font dela beaucoup ce truc de Users et Privileges
00:30 <@nil> s/dela/deja
00:31 <@nil> l'User "dieu" (ou "gaia") a un certain nombre de privileges
00:31 < Lunar^> root :D
00:31 <@nil> oui
00:31 <@nil> mais c'est pas les admins alternc
00:32 < Lunar^> ah alors j'avais pas compris
00:32 < Lunar^> continue
00:32 <@nil> je veux dire, les admin-sys de la machine
00:32 < Lunar^> gaia, donc ?
00:32 <@nil> pour moi, gaia c'est les limites imposees ou non en terme de services en place sur le systeme
00:33 <@nil> c'est gaia qui accorde aux comptes admin (dans le modele Altern1.0) le droit de creer des comptes
00:33 <@nil> gaia peut etre dans la constitution aussi
00:34 < Lunar^> oui c'est ça que je me dis
00:34 < Lunar^> c'est que gaia c'est la constitution là
00:34 < Lunar^> if User.name == 'root': pass
00:34 < Lunar^> ou "return True" plutôt
00:34 <@nil> sauf que j'aimer pas que la constitution dise qui sont les admins de la machine
00:34 < Lunar^> Bah la « vraie » constitution spécifie qui peut changer la constitution en même temps
00:35 <@nil> hihi
00:35 < Lunar^> j'veux dire
00:35 < Lunar^> la notion même d'admin de la machine
00:35 <@nil> la constitution republicaine francaise dit pas qui est le prez, elle dit comment on devient prez
00:35 < Lunar^> ça fait partie d'un certain type de constitution
00:35 < Lunar^> if User.is_admin: return True
00:35 < Lunar^> ça marche aussi
00:35 <@nil> (on parle d'admin dans le cadre d'alternc, la, hein)
00:36 <@nil> ok, alors etre admin est aussi une caracteristique d'utilisateur
00:36 <@nil> donc revocable, ou deleguable
00:36 < Lunar^> Comme les caractéristiques des Users c'est quelque chose de dépendant de la constitution, ça me va
00:37 <@nil> en fait, un admin est un User aux droits illimites
00:38 < Lunar^> mhh.. bah pour moi, la révocabilité ou même la déléguabilité, c'est déjà quelque chose de propre à une constitution
00:38 <@nil> dans les limites des quotas totaux du systeme
00:38 < Lunar^> yep
00:38 < Lunar^> C'est intéressant à prendre en compte comme notion, ça
00:38 < Lunar^> du coup, faut rajouter à nos deux trucs maudits un troisième : la charge CPU
00:38 <@nil> pis la RAM
00:39 < Lunar^> allez, soyons fou
00:39 <@nil> erf, difficilement controlable
00:39 < Lunar^> avec mpm-itk, ça doit pouvoir se faire
00:39 < Lunar^> pour apache par exemple
00:40 < Lunar^> (man ulimit)
00:40 <@nil> on est pas en train de reconstruire en environnement plus simple un OS linux ou genre.., la?
00:40 < Lunar^> non, non :)
00:40 < Lunar^> mais oui, un système de gestion de droits
00:41 <@nil> je veux dire, definir des users, des droits..
00:41 < Lunar^> On devrait aller lire des papiers de recherche sur le sujet, si on étais sérieux
00:41 <@nil> voila
00:41 <@nil> oui
00:41 < Lunar^> mais bon, c'est quand meme d'AlternC qu'on parle, hein
00:41 < Lunar^> je trouve qu'on grille déjà beaucoup de neurones par rapport à la moyenne ....
00:41 <@nil> hurd aussi d'ailleurs, et ses histoires de "plusieurs users pour un process"
00:41 < Lunar^> ah, je connais pas ça
00:41 <@nil> mais bon, je coupe la digression
00:42  * nil a du lire quelquepart que hurd a le paradigme de plusieurs uid pour un process
00:42 <@nil> mais bon, je coupe la digression, j'ai dit
00:42 <@nil> bon
00:42 <@nil> on a quoi, manque quoi?
00:43 <@nil> les conditions
00:43 < Lunar^> L'API de notre constitution
00:43 < Lunar^> on est pas d'accord en fait
00:43 <@nil> manque les conditions, 
00:43 <@nil> la constitution dit un truc du genre X peut accorder le droit truc a Y si....
00:43 <@nil> si quoi
00:43 < Lunar^> Ah.. en fait ça y est, je vois la différence
00:43 <@nil> formule comment
00:44 < Lunar^> Ton système établi une table statique
00:44 <@nil> ?
00:44 < Lunar^> C'est pour ça que tu as besoin de définir la notion de privilège et de délegation
00:44 < Lunar^> Là où je vois quelque chose de dynamique
00:44 <@nil> dis-moi
00:44 < Lunar^> avec presque un seul point d'entrée :
00:45 < Lunar^> allow :: User -> Service -> Action -> Bool
00:45 < Lunar^> ou plutôt
00:45 < Lunar^> isAllowed :: User -> Service -> Action -> Bool
00:45 < Lunar^> quelque chose comme ça
00:45 < Lunar^> enfin, pardon, en Python
00:45 <@nil> hmmmm
00:45 < Lunar^> def is_allowed(user, service, action): # return True or False
00:46 < Lunar^> action, je le voyais en Haskell comme un variant
00:46 < Lunar^> genre Create | Modify | Delete
00:46 < Lunar^> ou quelque chose comme ça
00:46 <@nil> oui
00:46 < Lunar^> ce qui est assez pauvre sémantiquement, malheureuseument
00:47 <@nil> + Transfer
00:47 < Lunar^> L'idéal serait d'avoir des actions extensibles par services
00:47 <@nil> (enfin, ca c'est create+delere)
00:47 <@nil> delete
00:47 < Lunar^> transfer... oui oui
00:47 < Lunar^> Enfin... ça dépend.. en modèle de convergence, c'est create+delete si la transaction est atomique
00:48 < Lunar^> Mais dans tous les cas, je pense que c'est plus simple si t'as un "Transfer" qui a une sémantique atomique en soit, comme "mv" dans Unix
00:48 <@nil> oui
00:48 <@nil> dans ce car transfer agit sur 1 service et 2 users
00:48 <@nil> caS
00:48 <@nil> quand meme
00:48 < Lunar^> c'est pour ça que je disais que c'était pauvre sémantiquement
00:49 <@nil> si on considere que un user dispose de services
00:49 <@nil> on peut peut-etre considere que un service est attribue a un user
00:49 <@nil> (c'est une alternative)
00:49 < Lunar^> non, ça va pas
00:49 < Lunar^> ça englobe pas la notion de collectif
00:49 <@nil> oui
00:50 <@nil> mais ca faciliterait la transfert
00:50 < Lunar^> donc ça peut pas être ça l'API
00:51 < Lunar^> (p'tite coupure réseau)
00:51 < Lunar^> Si je peux pas mettre la notion de collectif dans la constitution, c'est que c'est pas une API assez expressive
00:51 < Lunar^> et donc faut la jeter
00:51 <@vt> tiens moi aussi j'Ai eu une petite coupure ;)
00:51 <@nil> en fait, on a un pool d'users, un pool de services, et les droits sont des liens entre les deux pools
00:52 < Lunar^> La meilleure solution que je vois, c'est des trucs genre décorateurs 
00:52 <@vt> c'est sans doute un point d'échange ;)
00:52 < Lunar^> vt: un des routeurs de Free au TH2
00:52 <@nil> les modifications du modele sont ajouter ou retirer un lien
00:52 <@nil> la connectivite pouvant etre one-to-many
00:53 < Lunar^> je suis pas là
00:53 <@nil> suis de suivre ou de etre ?
00:53 < Lunar^> suivre
00:53 <@nil> :)
00:53 <@nil> je pense a une representation du modele
00:53 <@vt> Lunar^: alors nos problèmes de connexions sont indépendants :) je ne passe pas par proxad
00:53 <@nil> un nuage de points pour les users
00:54 <@nil> un nuage de points pour les services
00:54 <@nil> un lien de l'un vers l'autre pour dire X a le froit truc
00:54 <@nil> Droit
00:54 <@nil> ou les droits
00:54 < Lunar^> brb
00:54 <@nil> ou X, Y et Z on le droit truc
00:55 <@nil> un collectif, c'est plusieurs users lies au meme droit
00:56 <@nil> la consttution deraqit de la forme isallowed(Users, Services, UpdateRight): # return True or False
00:56 < Lunar^> trop restrictif
00:56 <@nil> un truc global, quoi
00:57 < Lunar^> Ok, je viens de me rappeler de papier de recherches
00:57 <@nil> ?
00:57 < Lunar^> on pourrait utiliser des capacités
00:57 <@nil> informatique, politique, socio?
00:57 < Lunar^> informatique
00:57 <@nil> hihi
00:57 < Lunar^> Ou alors faire plus simple, et introduire la notion de « jeton » ou de « clé »
00:57 <@nil> capacites...
00:58 <@nil> (si t'as une reference pour ce papier, a l'occasion, je le choperai)
00:58 < Lunar^> L'algebre des "capabilities" c'est simple hein
00:58 <@nil> connais pas
00:58 < Lunar^> Faut chercher EROS, CoyotOS
00:58 < Lunar^> attend, je retrouve
00:58 < Lunar^> http://en.wikipedia.org/wiki/Coyotos
00:58 < Lunar^> systems. A capability (known in some systems as a key) is a communicable, unforgable token of authority. It refers to a value that references an object along with an associated set of access rights. 
00:59 < Lunar^> communicable, donc pas dupliquable
00:59 < Lunar^> sauf si tu as la capacité de dupliquer, qui est bien gardé au chaud dans un coin
00:59 < Lunar^> http://en.wikipedia.org/wiki/Capability-based_security
01:00 < Lunar^> Mais on peut faire plus simple, en fait, alors je t'expose l'idée que j'ai en tête, ou je te laisse lire
01:00 <@nil> expose moi
01:00 < Lunar^> ok
01:00 <@nil> je lirai
01:00 < Lunar^> Ok, c'est assez simple en fait
01:00 < Lunar^> tu connais les décorateurs en Python ?
01:00 <@nil> non, pas encore :)
01:01 < Lunar^> C'est des fonctions d'ordre supérieur
01:01 < Lunar^> mais comme les Pythonistes sont pas tou·te·s des Haskelleux
01:01 < Lunar^> bah ils ont appelé ça « décorateur »
01:01 < Lunar^> Le type de ces fonctions, c'est (en Haskell, désolé) : (a -> b) -> (c -> d)
01:01 <@nil> ok, pep318
01:01 < Lunar^> Je prend une fonction, je renvoie un fonction
01:02 <@nil> d'accord
01:02 <@nil> en maths je vois bien
01:02 < Lunar^> La gestion des droits dans Turbogears se fait comme ça
01:02 < Lunar^> @require(identity.in_group('admin'))
01:02 < Lunar^> def delete(self, user):
01:02 < Lunar^>    ...
01:03 < Lunar^> Ça veut dire que pour accéder à /delete, il faut être authentifié, et dans le groupe admin
01:03 < Lunar^> require est en fait une fonction qui ajoute 
01:03 < Lunar^> un bout de code qui teste si les droits sont bons avant d'exécuter la fonction qui est décorée
01:03 <@nil> ah, d'ac
01:04 < Lunar^> Ici, on peut pas faire ça, vu que pour notre constitution, on veut pas avoir à modifier les sources directement
01:04 < Lunar^> Mais on peut avoir un concept similaire
01:04 < Lunar^> Notre constitution, elle va modifier le code de notre modèle
01:04 <@nil> ce genre de chose serait bon pour exprimer la constitution
01:04 < Lunar^> (entre guillemets)
01:05 <@nil> guillements autour de "code"
01:05 <@nil> ?
01:05 < Lunar^> en rajoutant le bon de code qui lui convient pour autoriser ou non l'exécution de la fonction
01:05 < Lunar^> oui, c'est ça
01:05 <@nil> oui
01:05 <@nil> ok
01:05 < Lunar^> on peut aussi le coder avec des hooks systématiques, si le langage dispose pas de fonction d'ordre supérieur
01:05 <@nil> hmmm
01:06 < Lunar^> genre :
01:06 < Lunar^> def delete(mailbox):
01:06 <@nil> ces fonctione d'ordre superieurs permetent d'exprimer plus que du booleen?
01:06 <@nil> (ok, pas la peinde de repondre)
01:07 < Lunar^>     self.constitution.check('mailbox.delete')
01:07 < Lunar^> ah bah si t'as des fonctions d'ordre supérieur
01:07 < Lunar^> tu peux faire ce que tu veux :D
01:07 < Lunar^> renvoyer des trucs faux pour faire un honey-pot
01:07 < Lunar^> par exemple :D
01:07 <@nil> :)
01:08 < Lunar^> Mais ça devient plus intéressant si on revient à nos histoires de quota
01:08 < Lunar^> je peux aller décorer le code de getUsedDiskSpace() 
01:09 < Lunar^> mh.. est-ce que je veux pouvoir faire ça ?
01:09 <@nil> self.constitution.check('mbx.del') a potentiellement acces a tout le modele pour decider oui/non...
01:09 < Lunar^> ah bah dans tous les cas notre constitution doit pouvoir accéder au modèle en read-only
01:09 <@nil> oui
01:09 < Lunar^> quand tu passes devant le juge, t'as un rappel des faits :)
01:10 <@nil> oui mais bon, les circonstances attenuantes...
01:10 <@nil> :)
01:10 < Lunar^> donc, non, je crois pas qu'il faille pouvoir décorer getUsedDiskSpace()
01:10 < Lunar^> vu que c'est une donnée du modèle, je veux pas pouvoir la changer de façon constitutionnel
01:10 <@nil> c'est une information objective
01:10 < Lunar^> c'est ça
01:11 <@nil> mais on pourrait decider unUser a le droit de savoir
01:11 < Lunar^> ah !
01:11 < Lunar^> bah oui !
01:12 < Lunar^> (l'utilisation genre « décorateur » est plus efficace en terme de coût de processing, ça évite d'avoir à chercher dans des tables quand t'as rien)
01:12 <@nil> cependant il y a des modification du systeme qui ne passent pas par le controleur
01:13 <@nil> un script php qui cree un fichier sur le disque
01:13 < Lunar^> nouveau terme "controleur" à définir
01:13 < Lunar^> ou c'est ton '
01:13 <@nil> il demande l'autorisation a personne
01:13 < Lunar^> "interface" dans le schéma envoyé sur la liste ?
01:13 <@nil> euh... je reprends le schema...
01:14 < Lunar^> mh... en terme MVC, ton interface c'est V+C en fait
01:14 <@nil> ca pourrait etre l'interface
01:14 < Lunar^> mais je pense que controlleur c'est pas le bon mot en fait
01:14 <@nil> mais l'interface c'est plus que le controle d'autorisation
01:14 < Lunar^> parce qu'on a de la logique dans la daemon, c'est lui qui va faire le boulot
01:14 <@nil> oui
01:14 <@nil> c'est ce que je me disais
01:14 < Lunar^> gardons interface, alors :)
01:14 <@nil> l'interface interroge le daemon avant d'agit surl e modele
01:15 < Lunar^> j'avais pas ça en tête
01:15 <@nil> j'ai le droit? (oui/non)
01:15 <@nil> ah?
01:15 <@nil> dis-moi
01:15 < Lunar^> pour moi le modèle il s'occupe de te jeter si tu lui demandes un truc qui le rend pas cohérent
01:15 <@nil> ok
01:16 <@nil> je ne voyais le modele que comme le stockage des caracteristiques souhaitees su systeme
01:16 < Lunar^> vérification des contraintes dans le modèle, c'est pour ça que la constitution se greffe dessus
01:16 <@nil> mais c'est mieux si il a de la logique
01:16 < Lunar^> bah les gens qui font du SGBDR sérieux, il mettent les contraintes dans la description du schéma
01:16 < Lunar^> donc c'est bien que le modèle il vérifie que c'est bon, non ?
01:16 <@nil> comme ca l'interface peut meme etre codee avec les pieds
01:16 < Lunar^> programmer défensif :)
01:17 <@nil> oui, oui
01:17 < Lunar^> Alors je reformule ton exemple
01:17 <@nil> (parceque je me dis qu'il devrait etre possible de construire une infinite d'interfaces)
01:17 <@nil> ok
01:18 < Lunar^> On a des modifications de l'état du système qui ne passent pas par le modèle
01:18 <@nil> oui
01:18 < Lunar^> enfin, qui sont effectués sans qu'une modification du modèle soit repercuté par le daemon
01:18 <@nil> et sans que le daemon decide si elles sont effectuees ou pas
01:19 < Lunar^> La daemon décide pas, si on garde l'idée de convergence
01:19 <@nil> oui
01:19 <@nil> mais je veux dire
01:19 < Lunar^> le daemon il cherche juste à faire converger, rien d'autre
01:19 <@nil> "en dehors de toute intervention du daemon"
01:19 <@nil> c'est ce qu'il ne controle pas
01:20 < Lunar^> ce qu'il ne fait pas, je préfère
01:20 <@nil> (on parle bien de disque/bp.cpu/ram, la?)
01:20 <@nil> ok
01:20 < Lunar^> bah je reprenais ton exemple du fichier posé sur le disque
01:21 <@nil> oui
01:21 < Lunar^> Quel est notre problème vis-à-vis de ça en fait ?
01:21 < Lunar^> Le contenu de fichier, ça fait pas partie de notre modèle, le droit de l'écrire non plus, si ?
01:21 <@nil> de le mesurer (en continu ou par moments)
01:22 < Lunar^> pardon, je reformule
01:22 < Lunar^> Le contenu de fichier, ça fait pas partie de notre modèle, le droit de l'écrire ne fait pas partie non plus de notre constitution, si ?
01:22 <@nil> le droit de l'ecrire, si, si le quota disque est rempli
01:22 <@nil> pas de la constitution, non
01:22 <@nil> effectivement
01:22 < Lunar^> Alors, là, on est obligé malheureusement de rentrer un cran en dessous
01:22 < Lunar^> unix de merde
01:22 < Lunar^> (pardon)
01:23 <@nil> hihi
01:23 < Lunar^> Pour rentre le quota disque dans notre bazar, il doit faire partie de « l'état du système »
01:23 <@nil> oui
01:23 < Lunar^> donc il doit faire partie du notre modèle
01:23 < Lunar^> si on veut pouvoir le modifier
01:24 <@nil> oui. le quota dans le sens unix
01:24 < Lunar^> oui, celui là
01:24 < Lunar^> mais c'est pareil pour la BP (mod_bandwidth) ou pour CPU/RAM (ulimit)
01:24 <@nil> ce quota, c'est un des services
01:25 < Lunar^> oui, c'est le service « fichiers »
01:25 <@nil> c'est juste un service dont l'usage n'est pas issu d'une action du daemon
01:25 <@nil> a la difference d'un quota boites mail
01:25 < Lunar^> d'accord
01:26 < Lunar^> Donc comment on intercale ça dans notre constitution, si on suit l'idée de décoration ?
01:26 <@nil> l'usage est mesuré, pas réalisé
01:26 < Lunar^> C'est bien ça la question ?
01:27 <@nil> pour le disque, on a la chance que unix permet de garantir que l'usage ne depasse pas ce qui est accorde
01:27 <@nil> donc la decoration est en place uniquement sur les modifications du quota
01:27 <@nil> je n'y vois aps de probleme particulier
01:27 < Lunar^> donc notre constitution modifie le modèle ?
01:28 <@nil> non, elle autorise ou non les modifications du modele
01:28 <@nil> non?
01:28 <@nil> ou alors je mixe les notions, neurones flous....
01:28 < Lunar^> ah.. le quota étant un service
01:28 <@nil> oui
01:28 <@nil> non?
01:28 < Lunar^> enfin, le quota disque
01:28 <@nil> l'espace disque max autorise
01:29 < Lunar^> mhh.. alors, faut que je remette tous les bouts ensemble
01:29 < Lunar^> Y a un de nos "use cases" de tout à l'heure qui est pas couvert jec rois
01:30 <@nil> use case = anarchy|single user|alternc1.0|cnt ?
01:30 < Lunar^> On voulait que la constitution puisse limiter la bande passante une fois une certaine quantité consommée
01:30 <@nil> oui
01:30 < Lunar^> (c'est le système des ADSL belges)
01:30 <@nil> mais je ne sais pas concretement ce que permet de faire mod_bandwidth
01:31 < Lunar^> Bah il fera pas des comptes sur un mois, c'est sur
01:31 < Lunar^> ta machine elle peut rebooter à un moment, genre
01:31 <@nil> definir un debit max? une quantite max? un ralentissement?
01:31 < Lunar^> les deux premiers, au moins
01:31 <@nil> ah, c'est mod_bandwidth qui mesure la bp?
01:31 < Lunar^> non, justement
01:32 <@nil> elle est mesuree sur les logs apache + ftp + postfix + dovecot?
01:32 <@nil> (c'est tout ca la bande passante)
01:32 <@nil> (mais on peut se limiter a apache)
01:32 < Lunar^> mh.. disons que le plus simple c'est de faire de l'analyse sur les fichiers AWStats
01:32 <@nil> qui sont archives, pérennes
01:33 < Lunar^> Apache + FTP + Postfix + Dovecot, c'est possible si tu fais un UID unix = un user et que tu utilises iptables 
01:33 < Lunar^> soit le plan über casse-gueule
01:33 <@nil> hmmmm
01:33 <@nil> et ca contraint a une structure user/group rigide
01:34 < Lunar^> ou alors que tu as une IP par Apache + FTP + Postfix + Dovecot
01:34 < Lunar^> ce qui est p'tet par contre plus envisageable « en vrai »
01:34 < Lunar^> genre, tu partages une machine avec 3 potes
01:34 < Lunar^> et tu veux partager les frais de bande passante en fonction de qui à utiliser quoi
01:34 <@nil> ca limite quand meme les cas pratiques
01:35 < Lunar^> chacun son IP, et t'as une constitution que tu peux écrire pour que ça colle
01:35 < Lunar^> (Je cherche des "use cases", hein, c'est comme ça qu'on fait une bonne API ;)))
01:36 < Lunar^> Bon, je me dis que vu qu'on a du code
01:36 <@nil> oui. mais pour 7000 users (ie Globenet), pas possible le plan IP
01:36 < Lunar^> On peut déporter des questions à notre constitution
01:36 <@nil> masi ca reste un des usecase credible
01:36 < Lunar^> et p'tet que getDiskSpace() ça peut le faire
01:37 <@nil> genre
01:37 <@nil> @allow(.....)
01:37 < Lunar^> en même temps... ça veut dire que ça force la constitution à au moins gérer ce truc là
01:37 <@nil> getDistSpace()
01:37 < Lunar^> ah non, plutôt : getDiskspace = constitution.getDiskSpace
01:37 <@nil> la constitution doit pouvoir le gerer
01:38 <@nil> tout ce que la constitution ne gere pas, c'est True
01:38 < Lunar^> ce qui permet à notre modèle de faire converger l'état du système vers le quota voulue par la constitution
01:38 <@nil> constitution.__getatta__(self, attr): return True
01:38 <@nil> constitution.__getattr__(self, attr): return True
01:38 < Lunar^> oui, on peut imaginer ça... si ça renvoie que du vrai/faux
01:38 <@nil> oui
01:39 < Lunar^> À quel point on veut que la constitution soit intelligente ?
01:39 <@nil> ou avoir une constitution "template" qui definit des reponses maximales permissives
01:39 <@nil> et la vraie constitution qui "override"
01:39 < Lunar^> (Si c'est du Python, on peut toujours faire n'importe quoi, mais bon.. on peut l'encourager ou pas)
01:40 <@nil> constitution intelligente....?
01:40 < Lunar^> euh... pour raison de sécurité, je dirais plutôt que tout est touours Faux, m'enfin, on peut faire de l'object et deux super-classes, l'une AllowAll, et l'autre DenyAll
01:40 < Lunar^> ok... restreindre la constitution à regarder dans le modèle et pas ailleurs
01:40 < Lunar^> typiquement, le bout de code qui va parser le fichier d'awstats
01:40 <@nil> pour des raisons politico-philosophiques je dirais que tout ce qui est non specifie par la constitution est True :)
01:40 < Lunar^> est-ce que c'est dans le modèle, ou dans la constitution ?
01:41 < Lunar^> erf... anarchiste, va
01:41 <@nil> erf... meme pas :p
01:41 <@nil> bon
01:42 <@nil> ca ne me gene pas que la constitution n'aie acces qu'a un ensemble predefini d'infos
01:42 < Lunar^> dans un cas, ça veut dire que pour tout un tas de trucs, il faudra aller modifier le modèle
01:42 < Lunar^> ou en tout cas, qu'il soit suffisament extensible pour pouvoir le modifier
01:43 < Lunar^> en même temps, c'est des données dont le daemon se fout
01:43 < Lunar^> ce qui permet d'aborder un autre problème
01:43 < Lunar^> qui est : est-ce que l'interface discute avec la constitution ? Si oui, comment ?
01:43 <@nil> prealable: j'ai pas confiance en l'interface
01:44 < Lunar^> ah oui, tu avais répondu tout à l'heure
01:44 < Lunar^> on veut pouvoir mettre du contrôle d'accès sur les get*
01:44 <@nil> elle peut me raconter des conneries, etre un client hacke dans une archi client-serveur, etc
01:45 < Lunar^> mhhhhhhhhhhhhhhhh
01:45 < Lunar^> Donc, si c'est le modèle qui a l'information que peut vouloir récupérer l'interface ? (Qu'est-ce que j'ai déjà consommé comme BP ou comme espace disque ?)
01:45 <@nil> masi si elle me demande des choses avec les bons credentials et que ces choss sont autorisees par la constitutions, je les commite dans le modele pour le daemon 
01:46 < Lunar^> oui, oui, pour cette partie là, c'est nickel
01:46 <@nil> fr(credentials) = ?
01:46 < Lunar^> mais on revient au problème de tout à l'heure
01:46 < Lunar^> capacité ? clé ?
01:46 <@nil> ah, oui
01:46 < Lunar^> j'ai un truc sur le système qui modifie mon modèle
01:47 < Lunar^> bon.. après, on peut faire de la rhétorique
01:47 < Lunar^> et dire que le modèle, il a le droit d'intérroger le système comme un grand
01:48 < Lunar^> (mais juste intérroger)
01:48 <@nil> euh.. pour poser la question a la constitution?
01:48 <@nil> en lui fournissant toutes les donnes de la question?
01:48 < Lunar^> et pis que s'il a envie de mettre la donné en cache, pourquoi pas, hein, on va pas parser le fichier d'awstats tout le temps
01:48 < Lunar^> je t'ai pas suivi 
01:49 <@nil> pourquoi le modele interrogerait-il le systeme?
01:49 <@nil> pour quoi faire?
01:49 < Lunar^> getDiskUsage() ; getUsedBandwidth()
01:49 <@nil> ah oui
01:49 <@nil> dans ce sens
01:49 < Lunar^> oui
01:50 <@nil> oui, dans ce cas le modele recupere l'info pour la communiquer a l'interface
01:50 < Lunar^> Ok, donc pour cette relation entre système, daemon et modèle, on aurait
01:51 <@nil> 01:46 < Lunar^> capacité ? clé ? <- je ne suis pas, quelle est la question?
01:51 < Lunar^> Le modèle peut intérroger le système (read-only) lorsque c'est là où se trouve le vrai modèle
01:51 < Lunar^> (la traduction de credentials)
01:51 <@nil> ah
01:51 < Lunar^> Le daemon s'assure de faire converger le système vers le modèle
01:52 < Lunar^> en terme unix ça pose un soucis de séparation de droit, mais je crois qu'on pourra s'en préoccuper plus tard
01:53 < Lunar^> manque encore un bout
01:53 <@nil> (roulage de clop)
01:54 < Lunar^> J'ai ma constitution qui peut interroger mon modèle pour connaître la bande passante utilisée
01:54 <@nil> si c'est un critere pour repondre a une question qu'on lui pose
01:55 < Lunar^> Comment est-ce que ma constitution peut modifier l'état du système pour brider les connections une fois le quota dépassé ?
01:55 <@nil> ah
01:55 <@nil> effectivement
01:55 < Lunar^> c'était pour ça, la délégation de tout à l'heure
01:56 < Lunar^> c'est que si c'est la constitution qui répond pour ce paramètre là du modèle
01:56 <@nil> c'est le cas des actions du daemon qui ne repondent pas a une modif du modele
01:56 < Lunar^> bah ça résoud notre problème
01:56 < Lunar^> le daemon interroge le modèle, qui répond, à travers la constitution, le nouveau réglage
01:57 < Lunar^> et donc le daemon fait converger
01:57 < Lunar^> et donc modifie la conf du vhost apache pour ajouter la limitation
01:57 < Lunar^> Si on a des décorateurs
01:57 <@nil> il demande quoi au modele? "etant donne que maintenant le systeme est ceci et cela, que veux-tu changer?"
01:57 < Lunar^> On gère ce cas là gratuitement ! :)
01:58 < Lunar^> ok, je répond et je reviens à mon « Eureka! »
01:58 < Lunar^> Le daemon, au démarrage, il construit un état du système
01:58 < Lunar^> ensuite, il interroge le modèle de fond en comble
01:59 < Lunar^> histoire de se construire un état « modèle »
01:59 < Lunar^> et il fait les modifications nécessaires pour réduire les différences
01:59 < Lunar^> tant qu'il y en a
02:00 <@nil> ok
02:00 < Lunar^> Donc c'est juste lui envoyer un signal pour lui demander de rafraichir sa vision du modèle sur la limitation de la bande passante 
02:01 <@nil> ah oui
02:01 < Lunar^> qui doit envoyer ce signal, haha :)
02:01 <@nil> un timer?
02:01 < Lunar^> Ça peut être juste le modèle lui-même...
02:02 <@nil> la bande passante evolue en continu, faut au moins un timer
02:02 < Lunar^> dans un système MVC, je crois que c'est auprès du modèle que tu t'enregistres pour demander à être prévenu en cas de modif
02:03 < Lunar^> bah en l'occurence, c'est le passage d'AWStats qui te permet de savoir que la donnée a changé, donc c'est pas vraiment un signal continu :)
02:03 < Lunar^> ouh........ mais c'est que ça commence à se tenir cette merde
02:03 < Lunar^> ou alors je suis juste trop crevé maintenant :)
02:04 <@nil> hihi :)
02:04 < Lunar^> ah oui, mon Eureka
02:04 < Lunar^> Si on décore, ça veut dire qu'on peut aller plus loin que du "allow"
02:04 < Lunar^> on peut aussi se substituer à la fonction
02:04 < Lunar^> complètement... c'est ce que fais le require turbogears, hein, il exécute pas du tout la fonction si t'as pas les droits
02:05 <@nil> et il peut en executer une autre a la place?
02:05 < Lunar^> bah tu fais ce que tu veux :)
02:06 <@nil> y'a vait aussi la question du retour d'erreur
02:06 < Lunar^> def id(f): return f
02:06 < Lunar^> je peux aussi faire 
02:06 < Lunar^> def id(f): return "Coincoin!"
02:06 < Lunar^> enfin, c'est pas "id" dans ce cas
02:06 < Lunar^> euh.. ça type pas
02:06 < Lunar^> def coin(f):
02:07 < Lunar^>     def f_(): return "Coincoin!"
02:07 < Lunar^>     return f_
02:07 < Lunar^> j'sais pas si je suis plus clair :D
02:07 < Lunar^> retour d'erreur ?
02:07 <@nil> euh..
02:07 <@nil> pas bcp plus clair
02:08 <@nil> maos pas grave
02:08 <@nil> oui, Vanzetti pose la question de "remontee des erreurs"
02:08 < Lunar^> (décorateur = fonction d'ordre supérieur : je prend une fonction en argument et je dois retourner une fonction... j'ai le droit d'ignorer mon argument)
02:09 <@nil> dans notre truc j'ai l'impression qu'il ne peut pas y avoir d'erreur, ca me semble bizarre :)
02:09 <@nil> (ok)
02:09 < Lunar^> Ce que je vois comme erreurs, c'est assez simple :
02:09 < Lunar^> 403 Forbidden
02:09 < Lunar^> 200 OK
02:09 < Lunar^> ça c'est les retour de l'interface en fonction des accès autorisé ou non par la constitution au modèle
02:10 <@nil> exactement
02:10 < Lunar^> Y a aussi le modèle qui peut dire 
02:10 < Lunar^> ValueError, "Euh... je veux pas d'espace dans les noms de domaines."
02:11 < Lunar^> le dernier type d'erreur, c'est le daemon
02:11 <@nil> c'est un Forbidden avec des details, ca
02:11 < Lunar^> non, c'est pas un forbidden
02:11 < Lunar^> tu as le droit de faire la modification, mais tu me donnes pas les données qu'il me faut
02:11 <@nil> ah oui
02:11 < Lunar^> et donc, le daemon
02:12 < Lunar^> et les erreurs du daemon, c'est soit une erreur système
02:12 < Lunar^> soit une erreur de programmation
02:12 < Lunar^> dans les deux cas, c'est à l'admin sys de la machine de s'y pencher
02:12 < Lunar^> et ça se log, c'est tout
02:12 <@nil> oui, je me dit que beaucoup repose sur la programmation correcte
02:12 <@nil> TOUT repose sur la programmation du modele
02:12 <@nil> faut de l'unittest rock-solide
02:12 < Lunar^> sur le daemon aussi, hein
02:13 <@nil> ah oui, pour la convergence
02:13 < Lunar^> parce que si l'opération de convergence, elle diverge
02:13 < Lunar^> t'es mal
02:13 <@nil> c'est plus une question d'avoir le bon algorithme
02:13 < Lunar^> typiquement :
02:13 < Lunar^> def create_mailbox(login, domain):
02:13 < Lunar^>     os.mkdir('/var/mial/%s/%s' % (domain, login))
02:14 < Lunar^> l'erreur est intentionnel
02:14 < Lunar^> la boite est jamais crée, ça convergera jamais
02:14 <@nil> ca diverge pas, mais on reste a la meme distance du modele
02:14 <@nil> ouaip
02:14 < Lunar^> ok
02:14 <@nil> non, on diverge
02:14 <@nil> espace disque
02:14 < Lunar^> tu peux faire pire avec du os.unlink() ;)
02:15 < Lunar^> Ce que je vois comme énorme intérêt à une telle architecture
02:15 < Lunar^> c'est qu'elle offre la flexibilité que les gens ont envie
02:15 < Lunar^> parce que dans le daemon et dans le modèle, tu peux rajouter les services que tu veux
02:16 < Lunar^> implémentés avec les outils que tu veux
02:16 <@nil> et tu peux utiliser la constitution que tu veux, aussi
02:16 <@nil> en prendre une classique, ou te faire la tiennne
02:16 < Lunar^> oui, oui, j'étais sur l'histoire de convergence
02:16 < Lunar^> mais ce truc de constitution, c'est über bien
02:17 < Lunar^> Là on a un argument pour dire qu'il faut un langage qui soit capable de faire de l'ordre supérieur
02:17 <@nil> euh, faut pas que le daemon publie la liste des parametres du systeme qu'il maitrise?
02:17 < Lunar^> donc pas PHP
02:17 <@nil> :p
02:17 <@nil> tout ca pour ca :D
02:17 < Lunar^> hihi
02:17  * Lunar^ hides
02:18 < Lunar^> comment ça publier ?
02:18 <@nil> euh, non
02:18 <@nil> c'est la responsabilite du root de mettre en place une constitution coherente avec les capacites du daemon
02:18 < Lunar^> oui
02:19 < Lunar^> il faut quand même prévoir une lib standard de constitution
02:19 < Lunar^> typiquement pour pouvoir généraliser des trucs à tout les services
02:19 < Lunar^> donc, oui, faut que tu puisses introspecter le modèle pour regarder quelles méthodes il propose
02:20 < Lunar^> +1 pour Python ou Ruby
02:20 <@nil> hmmm... manque rien la-dedans?
02:20 < Lunar^> une synthèse, au moins :)
02:21 < Lunar^> On peut essayer de la faire ensemble à coup de Gobby demain, p'tet
02:21 <@nil> oui... la backlog irc est long...
02:25 <@nil> ouais, poste le log en vrac, pour l'instant, ca fait un point de depart (touffu)
02:25 < Lunar^> oui
02:26 <@nil> une sorte de spec_rc1_alpha
02:26 <@nil> (mouais, pas vraiment)
-------------- section suivante --------------
Une pièce jointe autre que texte a été nettoyée...
Nom: signature.asc
Type: application/pgp-signature
Taille: 189 octets
Desc: Digital signature
URL: <http://lists.alternc.org/arch/dev/attachments/20061208/4519f473/attachment.pgp>


Plus d'informations sur la liste de diffusion Dev