ZenTech

La tu me vois, là tu me vois plus

hr — Wed, 25 Jun 2008 14:38:00 +0200

Depuis quelques temps j'avais un petit problème avec mon pavé numérique sur ma hardy, plus rien ne fonctionnait correctement. Le problème est simple à rêgler, dans le menu Système > Préférences > Clavier, onglet Touches de la souris il suffit de désactiver Permettre le contrôle du pointeur par le clavier. Cette option est également contrôlée par la combinaison de touches Shift + Verr Num.

Un robot en date et heure

hr — Sat, 14 Jun 2008 20:30:00 +0200

C'est un classique et je veux vous en faire profiter, il n'y a pas de raison. Une petite tâche dans crontab qui a besoin de la date courante et *pouf* des messages d'erreur incompréhensibles :

Syntax error: end of file unexpected (expecting ")")

C'est parti pour une petite investigation.

Ma ligne crontab ressemble à quelque chose comme ce qui suit :

59 23 * * *     /home/hr/codaz/script.py $(date +%Y%m%d)

Rien de bien sorcier pourtant, je fournis simplement la date courante à un script qui est lancé à 23h59 tous les jours. Et pourtant la source du problème est abordée dans la page de man de crontab(5) :

     The ``sixth'' field (the rest of the line) specifies the command to be
     run.  The entire command portion of the line, up to a newline or % char-
     acter, will be executed by /bin/sh or by the shell specified in the SHELL
     variable of the cronfile.  Percent-signs (%) in the command, unless
     escaped with backslash (\), will be changed into newline characters, and
     all data after the first % will be sent to the command as standard input.

Il faut donc toujours penser à échapper les caractères '%' dans une ligne de crontab pour éviter ce type de soucis, ma ligne devient donc :

59 23 * * *     /home/hr/codaz/script.py $(date +\%Y\%m\%d)

Je ne devrais plus oublier cette fois-ci!

Je te casse et tu ne peux rien y faire

hr — Tue, 29 Apr 2008 12:29:00 +0200

Je viens de découvrir une option assez sympathique qui se trouve, je crois, dans les S60 (vérifié sur un nokia e61i et un e65). Il est possible de bloquer son téléphone à distance grâce à un SMS en cas de perte. L'option se configure dans menu > Outils > Paramètres > Sécurité > Téléphone et carte SIM > Autoriser verrouillage distant. A partir de là, on définit un message qui, lorsque reçu par SMS, va provoquer le bloquage du téléphone. Un autre code, à taper sur le téléphone, permet de le déverouiller. Plutôt cool je trouve.

clic clac kodak

hr — Sat, 19 Apr 2008 19:56:00 +0200

Mon premier réflexe a été de trouver un logiciel me permettant de faire des captures d'écran de mon e61i pour agrémenter les billets le concernant. J'ai trouvé un logiciel s'appelant tout simplement screenshot, ayant le bon goût d'être sous license GPL. Le billet précédent est illustré par une de ces captures.

In the pocket

hr — Fri, 18 Apr 2008 12:22:00 +0200

