Internet and programming stuff

Quelques liens en vrac…

Patrick — Thu, 30 Jun 2011 10:35:24 +0000

Une petite sélection de liens pour le mois de Juin:

Not doing Code Reviews? What’s your excuse?
Getting started with android development
What are your favorite Vim tricks?
GNU Screen: Working with the Scrollback Buffer
C++ clear winner in Google language tests
Scaling with MongoDB (or how Urban Airship abandoned it for PostgreSQL)
SECCURE Elliptic Curve Crypto Utility for Reliable Encryption

PHP, Reflection et Annotations

Patrick — Sun, 29 May 2011 10:38:57 +0000

J’ai récemment eu à coder à mon taf des jeux de tests pour valider le comportement de mon serveur de pub, et pour ça, j’ai codé des petits scripts tout bête pour créer/modifier les données dans une base postgresql. J’aurai pu prendre un ORM tout fait (propel, doctrine…), mais j’ai juste codé mes classes tout bêtement et le plus simplement du monde. Un exemple:

class Voiture
{
public $id;
public $marque;
public $couleur;
};

Pour les requêtes d’insert, au lieu d’avoir des méthodes spécialisées dans chaque classe, j’ai codé juste une fonction save() qui prend l’objet à sauver, et qui parse grâce aux fonctions get_class_* ses propriétés pour générer les requêtes d’INSERT ou d’UPDATE. Cette fonction ressembait dans un premier temps à:

Ca me contentait dans pas mal de cas simples, mais très rapidement, cela à montré ses limites. J’avais besoin de connaître plus précisement les types des champs dans la base. Et la solution a été d’utiliser les annotations, pour ne pas avoir de longues et lourdes modifications à faire dans toutes mes classes d’objet. PHP ne propose pas out of the box un système complet d’annotation, mais incorpore les outils pour développer un comportement analogue: les classes Reflection.

Ces classes permettent de faire du « reverse engineering » sur les classes, les interfaces etc pour retrouver les différentes composantes de ces objets, qu’ils soient instanciés ou non. Et de plus, elles permettent de récupérer les commentaires des classes, des méthodes et des propriétés s’ils existent. Il n’y a qu’à les mettre en application:

/**
* Commentaire classe voiture
*/
class Voiture
{
/**
* Commentaire propriete id
*/
public $id;
}

$voiture = new Voiture;

$reflection = new ReflectionClass($voiture);
echo "Classe:\n";
echo $reflection->getDocComment() . "\n";

foreach($reflection->getProperties() as $property)
{
echo $property->name . ":\n";
echo $property->getDocComment() . "\n";
}

Ce qui donne:

$ php test_2.php
/**
* Commentaire classe voiture
*/
id:
/**
* Commentaire propriete id
*/
$

Il ne resterait plus maintenant qu’à définir ses keywords, parser les commentaires propement pis à coder son propre mini-orm sans modifier les objets finaux.

Et voilà un début:

class DbObject
{
public function save()
{
$schema = $this->buildSchema($this);
/* Ici y a du code */

return TRUE;
}

private function buildSchema()
{
$class_name = get_class($this);
$class_vars = get_class_vars($class_name);

$class_reflection = new ReflectionClass($this);
echo $class_reflection->getDocComment();

$schema = array();

foreach($class_vars as $var_name => $var_value)
{
$prop_reflection = $class_reflection->getProperty($var_name);
$comment = $prop_reflection->getDocComment();

$comment = preg_replace(',\/\*\*(.*)\*\/,', '$1', $comment);
$comments = preg_split(',\n,', $comment);

$key = $val = NULL;
$schema[$var_name] = array();

foreach($comments as $comment_line)
{
if(preg_match(',@(.*?): (.*),i', $comment_line, $matches))
{
$key = $matches[1];
$val = $matches[2];

$schema[$var_name][trim($key)] = trim($val);
}
}
}
var_dump($schema);

return $schema;
}
};

class Voiture extends DbObject
{
/**-
* @DbType: integer
* @DbValue: 0
*/
public $id;

/** @DbType: string
*
* Blabla.
*
*/
public $marque;

/** @DbType: string */
public $couleur;
};

$voiture = new Voiture;
$voiture->id = 1;
$voiture->marque = 'renault';
$voiture->couleur = 'bleu';
$voiture->save();

buildSchema retournera dans cet exemple:

$ php test_annotations.php
array(3) {
["id"]=>
array(2) {
["DbType"]=>
string(7) "integer"
["DbValue"]=>
string(1) "0"
}
["marque"]=>
array(1) {
["DbType"]=>
string(6) "string"
}
["couleur"]=>
array(1) {
["DbType"]=>
string(6) "string"
}
}

Pour finir, quelques petites références sur le sujet:

Et au final, au lieu de réinventer une roue bien vieille, je suis parti utiliser Addendum:

Controler les core dump

