Ceci dit, ça aurait pu être moins pire : le bureau aurait pu être vernis.

Calme, cool, zeeen, lexomiiil.

Bon, déjà, pour les plus retardés niveau information, Dedibox nous ont livrés le serveur le mercredi 30 au soir. Au passage, nous avons dû resouscrire l’ancien serveur pour un mois vu le peu de temps entre la livraison du nouveau serveur et la fin du contrat de l’ancien. Depuis la livraison, Sunny et moi avons pas mal travaillé sur le serveur. Pour l’instant, voila ce qui est fait :

• Le serveur (en lui même) : Il est installé, sous Debian Etch (la dernière stable donc), et plus ou moins configuré. Il manque surtout des outils de monitoring et un poil de sécurité (en gros, de la remontée d’informations).
• Le DNS : Contrairement à avant, nous avons décidés d’utiliser notre propre DNS pour éviter les problèmes que l’on a eu avec XName. Il est installé, configuré, ainsi que le DNS secondaire fournit par dedibox.
• Le serveur web : Comme avant, on utilise Lighttpd sur Bearnaise. Le serveur est configuré, et les outils pour créer vos virtuals hosts sont pratiquement terminés (je publierais un billet pour vous aider à les utiliser bientôt).
• Le serveur de mail : Tout comme avant, Postfix comme serveur smtp. Je suis passé à Dovecot pour le serveur imap4 (pas encore configuré le pop3, mais vu que personne l’utilise…). Le serveur est aussi accessible par SSL pour les paranos (pour moi quoi :)).
• Jabber : Je me suis aussi occupé de migrer le serveur Jabber. Ça m’a l’air de fonctionner même si il y a quelques trucs un chouilla bizarres qui se produisent.
• MySQL : Il est installé, rien de particulier à dire dessus.

Ce qu’il manque

• La migration du SVN : et des tracs. Mais ça ne devrais pas être trop difficile…
• Monitoring & Sécu
• L’écriture du reste des outils : Pour l’instant les outils pour gérer les vhosts sont pratiquement terminé, un outil pour créer un domaine sur le DNS aussi. Il manque un moyen de gérer les comptes mails, les bdd mysql etc.
• Finitions : création de vos comptes, documentation, faire un joli motd (si vous avez des idées pour ça) etc/

Bref, c’est pour très bientôt, encore un peu de patience :-)

L’idée est de faire un analyseur de logs extremement modulaire afin de pouvoir ajouter ou retirer à souhait les traitements qui seront effectués sur les fichiers. Pour résumer le fonctionnement, il y a d’un coté des modules d’analyse genre “visiteurs”, “referers”, “hits”, etc. qui s’occupent de collecter des données sur chaques lignes des fichiers de logs. De l’autre coté, un module de rendu (genre “html”, “mail”, “texte”) qui lui s’occupe comme son nom l’indique si bien, du rendu du rapport de résultats.

Le projet est déjà bien entamé, et je compte releaser une première version très bientôt. J’ai fais quelques tests de performances pour avoir une idée (pour l’instant, ce n’est pas optimisé). Condition des tests : sur mon portable, Core Duo 1.66Ghz, 1Go de RAM (mais l’utilisation par le programme de la ram était minime), fichiers de logs du serveur http de Bearnaise, un peu plus d’un an pour 1231699 lignes.

Test #1