Je me suis récemment acheté un nokia e61i (récemment chez moi c'est moins de 6 mois ... *kh*). Ce choix, en pleine folie iphone, repose sur différents critères :

véritable clavier (azerty)
3G (haha ... mais non c'est une fonction de l'iphone)
symbian (pas de windows mobile)
grand écran
wifi

Ce téléphone est associé à un abonnement 3G+ illimité (il me manque le '+' ::/) qui devrait me permettre de rester connecté au fabuleux interweb.

La première application que j'ai installée sur ce téléphone est screenshot qui me permettra de prendre de jolies photos de mon téléphone.

Sauvez du papier, mangez OpenOffice.org

hr — Wed, 09 Apr 2008 18:48:00 +0200

En réponse à une préoccupation sur la consommation de papier lors de l'impression de documents, je me demande souvent comment imprimer 2 pages par feuille dans OpenOffice.org.

Il faut de tout évidence commencer par ouvrir le document à imprimer. Ensuite, accéder à l'aperçu avant impression via Fichier > Aperçu. Dans l'aperçu il y a un bouton nommé "Options d'impression; aperçu" à gauche du bouton "Fermer l'aperçu". Ce bouton donne accès à une interface de préférences d'impression pour l'aperçu, en choisissant simplement Format > Paysage et en conservant le nombre de colonnes à 2 on obtient le résultat recherché. Il suffit maintenant d'imprimer l'aperçu en utilisant le bouton à gauche de "Options d'impression: aperçu" utilisé précédemment.

Qui est le plus fort entre l'éléphant et l'hippopotame

hr — Wed, 02 Apr 2008 15:31:00 +0200

Je me pose toujours des questions de performance lorsque je développe. Il y a souvent plusieurs façons de rêgler un problème et certaines plus consommatrices de ressources que d'autres. Dans le cas qui m'intéresse, je me questionne sur la performance des expressions régulières en regard d'autres méthodes de traitement de chaîne. Je dois effectuer un traitement sur un très grand nombre de lignes de log au fur et à mesure de leur émission en syslog.

La plupart du temps avec python, avoir une idée innovante est modérée par l'existence d'un module qui couvre déjà le sujet. Dans ce cas, le module timeit va me permettre de tester la rapidité d'exécution de différents bouts de code.

Le format d'une ligne de log syslog est connu et décrit par la RFC3164, ce format me permet différentes approches pour en extraire différents champs. Dans mon cas, je vais extraire le champ appelé HEADER de différentes façons. Un ligne de log syslog doit être de la forme :

<     >TIMESTAMP HOSTNAME TAG CONTENT
| PRI |      HEADER      |    MSG

Dans le code python ci-dessous, les trois fonctions testées sont :

split() qui récupère le champ header en effectuant un split sur le caractère espace et en réunissant les champs résultants.
match() effectue une sélection par expression régulière.
match_full() effectue une capture par expression régulière et occurence nommée.

Il est important de bien faire attention au contexte et à la portée des variables et fonctions ("scope" et "namespace") lorsqu'on utilise timeit.

import timeit

def split():
    str = '<22>Mar 27 16:13:35 192.168.1.1 mx-daemon[2754]: m2RFDTbw002754: from=<j.doe@nowhere.com>, size=3356, class=0, nrcpts=1, msgid=<000701c8902d$04cb7356$879fa6b4@epwlhnj>, proto=ESMTP, daemon=MX, relay=[192.168.1.2]'
    ' '.join(str.split()[0:4]).split('>')[1]

def match():
    import re
    pattern = r'^<(\d+)>(\w{3} (?: |\d)\d \d\d:\d\d:\d\d [\w:.]+) (\w+.+)'
    _pattern = re.compile(pattern)
    str = '<22>Mar 27 16:13:35 192.168.1.1 mx-daemon[2754]: m2RFDTbw002754: from=<j.doe@nowhere.com>, size=3356, class=0, nrcpts=1, msgid=<000701c8902d$04cb7356$879fa6b4@epwlhnj>, proto=ESMTP, daemon=MX, relay=[192.168.1.2]'
    _pattern.search(str).group(2)

def match_full():
    import re
    pattern_full = r'^<(?P<pri>\d+)>(?P<header>\w{3} (?: |\d)\d \d\d:\d\d:\d\d [\w:.]+) (?P<msg>\w+.+)'
    _pattern_full = re.compile(pattern_full)
    str = '<22>Mar 27 16:13:35 192.168.1.1 mx-daemon[2754]: m2RFDTbw002754: from=<j.doe@nowhere.com>, size=3356, class=0, nrcpts=1, msgid=<000701c8902d$04cb7356$879fa6b4@epwlhnj>, proto=ESMTP, daemon=MX, relay=[192.168.1.2]'
    _pattern_full.search(str).groupdict()['header']

print "split:"
print timeit.Timer("split()", "from __main__ import split").timeit()
print "match:"
print timeit.Timer("match()", "from __main__ import match").timeit()
print "match_full:"
print timeit.Timer("match_full()", "from __main__ import match_full").timeit()

Ce qui donne après exécution :

$ python stress.py
split:
6.14724898338
match:
14.80702281
match_full:
19.0696430206

En y réfléchissant bien, les fonctions testées ne sont pas vraiment optimisées et ne sont pas donc comparables en vitesse d'exécution. Pour vraiment jouer sur un pied d'égalité, je procède aux modifications suivantes :

Import du module re en début de script, ça fonctionne finalement, j'avais peur que les problèmes de contexte de timeit ne posent problème.
La compilation des expressions régulières est faite une fois pour toute et pas à chaque lancement des fonctions cmatch() et cmatch_full()
Introduction de deux nouvelles fonctions effectuant une capture par expression régulière sans compilation de l'expression.
Utilisation de la méthode repeat() plutôt que timeit() pour essayer d'obtenir un résultat moins influencé par le fonctionnement du système.

import re, timeit

str='<22>Mar 27 16:13:35 192.168.1.1 mx-daemon[2754]: m2RFDTbw002754: from=<j.doe@nowhere.com>, size=3356, class=0, nrcpts=1, msgid=<000701c8902d$04cb7356$879fa6b4@epwlhnj>, proto=ESMTP, daemon=MX, relay=[192.168.1.2]'

split_init = """from __main__ import split"""
match_init = """from __main__ import match"""
match_full_init = """from __main__ import match_full"""
cmatch_init = """from __main__ import cmatch"""
cmatch_full_init = """from __main__ import cmatch_full"""

pattern = r'^<(\d+)>(\w{3} (?: |\d)\d \d\d:\d\d:\d\d [\w:.]+) (\w+.+)'
pattern_full = r'^<(?P<pri>\d+)>(?P<header>\w{3} (?: |\d)\d \d\d:\d\d:\d\d [\w:.]+) (?P<msg>\w+.+)'
_pattern = re.compile(pattern)
_pattern_full = re.compile(pattern_full)

def split():
    ' '.join(str.split(' ')[0:4]).split('>')[1]

def match():
    re.search(pattern, str).group(2)

def match_full():
    re.search(pattern_full, str).groupdict()['header']

def cmatch():
    _pattern.search(str).group(2)

def cmatch_full():
    _pattern_full.search(str).groupdict()['header']

print "Testing %d occurences of each match, %d times" % (timeit.default_number, timeit.default_repeat)
split_result = timeit.Timer("split()", split_init).repeat()
print "split: %fs %s" % (min(split_result), split_result)
match_result = timeit.Timer("match()", match_init).repeat()
print "match: %fs %s" % (min(match_result), match_result)
match_full_result = timeit.Timer("match_full()", match_full_init).repeat()
print "match_full: %fs %s" % (min(match_full_result), match_full_result)
cmatch_result = timeit.Timer("cmatch()", cmatch_init).repeat()
print "cmatch: %fs %s" % (min(cmatch_result), cmatch_result)
cmatch_full_result = timeit.Timer("cmatch_full()", cmatch_full_init).repeat()
print "cmatch_full: %fs %s" % (min(cmatch_full_result), cmatch_full_result)

Qui me donne les résultats suivants :

$ python stress.py
Testing 1000000 occurences of each match, 3 times
split: 5.818318s [5.8183181285858154, 6.5981872081756592, 6.327794075012207]
match: 8.220056s [8.2262570858001709, 8.2361149787902832, 8.2200560569763184]
match_full: 12.399510s [12.40582799911499, 12.399509906768799, 12.501888036727905]
cmatch: 3.818037s [3.8180370330810547, 3.8276369571685791, 3.8310809135437012]
cmatch_full: 6.724747s [6.7247469425201416, 6.7392361164093018, 6.7564170360565186]

Il est surprenant de constater la différence énorme entre les expressions régulières compilées et non compilées, l'avantage de compiler ses expressions dans le cas d'une utilisation de masse est évident. La rapidité de split() est plutôt décevante par rapport à l'utilisation des expressions régullières.

Ces tests sont intéressant et donnent des indications de performance mais ne remplacent pas des tests complet de profilage.

C'est curieux chez les marins ce besoin de faire des phrases

hr — Tue, 18 Mar 2008 15:47:00 +0100

Suite à une remarque judicieuse j'ai été obligé de gérer un petit cas particulier qui conduisait à un conflit. Le script sed est maintenant modifié, ce n'est pas extrêmement propre mais c'est assez efficace. Le bout du script concerné est :

# remove /* */ comments, multiline or not
/\/\*/{
    # special case of /*/ starting comments that fools the next test
    s:/\*/:/\* /:
    :mline
    /\*\// {
        s:/\*.*\*/::
        b mlineend
    }
    N
    b mline
}
:mlineend