Patrick — Sun, 03 Apr 2011 07:23:40 +0000

La génération des fichier core contiennent l’état de la mémoire d’un process, et a lieu généralement suite au crash de ce process. Sous Linux, le core dump est provoqué suite à la réception par le process de signaux spécifiques documentés dans le man 7 signal:

       Signal     Value     Action   Comment
       ----------------------------------------------------------------------

       SIGQUIT       3       Core    Quit from keyboard
       SIGILL        4       Core    Illegal Instruction
       SIGABRT       6       Core    Abort signal from abort(3)
       SIGFPE        8       Core    Floating point exception
       SIGSEGV      11       Core    Invalid memory reference

       SIGBUS      10,7,10     Core    Bus error (bad memory access)
       SIGSYS      12,31,12    Core    Bad argument to routine (SVr4)
       SIGTRAP        5        Core    Trace/breakpoint trap
       SIGXCPU     24,24,30    Core    CPU time limit exceeded (4.2BSD)
       SIGXFSZ     25,25,31    Core    File size limit exceeded (4.2BSD)

Avant toute chose, il faut vérifier que le système est capable de générer ces fichiers. En effet, sous Ubuntu par exemple, la user limit (ulimit) pour la taille des fichiers core est nulle. Il faut donc permettre au système d’écrire des fichiers de taille illimité:

$ ulimit -c unlimited

On peut trivialement vérifier que les fichiers core sont générés. On lance un shell, et on envoie un signal SIGSEGV qui va faire crasher ce nouveau process ($$) pour générer le core:

$ bash
$ kill -SEGV $$
Segmentation fault (core dumped)
$ ls -l core
-rw------- 1 mycroft mycroft 3784704 2011-04-02 13:02 core

Cependant, parfois, on veut pouvoir controler un peu plus ce fichier, en particulier son nom et sa destination. Les noyaux Linux 2.6 permettent cela grace à la variable système kernel.core_pattern (ou /proc/sys/kernel/core_pattern) qui sert de template pour le nom de fichier et qui a comme valeur par défaut « core ». Ce template accepte un chemin absolu et les modificateurs de format suivant:

%p – pid
%u – uid
%g – gid
%s – numéro de signal
%t – temps UNIX / timestamp
%h – hostname
%e – nom de fichier executable
%% – « % »

On décide donc de placer nos fichiers core dans /tmp/core, et qu’ils aient le format « timestamp.nom-executable.pid.uid:gid ». Pour cela, on modifie /proc/sys/kernel/core_pattern avec le format de notre choix:

# mkdir /tmp/core/
# echo "/tmp/core/%t.%e.%p.%u:%g" > /proc/sys/kernel/core_pattern

Et on teste:

$ ulimit -c unlimited
$ bash
$ kill -SEGV $$
Segmentation fault (core dumped)
$ ls -l /tmp/core
total 3584
-rw------- 1 mycroft mycroft 3784704 2011-04-02 13:16 1301778979.bash.19366.1000:1000

Il ne reste plus qu’à le configurer de manière à toujours reproduire ce comportement, en particulier après un reboot dy système. Pour cela, il n’y a qu’à ajouter la ligne suivante dans le fichier /etc/sysctl.conf:

kernel.core_pattern=/tmp/core/%t.%e.%p.%u:%g

De plus, pour conserver la valeur de ulimit, il faudra modifier /etc/security/limits.conf et affecter la valeur « unlimited » à l’item « core »:

#                 
*              soft    core           unlimited

A noter que cette modification prendra effet au prochain log-in et non à l’ouverture d’une nouvelle console dans X.

Se connecter proprement à ssh via un proxy web

Patrick — Sat, 02 Apr 2011 11:07:24 +0000

Cet article est issu d’une précédente version de mon weblog, mais perdu dans l’oubli. Il remonte à Avril 2008. Je le remets ici à jour.

Un problème au taf, si ce n’est le prix du café au distributeur, est la non possibilité de se connecter sur sa box avec son ssh. Et bien, Dag Wiers propose une solution propre (qui n’oblige pas à installer son sshd sur le 443 et d’utiliser corkcrew), mais d’utiliser proxytunnel qui marche plutot bien.

Pour résumer la chose, cela implique d’avoir un serveur avec un apache où on a la main dessus, mod_proxy/mod_proxy_connect et mod_proxy_http d’installés, possiblement mod_ssl (mais ça crée un petit problème de taille à cause d’une non-feature d’apache2), et un peu de configuration.

N’ayant pas la main sur mon serveur au taf, c’est pas facile pour tester. J’ai donc aussi installé privoxy en local pour faire mes tests. Par contre, après utilisation, j’ai pas réussi à faire passer un CONNECT sur un port de destination 80, privoxy ne voulait pas, et le limit-connect semblait pas vouloir être changé. En même temps il était 5h du mat, j’ai peut être oublié un truc.

Alors, voilà la conf que j’ai faite sur ma debian (serveur ssh):