Traitement des lignes relatives au domaine “inaps.org” avec un seul module d’analyse actif et en mode verbeux : time python s.py -m inaps.org -d 01012006 -e 99999 -v html visitors logs/*

Résultat : 132.91user 0.58system 2:16.75elapsed 97%CPU (0avgtext+0avgdata 0maxresident)k

Test #2

Traitement des lignes relatives a tous les domaines avec un seul module d’analyse actif et en mode verbeux : time python s.py -d 01012006 -e 99999 -v html visitors logs/*

Résultat : 144.67user 4.52system 2:33.67elapsed 97%CPU (0avgtext+0avgdata 0maxresident)k

Test #3

Traitement des lignes relatives a tous les domaines avec deux modules d’analyse actifs et en mode verbeux : time python s.py -d 01012006 -e 99999 -v html visitors,referers logs/*

Résultat : 168.98user 5.69system 3:05.21elapsed 94%CPU (0avgtext+0avgdata 0maxresident)k

Test #4

Traitement des lignes relatives a tous les domaines avec deux modules d’analyse actifs et en mode silencieux : time python s.py -d 01012006 -e 99999 -q html visitors,referers logs/*

Résultat : 155.58user 0.24system 2:35.86elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k

Même si ces tests ne sont pas hyper démonstratifs (ils dépendent des modules activés), ils donnent quand même une idée de la vitesse d’exécution du truc (il faudrait que je regarde ce qui se fait à coté).

Si certains ont des suggestions, elles sont les bienvenues…

• L’option illimitée l’est, mais pas pour plus de 500Mo par mois, au delà, c’est 1 euro par Mo
• L’option illimitée limite son utilisation sur le mobile, les ordinateurs et PDA ne doivent pas utiliser le mobile comme modem (cela dit, ce n’est pas une limitation technique).
• L’option illimitée est limitée au port 80 et 110 (pop3). Pour l’https, on doit passer par un proxy Bouygue, le reste, c’est nada. Exit donc l’utilisation d’SSH, Jabber, IRC, ou même simplement d’IMAP.
• Enfin, l’option illimitée limite la taille maximum des fichiers que l’on peut télécharger à 600Ko, au delà, la connexion au serveur se coupe.

Si c’est pas du joli foutage de gueule tout ça…

Flemme de me relire ce soir, je ferais ça demain…

SteamPresence est un petit programme que j’ai réalisé avec l’aide de Sunny (pour la classe SteamPresence qui parse tout le caca juteux du site de Steam). Ce programme permet de garder un oeil sur ses amis gamers inscrits sur steam pour les rejoindres quand ils sont en train de jouer. Une fois lancé, il se place dans la zone de notification et affiche une bulle verte ou rouge selon l’état de l’ami.

Comment ça marche ?

C’est très simple, il suffit de lancer le programme avec comme seul et unique argument l’identifiant de l’ami sur steam community. Par exemple, l’adresse de mon profil est http://steamcommunity.com/id/grillepain, mon identifiant est “grillepain”. Il faut donc que je lance le programme comme ceci : ./steam_presence.py grillepain.

Sous gnome, vous pouvez utiliser les “programmes au démarrage” pour lancer automatiquement steam_presence. Je n’ai pas testé sur d’autres environnements.

Sous Windows le programme fonctionne mais ne permet pas d’afficher le menu (je corrigerais ce bug à l’occasion).

Et techniquement ?

Techniquement parlant, ce programme est fait en Python (étonnant ;)) avec PyGTK (sans glade cette fois, pas utile). Pour sa classe SteamPresence, Sunny à utilise Beautiful Soup, un module python qui permet de parser “facilement” du html tout crado. Ah oui, et il est sous GPL.

Je trouve ça où ?

Deux moyens, le SVN :

La version de développement :

svn checkout svn://dev.inaps.org/inaps/steam_presence/trunk/ .

La release 1.0 :

svn checkout svn://dev.inaps.org/inaps/steam_presence/tags/1.0/ .

Le ftp/http :

Direction le miroir bearnaise en ftp ou http, choisisez l’archive qui vous convient.

>>> liste = ['Python', 'c\'est', 'bon']
>>> iterateur = liste.__iter__()
>>> iterateur
<listiterator object at 0x808968c>
>>> iterateur.next()
'Python'
>>> iterateur.next()
"c'est"
>>> iterateur.next()
'bon'
>>> iterateur.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Comme vous pouvez le constater, chaque liste possède une méthode __iter__() qui retourne un objet iterator. Cet objet peut aussi être obtenu grace à la primitive iter(objet). On peut donc conclure qu’un objet itérable est un objet qui possède une méthode __iter__() qui retourne elle même un objet iterator.

En python, on ne se soucie pas de savoir si tel objet est de tel type, mais plutôt de savoir si l’on peut faire telle chose avec tel objet. On appel cela le duck typing : “Si ça marche comme un canard, que ça fait coin coin comme un canard, alors on peut appeler ça un canard”. Il est donc possible de créer très simplement un itérateur, et par extension un objet itérable :

>>> class Iterateur:
...     i = 0
...     def next(self):
...             if self.i >= 10: raise StopIteration
...             self.i += 1
...             return 2**self.i
...     def __iter__(self): return self
...
>>> objet_iterateur = Iterateur()
>>> for i in objet_iterateur: print i
...
1
2
4
8
16
32
64
128
256
512

Les générateurs

Les générateurs sont une manière de créer des itérateurs. Il existe deux moyens d’utiliser les générateurs : au travers d’une fonction en utilisant le mot clé yield au lieu de return et en utilisant les “generator expressions” qui ressemblent à la définition de liste par “list comprehension”.

Puisqu’un petit exemple vaut mieux qu’un beau discours :

>>> def iterateur():
...     for i in xrange(10):
...             yield 2**i
...
>>> for i in iterateur(): print i
...
1
2
4
8
16
32
64
128
256
512

Et de manière plus concise avec les “generator expressions” (voir mon billet sur la compréhension de liste pour voir des exemples de la syntaxe générale, le seul différence résidant dans l’utilisation des parenthèses au lieu des crochets) :

>>> for i in (2**x for x in xrange(10)): print i
...
1
2
4
8
16
32
64
128
256
512

Comprendre les itérateurs et les générateurs permet de rendre son code plus concis et de mieux comprendre le fonctionnement de Python avec les objets itérables.

A voir

• Pleins d’exemples sur l’utilisation des generators et des generators expressions (via David)

Une liste, comme un ensemble, peut-être définie par la donnée d’une propriété caractéristique de ses éléments, on dit qu’on l’a définie en compréhension. Comme cette construction offre des avantages de lisibilité et de concision, certains langages de programmation proposent donc la possibilité de définir une liste par une propriété caractéristique et l’on appelle cela la compréhension de liste.

Avant de débuter avec les exemples, voici la grammaire des compréhension de liste en Python telle qu’elle est donnée dans la documentation :

test 	 	::=  	and_test ( "or" and_test )* | lambda_form
testlist 	::= 	test ( "," test )* [ "," ]
list_display 	::= 	"[" [listmaker] "]"
listmaker 	::= 	expression ( list_for | ( "," expression )* [","] )
list_iter 	::= 	list_for | list_if
list_for 	::= 	"for" expression_list "in" testlist [list_iter]
list_if 	::= 	"if" test [list_iter]

Exemple 1 : équivalence à map :

Trouver les 10 premières puissances de 2, avec map :

map(lambda x: 2**x, xrange(10))

Avec la compréhension de listes :

[2**x for x in xrange(10)]

Exemple 2 : équivalence à filter :

Trouver les nombres pairs parmis les nombres de 0 à 9, avec filter() :

filter(lambda x:x%2 == 0, xrange(10))

Avec la compréhension de listes :

[x for x in xrange(10) if x%2==0]

Exemple 3 : les deux à la fois :

Trouver la puissance de deux des nombres pairs de 0 à 9 (oui c’est totalement inutile), avec map() et filter() :

map(lambda x:2**x, filter(lambda x:x%2==0, xrange(10)))

Et avec les compréhension de listes :

[2**x for x in xrange(10) if x%2==0]

Un peu plus compréhensible non ?

Exemple 4 : Renvoyer plusieurs résultats

On reprend l’exemple des puissances de deux, mais on veut renvoyer cette fois ci, à la fois le nombre calculé, et sa puissance :

[(x, 2**x) for x in xrange(10)]

Et avec un for pour gérer l’affichage :

for n, v in [(x, 2**x) for x in xrange(10)]:
     print "2^%s = %s" % (n, v)

Résultat :

2^0 = 1
2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64
2^7 = 128
2^8 = 256
2^9 = 512

Pratique !