Pour en finir avec Lulu la Nantaise

hr — Mon, 17 Mar 2008 12:32:00 +0100

Au final, je me suis occupé des espaces, le but de ce script étant au départ de fournir un code nettoyé qui pourra passer au banc des statistiques. Le script sed est disponible et placé sous license type *BSD. Quelques corrections d'erreur et de nouvelles fonctions constituent cette dernière version du script.

J'utilise un petit fichier de définition test.h :

/*
 * Big story here
 * my life
 */
// one line
#define HEHE 1

/* includes */
#include "blah"
#include "foo" // end line comment

#include /* weird comment */ "pouet"
int woop /* to see */
/* let's continue with weird comments */ void sigpipe_handle(int);

/*-------------
  bloh
---------------*/
int main(int argc, char **argv);
int parseCommandLine(int argc, char* argv[]);

Ce qui donne, une fois passé par sed :

$ sed -nf ccmtstrip.sed test.h
#define HEHE 1
#include "blah"
#include "foo"
#include "pouet"
int woop
void sigpipe_handle(int);
int main(int argc, char **argv);
int parseCommandLine(int argc, char* argv[]);

Les commentaires déssoudés par Jo le trembleur

hr — Sat, 15 Mar 2008 21:21:00 +0100

La version précédente du script sed ne me convenait pas. Elle ne gérait pas certaines formes de commentaires horribles, qui mériterait une sentence extrême et douloureuse. C'est maintenant chose rêglée avec une version améliorée.

#!/usr/bin/sed -nf

# remove single line comments
/^\/\//d

# remove /* */ comments, multiline or not
/\/\*/{
    :mline
    /\*\// {
        s:/\*.*\*/::
        b mlineend
    }
    N
    b mline
}
:mlineend

# remove empty lines
/^$/d

p

Il peut arriver que certains espaces inutiles apparaissent dans le code suite à la suppression des commentaires multiligne mais ce n'est pas fondamentalement un problème.

Du C par Teddy de Montreal

hr — Fri, 14 Mar 2008 17:25:00 +0100

" ... un fondu qui travaillait qu'à la dynamite." Je me suis mis en tête de compter le nombre de lignes efficaces d'un développement en C. Par ligne efficace j'entends le nombre de lignes de code vraiment compilées. Je dois donc éliminer les commentaires sous leurs diverses formes et les lignes blanches. Et comme j'aime bien me faire mal, au lieu de faire ça en 10 minutes en Perl ou Python, je l'ai fait grâce à sed(1).

Ce script sed doit donc gérer les lignes blanches, les commentaires sur une ligne commençant pas '//', les commentaires sur plusieurs lignes (ou pas) du type /* comment */. Ca donne alors le script suivant :

#!/bin/sed -nf

# remove empty lines
/^$/d
# remove single line comments
/^\/\//d

# remove /* */ comments, multiline or not 
/\/\*/{
    :mline
    /\*\//b mlineend
    N
    b mline
    :mlineend
    d
}
p