Server ssh sur le 22 et 2222;
Apache2 de base installé (bon, avec php mais là on s’en fiche);

On configure le bouzin:

remote# a2enmod ssl
remote# a2enmod proxy
remote# a2enmod proxy_connect

Il faut générer un certificat (.pem) pour notre nouveau serveur https. Pour çà, y a un super outil dans debian, et c’est make-ssl-cert:

remote# make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem
remote# chmod a+r /etc/apache2/ssl/apache.pem

Et un virtualhost sur le 443, qui inclue directement les directives pour mod_ssl et mod_proxy:

<VirtualHost spine.minithins.net:443>
SSLEngine On
SSLCertificateFile /etc/apache2/ssl/apache.pem

ServerAdmin mycroft@minithins.net
DocumentRoot /home/web/minithins.net
ServerName cns.minithins.net

HostnameLookups On

ProxyRequests on
AllowCONNECT 2222
ProxyVia on

<proxy *>
Order deny,allow
Deny from all
Allow from client.monkeyz.eu
proxy>
VirtualHost>

Un redémarrage d’apache, et on va tester avec stunnel:

remote# service apache2 restart
Restarting web server: apache2 ... waiting .

client# apt-get install stunnel
...
client# stunnel -f -c -d 12345 -r spine.minithins.net:443
2011.04.02 12:22:22 LOG5[11844:140613013587712]: stunnel 4.29 on x86_64-pc-linux-gnu with OpenSSL 0.9.8o 01 Jun 2010
2011.04.02 12:22:22 LOG5[11844:140613013587712]: Threading:PTHREAD SSL:ENGINE Sockets:POLL,IPv6 Auth:LIBWRAP
2011.04.02 12:22:22 LOG5[11844:140613013587712]: 500 clients allowed
...

Sur une autre console:

client# telnet localhost 12345
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
CONNECT spine.minithins.net:2222 HTTP/1.0

Connection closed by foreign host.

Hum. Ca ne fonctionne pas.

Un peu de recherche (ou de triche, car Dag Wieers donne la réponse), Apache, ou plus précisement le mod_proxy_connect est buggé. Mais un patch existe. Il faut appliquer un des patchs proposés (surement le dernier en date, dans mon exemple celui pour 2.2.16), et lancer un coup de rebuild des packages apache via les scripts debian:

remote# cd /tmp
remote# apt-get install devscripts fakeroot gcc bzip2 dpkg-dev
...
remote# apt-get build-dep apache2.2-common
...
remote# apt-get source apache2.2-common
...
remote# cd apache2-2.2.16/modules/proxy
remote# wget -O mod_proxy_connect.diff "https://issues.apache.org/bugzilla/attachment.cgi?id=26225"
remote# patch -p0 < mod_proxy_connect.diff

… et c’est parti pour tout rebuilder: …

remote# debuild -us -uc
remote# cd /tmp/apache2-2.2.16
... (long) ...

… et finalement on met à jour le package apache2.2-bin:

remote# dpkg -i ../apache2.2-bin_2.2.16-6+squeeze1_amd64.deb
(Reading database ... 48179 files and directories currently installed.)
Preparing to replace apache2.2-bin 2.2.16-6+squeeze1 (using .../apache2.2-bin_2.2.16-6+squeeze1_amd64.deb) ...
Unpacking replacement apache2.2-bin ...
Setting up apache2.2-bin (2.2.16-6+squeeze1) ...
Processing triggers for man-db ...
remote # service apache2 restart
Restarting web server: apache2 ... waiting .

On reteste avec stunnel:

client# telnet localhost 12345
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
CONNECT spine.minithins.net:2222 HTTP/1.0

HTTP/1.0 200 Connection Established
Proxy-agent: Apache/2.2.16 (Debian)

SSH-2.0-OpenSSH_5.5p1 Debian-6

Yay ! First step donne. Plus qu’à tester via un proxy http et utiliser le client ssh.

Pour tester, j’installe en local un privoxy:

client# apt-get install privoxy

On pourra modifier l’adresse d’écoute de privoxy (localhost:8118), et le modifier (par exemple, 127.0.0.1:8080 pour éviter qu’il prenne l’adresse ipv6 au lieu de la v4).

On crée un profil ssh en accord, dans ~/.ssh/config:

Host spine-proxy
DynamicForward 1080
ServerAliveInterval 30
# proxy.dev pointe vers localhost car mon proxy est sur localhost.
ProxyCommand proxytunnel -v -X -p proxy.dev:8118 -r spine.minithins.net:443 -d %h:%p -H "User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n"

On notera dans mon exemple que j’utilise le flag -X. Il permet de préciser que j’utilise une connection sécurisée ssl entre les deux proxy (entre mon proxy et le mod_proxy de mon apache). Il est possible que le proxy que vous utiliserez ne l’aime pas. Dans ce cas, n’hésitez pas à joeur avec -X, -e et -E).