Le seul passage qui me semble nécessiter une explication est celui qui gère les commentaires sur plusieurs lignes. Ce qui est fait là est assez simple (sisi c'est vrai) : on ne traite que les lignes comprenant '/*', si la ligne comprend aussi '*/' on passe à la balise mlineend, sinon on ajoute la ligne suivante aux lignes déjà lues et on passe à la balise mline (boucle). Le saut à la balise mlineend provoque la destruction des lignes lues et le passage à la ligne suivante en recommençant le script.
On finit par afficher la ligne (grâce à 'p') si aucun des cas précédents ne s'est produit.

Le défaut de ce script est de ne pas gérer les cas où les commentaires sont mixés avec du code. Je pense l'améliorer dans un deuxième temps pour prendre en compte ces cas.

Mise à jour: une nouvelle version de ce script règle ces soucis.

Booooooonjouuuuuuuuuuuur jeee m'aaaappeeeeeeeeeeeeelle Dooooooooriiiiiiiiiiiis

hr — Thu, 13 Mar 2008 15:54:00 +0100

Suite à la configuration de net-snmp pour utiliser des scripts, il a bien fallu coder un compteur 32bits. Aimant les défis, je me suis décidé à écrire un compteur 32 bits en bash qui compte les entrées d'une base de donnée.

Comment doit fonctionner un compteur 32 bits en script :

Le compteur est un entier modulo 2^32
Le compteur augmente uniquement de la différence de valeur entre deux requêtes
Le compteur doit être conservé entre deux requêtes

Pour implémenter le modulo, ce n'est pas très compliqué en bash/sh :

$(($count % 2**32))

J'ai choisi de stocker les données dans un tableau bash. Pour conserver les données entre 2 appels, je stocke directement le tableau dans un fichier sous la forme d'une définition de tableau bash. De cette façon, je peux inclure le fichier au début de mon script et j'évite d'avoir à lire un fichier de donnée. Les données que je conserve sont le résultat de ma dernière requête SQL, la différence entre la dernière requête et la précédente, et finalement mon compteur. Pourquoi conserver le dernier résultat ? Ca me permet au passage de choisir le comportement du compteur entre compteur 32 bits et donnée directe (gauge).
La requête SQL est tout simplement un count(*) sur une table, le nombre de lignes de cette table peut augmenter ou diminuer (si il ne faisait qu'augmenter, je pourrais directement prendre le count(*) modulo 2^32).

#!/bin/sh

counters='pgcount.txt'
# call the counters
if [ -f $counters ]; then
    . $counters
else
    # last count / last diff / counter
    count=(0 0 0)
fi

# adds 2 values
# return the sum modulo 2**32
counter() {
    counter=$(($1 + $2))
    echo -n $(($counter % 2**32))
}

# dumps the values as bash arrays
dump() {
    echo "count=(${count[@]})" > $counters
}

getdata() {
    count=($@)
    rows=$(getcount $table)
    if [ "${count[1]}" -ne "$count" ]; then
        count[1]=$(($rows - ${count[0]}))
        count[0]=$rows
        count[2]=$(counter ${count[2]} ${count[1]})
    fi
    # return needed values
    echo ${count[@]}
}

count=($(getdata ${count[@]}))
dump()

La fonction getcount() effectue le count(*) et retourne le nombre de lignes lues.

Ce script est lancé toutes les minutes car la requêtes peut parfois prendre du temps et provoquer un timeout snmp. Mon serveur net-snmp appelle donc un bête script qui inclut le fichier de sauvegarde et renvoit les données sauvées.

#!/bin/sh

counters='pgcount.txt'
# call the counters
if [ -f $counters ]; then
    . $counters
else
    # last count / last diff / counter
    count=(0 0 0)
fi

echo ${count[1]}
echo ${count[2]}

En sélectionnant la donnée que je veux dans mon chemin snmp je peux obtenir le nombre de lignes insérées sous forme de compteur 32 bits ou le nombre de lignes insérées entre deux exécutions du scipt. Cette dernière valeur est bancale puisqu'elle ne représente pas le nombre de lignes insérées entre deux consultations du compteur. Il serait possible de le faire fonctionner correctement si le script de lecture réécrivait le fichier de sauvegarde à chaque lecture pour signifier qu'il a été consulté. Il faudrait alors implémenter un verrou sur ce fichier pour éviter qu'il soit utilisé par les 2 scripts en même temps.

NB: Désolé pour le titre du post, je ne trouvais rien de plus inspiré mais un compteur 32bits c'est un peu comme Doris, au bout d'un certain temps, il revient à zero. Oui, je sais ...

All your poll are belong to us

hr — Wed, 05 Mar 2008 18:36:00 +0100

J'ai aujourd'hui besoin de tenir à l'oeil certaines valeurs sur un serveur, le plus simple semble d'utiliser net-snmp et mrtg. Ce serveur SNMP peut être très facilement étendu, mais est assez mal documenté à mon goût. Je vais donc faire un petit tour des méthodes simples d'utilisation de net-snmp pour récupérer des données non communes.

Les versions de net-snmp et mrtg installées sur ma debian etch sont snmpd (5.2.3-7etch2) et mrtg (2.14.7-2). Je suppose que vous êtes à l'aise avec le concept de SNMP et que net-snmp et mrtg sont configurés.
En faisant le tour du site web, du fichier de configuration par défaut et de goo^Winternet, j'ai pû lister les méthodes suivantes :

exec
extend
pass

Je passe sur l'utilisation de subagent qui est plus complexe.
Le script que je vais utiliser tient en 2 lignes et se trouve dans /tmp/test_snmp :

#!/bin/sh
echo 42

Pour information, le fichier /usr/share/snmp/mibs/UCD-SNMP-MIB.txt indique que l'OID 2021 correspond à ucdavis et se trouve après le noeud enterprise (ce qui donne .1.3.6.1.4.1.2021). Cet OID sera utilisé pour ajouter de nouvelles données en test, en réalité il faudrait utiliser un OID correspondant à l'environnement d'utilisation (un OID d'entreprise délivré par IANA par exemple).

`exec`

[...]
exec test1 /tmp/test_snmp
exec .1.3.6.1.4.1.2021.60 test2 /tmp/test_snmp
[...]

Après redémarrage, on vérifie que les données sont bien accessibles en SNMP :

$ snmpwalk -v 1 -c private localhost .1.3.6.1.4.1.2021
[...]
UCD-SNMP-MIB::extIndex.1 = INTEGER: 1
UCD-SNMP-MIB::extNames.1 = STRING: test_snmp
UCD-SNMP-MIB::extCommand.1 = STRING: /tmp/test_snmp
UCD-SNMP-MIB::extResult.1 = INTEGER: 0
UCD-SNMP-MIB::extOutput.1 = STRING: 42
UCD-SNMP-MIB::extErrFix.1 = INTEGER: 0
UCD-SNMP-MIB::extErrFixCmd.1 = STRING:
[...]
UCD-SNMP-MIB::ucdavis.60.1.1 = INTEGER: 1
UCD-SNMP-MIB::ucdavis.60.2.1 = STRING: "test_snmp"
UCD-SNMP-MIB::ucdavis.60.3.1 = STRING: "/tmp/test_snmp"
UCD-SNMP-MIB::ucdavis.60.100.1 = INTEGER: 0
UCD-SNMP-MIB::ucdavis.60.101.1 = STRING: "42"
UCD-SNMP-MIB::ucdavis.60.102.1 = INTEGER: 0
UCD-SNMP-MIB::ucdavis.60.103.1 = ""
[...]

La première forme est plus explicite et la deuxième forme est mieux maitrisée puisqu'on choisit l'OID destination.

Le problème est que le serveur snmp n'est pas très satisfait de l'utilisation de exec :

[...]
Mar  4 17:28:45 snmp.priv snmpd[8678]: /etc/snmp/snmpd.conf: line 363: Error: Warning: relocatable 'exec' format will change in a future release - See 'NET-SNMP-EXTEND-MIB' for an alternative
Mar  4 17:28:45 snmp.priv snmpd[8678]: net-snmp: 2 error(s) in config file(s)

`extend`

L'uilisation de extend se fait via une mib spéciale (NET-SNMP-EXTEND-MIB.txt), sur une debian elle se trouve dans /usr/share/snmp/mibs. L'utilisation de cette option permet de créer automatiquement des entrées sous l'OID .1.3.6.1.4.1.8072 par défaut.

extend test_snmp /tmp/test_snmp
extend .1.3.6.1.4.1.2021.60 test_snmp /tmp/test_snmp

Les résultats se trouvent aux 2 endroits suivants :

$ snmpwalk -v 1 -c private localhost NET-SNMP-EXTEND-MIB::nsExtendObjects
[...]
NET-SNMP-EXTEND-MIB::nsExtendNumEntries.0 = INTEGER: 3
NET-SNMP-EXTEND-MIB::nsExtendCommand."test_snmp" = STRING: /tmp/test_snmp
NET-SNMP-EXTEND-MIB::nsExtendArgs."test_snmp" = STRING: 
NET-SNMP-EXTEND-MIB::nsExtendInput."test_snmp" = STRING: 
NET-SNMP-EXTEND-MIB::nsExtendCacheTime."test_snmp" = INTEGER: 5
NET-SNMP-EXTEND-MIB::nsExtendExecType."test_snmp" = INTEGER: exec(1)
NET-SNMP-EXTEND-MIB::nsExtendRunType."test_snmp" = INTEGER: run-on-read(1)
NET-SNMP-EXTEND-MIB::nsExtendStorage."test_snmp" = INTEGER: permanent(4)
NET-SNMP-EXTEND-MIB::nsExtendStatus."test_snmp" = INTEGER: active(1)
NET-SNMP-EXTEND-MIB::nsExtendOutput1Line."test_snmp" = STRING: 42
NET-SNMP-EXTEND-MIB::nsExtendOutputFull."test_snmp" = STRING: 42
NET-SNMP-EXTEND-MIB::nsExtendOutNumLines."test_snmp" = INTEGER: 1
NET-SNMP-EXTEND-MIB::nsExtendResult."test_snmp" = INTEGER: 0
NET-SNMP-EXTEND-MIB::nsExtendOutLine."test_snmp".1 = STRING: 42
[...]
$ snmpwalk -v 1 -c private localhost .1.3.6.1.4.1.2021.60
UCD-SNMP-MIB::ucdavis.60.1.0 = INTEGER: 1
UCD-SNMP-MIB::ucdavis.60.2.1.2.9.116.101.115.116.95.115.110.109.112 = STRING: "/tmp/test_snmp"
UCD-SNMP-MIB::ucdavis.60.2.1.3.9.116.101.115.116.95.115.110.109.112 = ""
UCD-SNMP-MIB::ucdavis.60.2.1.4.9.116.101.115.116.95.115.110.109.112 = ""
UCD-SNMP-MIB::ucdavis.60.2.1.5.9.116.101.115.116.95.115.110.109.112 = INTEGER: 5
UCD-SNMP-MIB::ucdavis.60.2.1.6.9.116.101.115.116.95.115.110.109.112 = INTEGER: 1
UCD-SNMP-MIB::ucdavis.60.2.1.7.9.116.101.115.116.95.115.110.109.112 = INTEGER: 1
UCD-SNMP-MIB::ucdavis.60.2.1.20.9.116.101.115.116.95.115.110.109.112 = INTEGER: 4
UCD-SNMP-MIB::ucdavis.60.2.1.21.9.116.101.115.116.95.115.110.109.112 = INTEGER: 1
UCD-SNMP-MIB::ucdavis.60.3.1.1.9.116.101.115.116.95.115.110.109.112 = STRING: "42"
UCD-SNMP-MIB::ucdavis.60.3.1.2.9.116.101.115.116.95.115.110.109.112 = STRING: "42"
UCD-SNMP-MIB::ucdavis.60.3.1.3.9.116.101.115.116.95.115.110.109.112 = INTEGER: 1
UCD-SNMP-MIB::ucdavis.60.3.1.4.9.116.101.115.116.95.115.110.109.112 = INTEGER: 0
UCD-SNMP-MIB::ucdavis.60.4.1.2.9.116.101.115.116.95.115.110.109.112.1 = STRING: "42"

La deuxième forme revient à peu de choses près au résultat de la commande exec avec utilisation d'un chemin.
La première forme permet d'obtenir beaucoup d'informations intéressantes comme le nombre d'éléments qui étendent la mib (NET-SNMP-EXTEND-MIB::nsExtendNumEntries.0 on remarque donc que j'ai nettoyé la réponse puisqu'il annonce 3 scripts d'extension). On peut récupérer la réponse complète NET-SNMP-EXTEND-MIB::nsExtendOutputFull."test_snmp" ou les lignes une à une NET-SNMP-EXTEND-MIB::nsExtendOutLine."test_snmp".x.

Le point faible de cette méthode subsiste dans le type de donnée renvoyé, notre script envoit un chiffre et il est considéré comme une chaine de caractère. De la même façon, si on veut générer un compteur sur 32 ou 64 bits, c'est impossible avec cette méthode.

`pass`

L'utilisation de cette option de configuration oblige à choisir un OID en dessous duquel le script est entièrement maitre. Il faut donc avoir recours à un script plus complexe qui permet de donner le type de valeur et la valeur pour un OID donné. Le script passtest donne une bonne idée d'un script basique permettant cette intégration. Je ne rentrerai pas dans les détails.

pass .1.3.6.1.4.1.2021.60 /tmp/test_snmp

Dans l'idée, le script est appelé avec les arguments <reqtype> <miboid>. Avec reqtype qui correspond à -g pour une requête GET, -n pour un GETNEXT et un -s pour un SET. le chemin OID est donné par miboid.
Dans le cas des commandes GET et GETNEXT, la réponse est constituée de 3 lignes :

l'OID de réponse;
le type de la valeur retournée, au choix dans integer, gauge, counter, timeticks, ipaddress, objectid, ou string;
la valeur.

Dans le cas de la commande SET, le script ne doit rien retourner.

Conclusion

Il faut bien en finir avec tout ce bazar, il est intéressant de jeter un coup d'oeil du côté de snmpd.conf(5) pour les détails, d'autres options de configuration comme pass_persist peuvent être utilisées. Personnellement, j'utilise la solution extend qui me semble raisonnablement simple à mettre en place et à utiliser.