Et si on restestait:

client# ssh spine-proxy
...
Tunneling to spine-proxy:2222 (destination)
Communication with remote proxy:
-> CONNECT spine-proxy:2222 HTTP/1.0
-> Proxy-Connection: Keep-Alive
-> User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n
<- HTTP/1.1 502 Proxy Error
HTTP return code: 502 Proxy Error
...

What ?!
Dans les logs, on voit:

[error] [client 78.229.134.1] proxy: DNS lookup failure for: spine-proxy returned by spine-proxy:2222

Il n’aime pas trop que j’utilise « spine-proxy » comme alias. Solution, retirer le -d %h:%p (et le remplacer par le vrai host de la machine), ou changer l’alias. Après correction:

client# ssh -v spine
OpenSSH_5.5p1 Debian-4ubuntu5, OpenSSL 0.9.8o 01 Jun 2010
...
debug1: Executing proxy command: exec proxytunnel -v -X -p proxy.dev:8118 -r spine.minithins.net:443 -d spine:2222 -H "User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\\n"
...
SSL local to remote proxy enabled
Local proxy proxy.dev resolves to 127.0.0.1
Connected to proxy.dev:8118 (local proxy)

Tunneling to spine.minithins.net:443 (remote proxy)
Communication with local proxy:
-> CONNECT spine.minithins.net:443 HTTP/1.0
-> Proxy-Connection: Keep-Alive
-> User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n
<- HTTP/1.0 200 Connection established
<- Proxy-Agent: Privoxy/3.0.16

Tunneling to spine:2222 (destination)
Communication with remote proxy:
-> CONNECT spine:2222 HTTP/1.0
-> Proxy-Connection: Keep-Alive
-> User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n
<- HTTP/1.0 200 Connection Established
<- Proxy-agent: Apache/2.2.16 (Debian)

Tunnel established.
debug1: Remote protocol version 2.0, remote software version OpenSSH_5.5p1 Debian-6
...
remote#

Et ça marche ! Rock’n'Roll ! :°)

Python: Chargement de fichiers sources en live

Patrick — Sat, 26 Mar 2011 13:52:57 +0000

Pour BUTT j’ai voulu un mini système de plugins/modules afin de rajouter ou modifier du code sans redémarrer mon process. Et Python propose nativement cela grâce au module imp. On va utiliser spécifiquement la procédure load_source qui permet de charger un fichier source, de le parser, et de retourner son objet Module.

Illustrons. Voici le code du très simple module à importer:

#!/usr/bin/env python

class TestModule:
def __init__(self):
pass

def myfunction(self):
print "Calling myfunction"

Procédure de chargement du module:

#!/usr/bin/env python

import os, shutil
import imp

def load_module(module_name):
print "Loading module %s" % module_name

modfile = os.path.join(os.getcwd(), module_name + '.py')

module = imp.load_source(module_name, modfile)

print module
# Returns

print dir(module)
# Permet de lister les differents attributs de l'objet importé.
# Returns ['TestModule', '__builtins__', '__doc__', '__file__', '__name__', '__package__']

for objname in dir(module):
# Je veux specifiquement les modules suffixés "Module":
if objname.endswith('Module'):
modclass = getattr(module, objname)
print modclass
# Returns test.TestModule
print dir(modlass)
# Returns ['__doc__', '__init__', '__module__', 'myfunction']
return modclass

return None

Il ne reste plus qu’à montrer par l’exemple le fonctionnement et le reload d’un module dans le main:

if __name__ == '__main__':

modclass = load_module('test')
instance = modclass()
instance.myfunction()

# We move away test.py, and copy test_new.py to test.py.

print

shutil.move('test.py', 'test_old.py')
shutil.move('test_new.py', 'test.py')

modclass = load_module('test')
instance = modclass()
instance.myfunction()

shutil.move('test.py', 'test_new.py')
shutil.move('test_old.py', 'test.py')

Qui nous donnera:

$ ./modules.py
Loading module test
<module 'test' from '/home/mycroft/imp/test.py'>
['TestModule', '__builtins__', '__doc__', '__file__', '__name__', '__package__']
test.TestModule
['__doc__', '__init__', '__module__', 'myfunction']
Calling myfunction

Loading module test
<module 'test' from '/home/mycroft/imp/test.py'>
['TestModule', '__builtins__', '__doc__', '__file__', '__name__', '__package__']
test.TestModule
['__doc__', '__init__', '__module__', 'myfunction']
Calling (new) myfunction

Le code modifié (ici test.py a été remplacé par test_new.py, qui contient du code modifié) a bien été relu par python et est à présent utilisé.

Ecrire un bot IRC grâce à Python et Twisted

Patrick — Fri, 25 Mar 2011 08:51:40 +0000