Le log qui se voulait plus gros que le boeuf

hr — Thu, 21 Feb 2008 17:52:00 +0100

C'est généralement au moment où on se retrouve avec une partition pleine que l'oubli de la rotation des logs refait surface. C'est ultra-classique et pourtant... Mais nous allons prendre les devants pour que lighty ne soit pas un mangeur d'espace.

Sur FreeBSD, le gestionnaire de rotation de log de base s'appelle newsyslog(8), il est configuré par le fichier /etc/newsyslog.conf (newsyslog.conf(5)). Je suis habitué à logrotate(8) et j'aime bien conserver tous mes fichiers de logs d'activité web, je vais donc faire la même chose avec newsyslog(5). Je souhaite donc faire tourner mes logs tous les jours à minuit, compresser les logs passés et les conserver ad vitam eternam. Ces contraintes donnent l'entrée suivante dans le fichier de configuration :

# lighttpd rotates
/var/log/lighttpd/lighttpd.access.log   www:www   640  366 *   @T00   JC

il faut spécifier un champ de gestion d'appartenance (propriétaire et groupe), lighttpd écrit les logs avec les droits www:www et ils seront déplacés en changeant le propriétaire en root:www.Les fichiers seront créés avec les droits 640, le champ suivant spécifie que les fichiers sont sauvegardés 366 fois avant d'éliminer les fichiers les plus anciens (1 an). Les 2 champs suivant provoquent une rotation à minuit tous les jours. Le dernier champ précise qu'on compresse les archive de log en bzip2 et que le fichier est créé si il n'existe pas.
Le champ 'count' n'est pas exhaustivement décrit dans la page de man, et j'espérais pouvoir utiliser une valeur qui me permettrait d'avoir un nombre infini de fichiers de logs. La lecture du code source m'a confirmé que je ne pouvais pas utiliser le même type de fonctionnement que pour logrotate(8).

Une entrée doit être créée pour chaque fichier de log de chaque vhost.

Un blog bien sous tout rapport

hr — Thu, 14 Feb 2008 16:39:00 +0100

Ce blog est un dotclear 2 installé sur un système FreeBSD et servi par un lighty. J'ai choisi dotclear pour la possibilité de gérer de multiples blogs à partir d'un seul code, wordpress ne donnait pas cette possibilité simplement au moment de mon choix. Mon premier déploiement n'a pas été fait dans les règles FreeBSD, il est temps de remédier à cet insupportable état de fait.

Les applications web sont déployées dans /usr/local/www sous FreeBSD, le contenu des sites se trouve dans /usr/local/www/data.

# cd /usr/local/www
# tar zxvf ~/src/dotclear-2.0-beta7.tar.gz
# mv dotclear dotclear2

Le renommage du répertoire permet d'éviter un conflit dans l'éventualité de l'installation d'un dotclear 1.

Une fois le blog installé, il faut le configurer. La configuration de lighty est très simple, il suffit d'ajouter l'alias suivant pour un blog qui est atteint par http://www.bon.org/blog par exemple :

alias.url += (
        "/blog" => "/usr/local/www/dotclear2"
)

La suite de la configuration a déjà été abordée dans un autre billet.

Finalement la modification est assez mineure et revient uniquement à modifier le chemin d'alias pour tous les blogs hormis celui par défaut et ajouter un alias pour celui-ci.

ALETER Out of memory

hr — Wed, 13 Feb 2008 18:29:00 +0100

Si comme Doris vous avez de petits problèmes de mémoire avec dotclear 2 (dc2 beta7) lors du chargement de la page d'administration des utilisateurs, le problème vient probablement de MySQL.

Je me retrouve actuellement devant l'erreur suivante lorsque j'essaie d'administrer mes utilisateurs via l'interface d'administration :

Out of memory; restart server and try again (needed 65528 bytes) (1037)

Le problème me semble venir du serveur MySQL, une petite recherche google me conforte dans cette idée, je mets donc un peu de code de debug dans admin/users.php et je me retrouve avec cette requête SQL dantesque générée par la fonction getUsers() :

SELECT U.user_id,user_super,user_status,user_pwd,user_name,user_firstname,user_displayname,user_email,user_url,user_desc, user_lang,user_tz, user_post_status,user_options, count(P.post_id) AS nb_post FROM dc_user U LEFT JOIN dc_post P ON U.user_id = P.user_id WHERE NULL IS NULL GROUP BY U.user_id,user_super,user_status,user_pwd,user_name,user_firstname,user_displayname,user_email,user_url,user_desc, user_lang,user_tz,user_post_status,user_options ORDER BY U.user_id ASC  LIMIT 30 OFFSET 0;

Je comprends bien pourquoi mon petit serveur râle, devant l'adversité je me plie et je reconfigure mon serveur dans /var/db/mysql/my.cnf en modifiant une seule ligne :

sort_buffer_size = 128K

Après un redémarrage du serveur MySQL, tout rentre dans l'ordre et everybody is content.

HAL> Affirmative, Dave, I read you.

hr — Fri, 11 Jan 2008 17:39:00 +0100

Ah la vacuité d'une session IRC sur un canal dirigé par un automate. Quoi de plus extraordinaire que pouvoir connaitre la météo de Felletin dans la Creuse ou d'avoir une blague carambar à la demande. En ce moment je fais beaucoup de python, donc je me suis penché sur le problème pour un ami. Je vais essayer de vous exposer les clés de l'utilisation d'irclib pour construire un automate irc simple.

L'automate est présenté ci-après, ses fonctions sont simplement la connexion à un serveur irc local sur le port 6667 et l'entrée dans le canal #test. L'automate s'attend à lire des commandes préfixées de '!' dans le canal. La commande !cycle demande à l'automate de partir et revenir sur le canal, la commande !die provoque la déconnexion du serveur puis l'arrêt de l'automate. Le script de l'automate ci-après se trouve en téléchargement ici et peut être lancé par la commande python mybot.py.

import sys
try:
    from ircbot import SingleServerIRCBot
    import irclib
except ImportError, e:
    print e
    sys.exit(1)

class pybot(SingleServerIRCBot):
    def __init__(self, server, nick, realname, chan):
        SingleServerIRCBot.__init__(self, server, nick, realname)
        self.chan = chan
        self.nick = nick

    ## Event callbacks
    def on_welcome(self, c, e):
        if self.chan:
            c.join(self.chan)

    def on_join(self, c, e):
        who = e.source().split('!', 1)
        if who[0] == self.nick:
            c.privmsg(e.target(), 'Hello world!')

    def on_pubmsg(self, c, e):
        msg = e.arguments()[0].strip()
        if msg.startswith('!'):
            cmd = msg[1:].split(' ', 1)[0]
            self.trigger(c, e, cmd)

    ## Command triggers
    def trigger(self, c, e, cmd):
        try:
            getattr(self, 'cmd_%s' % cmd)(c, e)
        except AttributeError:
            pass

    def cmd_cycle(self, c, e):
        chan = e.target()
        c.part(chan, 'cycle')
        c.join(chan)

    def cmd_die(self, c, e):
        SingleServerIRCBot.die(self, 'Argh')

## Here comes the real script
if __name__ == '__main__':
    server = [('localhost', 6667)]
    nick = 'monbot'
    realname = 'monbot'
    channel = '#test'

    bot = pybot(server, nick, realname, channel)
    try:
        bot.start()
    except KeyboardInterrupt:
        bot.connection.disconnect("Ctrl-C m'a tuer")
        bot.connection.close()

La librairie irclib est basée sur la gestion d'évènements, des méthodes vont être lancées sur apparition d'un évènement au sens IRC. Les méthodes de l'objet pybot commençant par 'on_' sont les méthodes de gestion d'évènements, par exemple lorsqu'un message est envoyé sur un canal (PUBMSG) la méthode on_pubsmg() est appelée. La création de l'automate se base sur la surcharge des méthodes de gestion d'évènements. Ces méthodes ont toutes la même définition d'appel :

def on_foo(self, c, e):
    [...]

La variable c est un objet ServerConnection, cet objet permet de manipuler tout ce qui concerne le serveur irc d'où provient l'évènement. On peut par exemple rejoindre un canal (c.join()) ou envoyer un message à un canal ou une personne (commande PRIVMSG via c.privmsg()). La variable e est un objet Event, elle permet d'obtenir toutes les informations sur l'évènement qui a provoqué l'appel de la méthode. L'origine de l'évènement (e.source()), la destination de cet évènement (e.target()) ou encore les arguments de cet évènement (e.arguments()). Toutes les informations sur ces 2 méthodes se trouvent dans le module irclib (pydoc irclib).