Quand il faut écrire une application réseau, les développeurs Python n’ont qu’un mot à la bouche: Twisted. Il s’agit d’un moteur réseau « event-driven », et comprend un grand nombre de protocoles de niveau 3 (TCP, UDP, socket unix) et 7 (HTTP, SSH, IMAP, IRC…).

On va donc simplement voir ici comment coder un bot irc (quasi) complet. On prend la doc « Writing Clients » et celle de la classe irc.IRCClient.

On a donc besoin d’écrire une classe de base pour le bot, et sa factory utilisable dans le reactor de twisted.

#!/usr/bin/env python

import sys

from twisted.words.protocols import irc
from twisted.internet import protocol
from twisted.internet import reactor

class QuickBot(irc.IRCClient):
def _get_nickname(self):
return self.factory.nickname
nickname = property(_get_nickname)

def signedOn(self):
self.join(self.factory.channel)
pass

def privmsg(self, user, channel, msg):
pass

class QuickBotFactory(protocol.ClientFactory):
protocol = QuickBot

def __init__(self, channel, nickname):
self.channel = channel
self.nickname = nickname

def clientConnectionLost(self, connector, reason):
connector.connect()

def clientConnectionFailed(self, connector, reason):
connector.connect()

Et le point d’entrée:

if __name__ == "__main__":
reactor.connectTCP('localhost',
6667,
QuickBotFactory('#bot', 'quicky'))
reactor.run()

Et du coup, j’ai un peu étendu le truc et j’ai créé Another Python Bot Using The Twisted Framework, aka Butt, avec un système de modules chargeables dynamiquement (avec imp) et l’utilisation de python-yaml pour les fichiers de conf. Un bon exemple pour commencer un bot IRC ! Les sources sont disponibles sur le projet Butt sur mon compte Github.

Mise en commun d’un serveur git via ssh et mise à disposition à tous

Patrick — Sat, 19 Mar 2011 11:45:36 +0000

Je suis en train de développer sygit, une interface web light pour naviguer dans un dépôt git. J’ai alors décidé de mettre au clair mes dépots et de monter ma propre architecture d’hosting git, sous debian.

Emplacement des dépôts

Les dépôts vont être accessible via ssh (lecture+écriture) et via git-daemon (par dessus d’inetd, en lecture seule). On décide de créer un groupe « git-users » pour ceux qui auront accès aux dépots. On édite donc /etc/group:

git-users:x:199:mycroft,patrick

Le dépôt sera physiquement dans /git. On le crée (et on n’oublie pas le –bare !):

# mkdir -p /git/newproject
# cd !-1:2
# git --bare init
Initialized empty Git repository in /git/newproject/

On pourra également réutiliser un projet déjà existant dont on créerait un dépôt bare:

# cd /git
# git clone --bare git://github.com/mycroft/sygit.git
Cloning into bare repository sygit.git...
remote: Counting objects: 48, done.
remote: Compressing objects: 100% (47/47), done.
remote: Total 48 (delta 21), reused 0 (delta 0)
Receiving objects: 100% (48/48), 8.77 KiB, done.
Resolving deltas: 100% (21/21), done.

Pour ces projets, il faudra changer la configuration et leur indiquer qu’il s’agit d’un dépôt partagé sur la base du groupe. Pour cela, il faut modifier la propriété core.sharedRepository:

# cd sygit.git
# git repo-config core.sharedRepository group

On n’a plus qu’à fixer les permissions manuellement:

# chgrp -R git-users /git/sygit.git
# find /git/sygit.git -type d -exec chmod g+ws {} \;

Mise en place de git-daemon

On utilise inetd pour partager les dépôts. On édite donc /etc/inetd.conf …

git stream tcp nowait nobody /usr/bin/git git daemon --inetd --verbose --export-all --base-path=/git /git

… et on redémarre le daemon:

/etc/init.d/openbsd-inetd restart

Testons !

Sur ma machine de travail, on clone le dépôt en read-only:

$ git clone git://mkz.me/sygit.git
Initialized empty Git repository in /tmp/testgit/sygit/.git/
remote: Counting objects: 48, done.
remote: Compressing objects: 100% (26/26), done.
remote: Total 48 (delta 21), reused 48 (delta 21)
Receiving objects: 100% (48/48), 8.77 KiB, done.
Resolving deltas: 100% (21/21), done.

$ cd sygit
$ git remote -v
origin git://mkz.me/sygit.git (fetch)
origin git://mkz.me/sygit.git (push)

Pour le moment, le seul remote configuré est le serveur git. Celui là étant en read-only, il va faloir le modifier pour pouvoir push:

$ git remote rm origin
$ git remote add origin mycroft@mkz.me:/git/sygit.git
$ git remote -v
origin mycroft@mkz.me:/git/sygit.git (fetch)
origin mycroft@mkz.me:/git/sygit.git (push)

Il ne reste plus qu’à modifier un fichier, le commiter et le pusher:

$ vim README
$ git add README
$ git commit -m "Update README"
[master 2d98128] Update README
1 files changed, 6 insertions(+), 0 deletions(-)
$ git push origin master
Counting objects: 5, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 375 bytes, done.
Total 3 (delta 2), reused 0 (delta 0)
To mycroft@mkz.me:/git/sygit.git
826d9b0..2d98128 master -> master

Et voilà !

Apache: Lire et découper le corps d’une requête POST dans un module Apache

Patrick — Mon, 14 Mar 2011 15:08:39 +0000

Le code est très inspiré du chapitre « Reading the Request body » du livre Writing Apache Modules with Perl and C.

Pour expérimenter un peu les modules Apache (suite à un nouvel entretien d’embauche), je me suis mis en tête de coder un mini service via un module pour générer des nombres aléatoire.

Le service devra être très simple et sera exécuté lors de l’appel de l’url http://localhost/randomint, et l’on pourra l’appeler en POST en donnant, par exemple, l’argument count pour préciser le nombre d’entiers aléatoires que l’on désire.

Et finalement, l’étape la plus complexe aura été de reconstruire le body envoyé lors de la requête POST, et de le parser pour en sortir un tableau associatif (key/value).

Reconstruction du body

Cette fonction attend l’envoie du body par le client et reconstruit en un seul block toutes les données envoyées.

static int chunk_reader(request_rec *r, const char **rbuf)
{
int ret;

if(OK != (ret = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR))) {
return ret;
}

if(ap_should_client_block(r)) {
char argsbuffer[HUGE_STRING_LEN];
int rsize, len_read, rpos=0;
long length = r->remaining;

*rbuf = apr_pcalloc(r->pool, length + 1);

while(0 < (len_read = ap_get_client_block(r, argsbuffer, sizeof(argsbuffer)))) {
if ((rpos + len_read) > length) {
rsize = length - rpos;
}
else {
rsize = len_read;
}

memcpy((char*)*rbuf + rpos, argsbuffer, rsize);
rpos += rsize;
}
}

return ret;
}

Création du tableau associatif

Avec le block recomposé, on fait ensuite appel aux fonctions ap_getword ap_getword et aux fonctions apr_tables de apr afin de découper et stocker les différentes valeurs envoyées:

static int read_post(request_rec *r, apr_table_t **tab)
{
const char *data;
const char *key, *val, *type;
int ret = OK;

if(r->method_number != M_POST) {
return ret;
}

// On verifie que le content type soit bien application/x-www-form-urlencoded
type = apr_table_get(r->headers_in, "Content-Type");

if(strcasecmp(type, DEFAULT_ENCTYPE) != 0) {
return DECLINED;
}

if((ret = chunk_reader(r, &data)) != OK) {
return ret;
}

// Creation ou RAZ de la apr_table_t
if(*tab) {
apr_table_clear(*tab);
}
else {
*tab = apr_table_make(r->pool, 8);
}

// Tant qu'il y a des datas...
while(*data && (val = ap_getword(r->pool, &data, '&'))) {
key = ap_getword(r->pool, &val, '=');
ap_unescape_url((char*)key);
ap_unescape_url((char*)val);
apr_table_merge(*tab, key, val);
}

return OK;
}

Récupérer la bonne valeur

Une fois qu’on a le tableau associatif, il nous faut une fonction pour récupérer la valeur voulue:

int get_value(request_rec *r, const char *name)
{
apr_table_t *post_values = NULL;
apr_array_header_t *arr;
apr_table_entry_t *elt;

int i, ret, value;

if(OK != (ret = read_post(r, &post_values))) {
return -1;
}

if(NULL == post_values) {
return -1;
}

arr = apr_table_elts(post_values);
elt = (apr_table_entry_t*)arr->elts;

for(i = 0; i < arr->nelts; ++i) {
if(strcmp(elt[i].key, name) == 0
&& LONG_MIN != (value = strtol(elt[i].val, NULL, 10))) {
return value;
}
}

return -1;
}

Revenons au code du module lui-même…

Il ne reste plus qu’à coder le handler de génération, et rajouter les structures nécessaires pour le module:

static int mod_randomint_method_handler (request_rec *r)
{
int ret = OK, i, count = 8, new_count;
unsigned int random_value;

new_count = get_value(r, "count");

if(new_count > 0 && new_count < MAX_COUNT) {
count = new_count;
}

ap_set_content_type(r, "text/plain");

int random_fd = open("/dev/urandom", O_RDONLY);
for(i = 0; i < count; i ++) {
read(random_fd, (void*)&random_value, sizeof(random_value));
ap_rprintf(r, "%u\n", random_value);
}
close(random_fd);

// fprintf(stderr, "Count: %d\n", count);
// fflush(stderr);

return ret;
}

static void mod_randomint_register_hooks (apr_pool_t *p)
{
ap_hook_handler(mod_randomint_method_handler, NULL, NULL,APR_HOOK_LAST);
}

module AP_MODULE_DECLARE_DATA randomint_module =
{
STANDARD20_MODULE_STUFF,
NULL,
NULL,
NULL,
NULL,
NULL,
mod_randomint_register_hooks, /* callback for registering hooks */
}

Il ne reste plus qu’à compiler le code …:

apxs2 -c -a -i mod_randomint.c

… et le configurer dans httpd.conf:

LoadModule randomint_module /usr/lib/apache2/modules/mod_randomint.so

SetHandler randomint-handler

Et après un redémarrage d’apache:

$ curl http://localhost/randomint
4162010288
1220025110
2641785880

On pourra voir le résultat dans mes snippets et le télécharger dans mes projets directement.

Mise à jour:

J’ai oublié de filtrer par handler dans le code. On incluera donc dans mod_randomint_method_handler:

if(strcmp(r->handler, "randomint-handler")) {
return DECLINED;
}

Intégrer le single sign-on Twitter avec Yapl4twitter dans symfony

Patrick — Mon, 07 Mar 2011 08:53:17 +0000

Le but de ce mini tutorial est d’implémenter la fonctionnalité single sign-on de Twitter sur un site construit autour de Symfony. Pour ce faire, j’ai utilisé la bibliothèque Yapl4twitter (que j’ai développé).

On n’oubliera pas de consulter Sign in with twitter afin de mieux comprendre comment fonctionne cette fonctionnalité.

Un article où il y a plus de code que de texte, mais je pense que c’est assez clair. ;-)

Installer Yapl4twitter et le configurer

$ cd lib/vendor
$ git clone git://github.com/mycroft/yapl4twitter.git
[...]

On le rajoute dans config/autoload.yml pour que les classes soient préloadées:

autoload:
twitter:
name: twitter
path: %SF_LIB_DIR%/vendor/yapl4twitter
recursive: off

On va ensuite avoir besoin de clefs valide d’une application. On prendra donc soin d’en créer une sur https://dev.twitter.com/apps et de créer le config/app.yml adéquat:

all:
base_url: http://mysite.com

twitter:
consumer_key:
consumer_secret: >

request_token_url: https://api.twitter.com/oauth/request_token
access_token_url: https://api.twitter.com/oauth/access_token
authorize_url: https://api.twitter.com/oauth/authorize
authenticate_url: https://api.twitter.com/oauth/authenticate

Le module et ses actions dans symfony

On crée un module spécifique au login/logout. Mon application s’appelle « frontend », tout simplement:

$ php symfony generate:module frontend twitter

On aura dans ce module deux actions: login et logout. On n’oubliera pas d’en créer les routes dans apps/frontend/config/routing.yml:

login:
url: /login
param: { module: twitter, action: login }

logout:
url: /logout
param: { module: twitter, action: logout }

Il ne reste plus qu’à implémenter les deux actions:

public function executeLogin(sfWebRequest $request)
{
$oa = new OAuth(
sfConfig::get('app_twitter_consumer_key'),
sfConfig::get('app_twitter_consumer_secret')
);

// Premiere etape: Pas de parametre oauth_token: On ne vient pas de twitter.com
// On fait donc la demande d'un request token et on redirige l'utilisateur vers
// twitter.com.
if(FALSE == $request->hasParameter('oauth_token'))
{
$request_token_url = sfConfig::get('app_twitter_request_token_url');

$callback_url = sfConfig::get('app_base_url');
$callback_url.= $this->getController()->genUrl('@login');

$request_token = $oa->getRequestToken($request_token_url,
$callback_url);

// On redirige vers l'authenticate_url qui permet de ne pas avoir
// a accepter l'application une nouvelle fois.
$next_url = sfConfig::get('app_twitter_authenticate_url');
$next_url.= '?oauth_token=' . $request_token['oauth_token'];

$this->redirect( $next_url );
}
// Seconde etape: On a un parametre oauth_token. On vient donc de twitter.com
// On va recuperer a partir du oauth_token et oauth_verifier l'oauth_token_secret.
else
{
$oauth_token = $request->getParameter('oauth_token');
$oauth_verifier = $request->getParameter('oauth_verifier');

$access_token = $oa->getAccessToken(sfConfig::get('app_twitter_access_token_url'),
$oauth_token,
$oauth_verifier);

// On a le token, on enregistre dans la session le screen_name et
$this->getUser()->setAttribute('screen_name', $access_token['screen_name']);
$this->getUser()->setAttribute('oauth_token', $access_token['oauth_token']);
$this->getUser()->setAttribute('oauth_token_secret', $access_token['oauth_token_secret']);
$this->getUser()->setAuthenticated(TRUE);

// On pourrait avoir une table ou l'on stocke ces informations pour plus tard:
// $account = AccountTable::getInstance()->findOneByScreenName($access_token['screen_name']);
// if( ! $account )
// {
// $account = new Account();
// $account->screen_name = $access_token['screen_name'];
// $account->user_id = $access_token['user_id'];
// $account->oauth_token = $access_token['oauth_token'];
// $account->oauth_token_secret = $access_token['oauth_token_secret'];
// $account->save();
// }

// $this->getUser()->setAttribute('account_id', $account->id);

// On est loggue, on retourne sur la page principale:
$this->redirect('@homepage');
}

return sfView::NONE;
}