A partir de la connaissance de ces éléments de base, la construction d'un automate devient assez simple. Si l'automate doit effectuer des tâches régulières, les méthodes execute_at() et execute_delayed() (héritage de l'objet IRC parent de SingleServerIRCBot) peuvent être utilisées. Plus d'information sur irclib devrait se trouver sur mon wiki.

Il est également possible d'utiliser twisted.words pour effectuer la même chose mais ça me semble une librairie un peu imposante pour un simple automate.

Il faut noter qu'on peut faire également le même genre de chose en Perl.

WOPR> Global Thermonuclear War

hr — Thu, 03 Jan 2008 18:33:00 +0100

Dans mon parcours d'initiation à python, je me suis retrouvé face à un problème existentiel (ce qui donne tout le caractère initiatique au parcours, le problème, parce qu'il est existentiel ... laisse tomber). Lors de l'utilisation du module cmd, comment gérer correctement les interruptions classiques que sont ctrl+D (EOF) et ctrl-C (SIGINT).

Ci-après, un squelette pour la gestion des 2 signaux évoqués. Juste après ci-après, les quelques explications qui s'imposent.

import sys
import cmd

class shell(cmd.Cmd):
    def __init__(self):
        cmd.Cmd.__init__(self)

    # Let's handle ctrl+D signals and quit gently
    def do_EOF(self, str):
        # CLEAN HERE
        return 1

if __name__ == "__main__":
    console = shell()
    try:
        console.cmdloop()
    except KeyboardInterrupt:
        # CLEAN HERE
        sys.exit(0)

`ctrl-D` ou la fin du monde

Le manuel de cmd nous dit :

An end-of-file on input is passed back as the string 'EOF'.

Ce qui signifie que la combinaison de touches ctrl+D revient à gérer la commande EOF, la méthode appelée est donc do_EOF().
Une autre information à propos de cmdloop() donnée dans le manuel est :

This method will return when the postcmd() method returns a true value. The stop argument to postcmd() is the return value from the command's corresponding do_*() method.

Donc si la méthode do_EOF() retourne simplement 1, la boucle va tout bêtement s'arrêter.

`ctrl-C` ou la fin de l'univers

En Python, l'utilisation de ctrl-C lève l'exception KeyboardInterrupt, en capturant cette interruption, on permet au script de sortir de façon maitrisée.

Evolution

Il est conseillé d'ajouter des actions de nettoyage au niveau des commentaires # CLEAN HERE pour permettre une sortie de la console vraiment sans encombre. Il reste encore à trouver un moyen élégant d'utiliser ctrl-c pour annuler la ligne en cours et récupérer l'invite vierge sans quitter cmd.cmdloop()
Attention toutefois, ce code n'a pas été testé dans un environnement microsoft. Les signaux ne sont surement pas traités de la même façon, ça n'étonnera personne.

Colle toi ça dans les oreilles

hr — Fri, 30 Nov 2007 17:21:00 +0100

Je suis l'heureux possesseur d'un iAUDIO X5L de 30Go, cet appareil est vraiment génial. Sauf quand il vous claque des montages en lecture seule, là c'est un peu pénible.

Nov 30 16:36:09 ewok kernel: [23799.560000] FAT: Filesystem panic (dev sdb1)
Nov 30 16:36:09 ewok kernel: [23799.560000]     fat_get_cluster: invalid cluster chain (i_pos 0)
Nov 30 16:36:09 ewok kernel: [23799.560000]     File system has been set read-only

Pas de problème, il suffit de faire une petite vérification du système de fichier après avoir démonté la partition :

$ sudo umount /media/IAUDIO
$ sudo fsck.vfat -a -v /dev/sdb1
dosfsck 2.11 (12 Mar 2005)
dosfsck 2.11, 12 Mar 2005, FAT32, LFN
Checking we can access the last sector of the filesystem
Boot sector contents:
System ID "MSDOS5.0"
Media byte 0xf8 (hard disk)
[...]
Reclaiming unconnected clusters.
Reclaimed 18671 unused clusters (305905664 bytes) in 73 chains.
Checking free cluster summary.
Free cluster summary wrong (98499 vs. really 98722)
  Auto-correcting.
Performing changes.
/dev/sdb1: 6625 files, 1731289/1830011 clusters

La reconnexion du lecteur à mon port USB et des mouvements de fichiers sur le disque me confirment que le problème a disparu. YATAAAAAAAAAAAA.

Rooooooooxanne

hr — Thu, 29 Nov 2007 13:04:00 +0100

J'ai eu besoin d'installer une jolie police de caractère (font en anglois) sur une ubuntu/debian (ce sont les seules distributions que j'ai testé) récemment et je me suis rendu compte de deux choses :

C'est très simple à faire
C'est peu documenté

Donc voici la marche à suivre pour installer une police de caractère sans les droits administrateur.

Il faut, a priori, trouver un belle police à installer (à noter les "Free Fonts Of The Month" de SmashingMagazine). Après avoir téléchargé la police en question et décompressé éventuellement une archive, les fichiers .ttf sont disponible.

$ wget http://www.kottke.org/plus/type/silkscreen/download/silkscreen.tar.gz -P ~/tmp
[...]
$ tar zxvf ~/tmp/silkscreen.tar.gz -C ~/tmp/
slkscr.ttf
slkscrb.ttf
slkscre.ttf
slkscreb.ttf
readme.txt

Un fois les fichiers de police à disposition, il suffit de créer un répertoire .fonts dans son répertoire home, d'y placer les polices et rafraichir le cache de polices.

$ mkdir ~/.fonts
$ cp ~/tmp/*.ttf ~/.fonts
$ fc-cache -f -v ~/.fonts/
/home/hr/.fonts/: caching, 1 fonts, 0 dirs
/var/cache/fontconfig: not cleaning unwritable cache directory
/home/hr/.fontconfig: cleaning cache directory
fc-cache: succeeded

Et c'est parti, pas plus compliqué que ça.