// logout: On invalide tout.
public function executeLogout(sfWebRequest $request)
{
$this->getUser()->setAttribute('screen_name', NULL);
$this->getUser()->setAttribute('oauth_token', NULL);
$this->getUser()->setAttribute('oauth_token_secret', NULL);
$this->getUser()->setAuthenticated(FALSE);

return $this->redirect('@homepage');
}

mplayer/mencoder: Convertir un fichier .mkv (Matroska) en .avi (divx)

Patrick — Sun, 06 Mar 2011 16:57:50 +0000

Il est de plus en plus courant d’avoir à faire à des fichiers mkv (Matroska). L’avantage de ces fichiers, c’est qu’il peuvent être composés de plusieurs pistes videos/audios/sous titres, et donc de permettre des vidéos multilingues. Le point négatif, est que les lecteurs de divx de salon ou bien encore la freebox ne les gèrent pas complètement (certains codecs manquant). Il est donc indispensable de convertir ces videos en divx/xvid avec en plus un bon codec sonore.

Pour cela, je vais faire appel aux packages mkvtoolnix, mplayer et mencoder sous gnu/linux.

Description des fichiers mkv

Les mkv sont capables d’être composés de flux vidéos et sonores encodés par différents types de codecs. Une première étape est de déterminer à quels codecs l’on a à faire. La commande mkvinfo permet cela:

$ mkvinfo "Morning Musume - Pepper Keibu.mkv" | grep -E "Codec ID: (V_|A_)"
| + Codec ID: V_MPEG4/ISO/AVC
| + Codec ID: A_AAC

Ce fichier, par exemple, contient une vidéo en mpeg4 et la piste audio est de l’AAC.

Ce fichier ci, par contre, contient une piste vidéo (le codec est préfixé par V_), deux pistes audios (une japonaise et une anglais), et une piste de sous titres anglaise. La liste complète des codecs supportés par Matroska est disponible sur cette page.

Lecture d’un mkv avec mplayer

Il est facilement possible de lire avec mplayer un tel fichier, en utilisant les bonnes options pour avoir la bonne piste audio/vidéo/sous-titres.

Par exemple, si l’on reprend le fichier précédent et que l’on veuille lire la version originale japonaise sous titrée anglais:

mplayer -alang jpn -slang 0 MyMovie.mkv

(ou encore: « mplayer -vid 0 -aid 0 -sid 0 MyMovie.mkv » pour sélectionner manuellement les pistes.)

mplayer donne de toutes façons plus d’informations au démarrage de la lecture sur les pistes:

Playing MyMovie.mkv.
[mkv] Track ID 1: video (V_MS/VFW/FOURCC) "MyMovie", -vid 0
[mkv] Track ID 2: audio (A_AAC/MPEG2/LC/SBR) "Dolby 5.1 Japanese", -aid 0, -alang jpn
[mkv] Track ID 3: audio (A_AAC/MPEG2/LC/SBR) "Dolby 5.1 English", -aid 1, -alang eng
[mkv] Track ID 4: subtitles (S_TEXT/ASS), -sid 0, -slang eng
[mkv] Will play video track 1.

Conversion d’un fichier mkv en fichier avi

Quand on a de la chance, le fichier mkv contient un flux vidéo xvid. Dans ce cas là, on peut facilement faire un fichier AVI en utilisant le flux vidéo existant. Pour la piste audio, on opte pour une simple conversion en PCM (passe partout).

La commande est:

mencoder nom_du_fichier.mkv -ovc copy -oac pcm -o nom_du_fichier.avi

Le paramètre -ovc donne le codec avec lequel on va encoder le flux video. Ici, `copy’ signifie qu’on ne réencode pas, on copie juste le flux. Le paramètre -oac permet de donner le codec audio utilisé. Ici, pcm.

Quand on n’a pas de chance, il faut réencoder le flux vidéo en xvid et le flux sonore en mp3. Et en prime, on veut vouloir sélectionner la piste audio (jpn), et inclure les sous titres.

Alons-y:

mencoder -vid 0 -alang jpn -slang eng \
-oac mp3lame -lameopts cbr=128 \
-ovc xvid -xvidencopts bitrate=900 \
nom_du_fichier.mkv -o nom_du_fichier_final.avi

Et voilà !
On jouera avec les options d’encodage selon nos besoins (man mencoder est votre ami à partir de maintenant) pour avoir des fichiers plus petits ou une meilleure qualité.