Dans ma quête de stabilité, je me suis dit qu’utiliser Gearman serait une bonne idée, il est censé être simple, scalable, stable, et tout et tout.

Voici la structure mise en place :

• Un client, qui en fait est un script PHP, qui envoie envoie des jobs (des tâches) au serveur gearman.
• Un serveur gearman qui s’occupe d’empiler les jobs et de les distribuer au workers.
• Plusieurs workers qui eux aussi sont des scripts PHP. Ils reçoivent les jobs que le client à envoyé au serveur. Une fois le job terminé, le worker qui avait le job en charge retourne le résultat au client via le serveur.

On verra pas la suite que le client n’est pas obligé d’attendre le résultat de ses jobs. Dans ce cas le client ne sait pas si le job s’est bien passé et il ne connaitra pas non plus le résultat du job.

Dans mon cas je n’ai pas besoin du résultat, j’ai juste besoin d’empiler des jobs afin de les lancer en parallèle et ce n’est pas la peine d’attendre que chaque job ait fini son travail.

Installation

L’installation décrite ici est pour Linux, pour Ubuntu plus exactement, voici la démarche a suivre :

Il faut ajouter ce dépôt à vos sources dans le fichier /etc/apt/sources.list :  https://launchpad.net/~gearman-developers/+archive/ppa

On met à jour puis on installe gearman avec apt-get :

apt-get update
apt-get upgrade
apt-get install gearman-job-server

On installe l’extension pour PHP

apt-get install php5-dev
apt-get install libgearman-dev
wget http://pecl.php.net/get/gearman-0.8.0.tgz
tar xzf gearman-X.Y.tgz
cd gearman-X.Y
phpize
./configure
make
make install

Si tout se passe bien, on a juste à a jouter l’extension au fichier php.ini :

extension="gearman.so"

Et on n’oublie pas de recharger son serveur web pour prendre en compte la nouvelle extension.

Pour vérifier que tout est bien en place, on peut utiliser cette commande :

print gearman_version();

Le client

Voila le code du client utilisé :

$client= new GearmanClient();
$client->addServer("127.0.0.1", 4730);
 
$task_id = 0;
while($image_id = get_new_image())
{
    $params = array(
        "db_config" => $db_config[$options['environment']],
        "image_id" = $image_id,
    );
 
    $client->addTaskBackground("process_image", serialize($params), null, "T".$task_id++);
}
$client->runTasks();
exit(0);

On commence par créer un objet GearmanClient, il se connectera à notre serveur grâce au addServer.

Dans cet exemple, on empile des traitements sur des images, c’est la fonction process_image qui sera appelée par chaque job.

On crée aussi un tableau de paramètres qui sera sérialisé avant d’être envoyé au job. Les paramètres que j’ai mis ici sont juste des exemples, on peut y mettre ce qu’on veut pourvu que ce qu’on y met soit sérialisable.

Le runTasks() achève le travail et indique au serveur de lancer les tâches.

Les workers

Pour gérer les workers, j’ai fait un petit script qui en lance un certain nombre à coup de fork().

echo "Starting {$nb_workers} workers : ";
for($i=0; $i<$nb_workers; $i++)
{
     $pid = pcntl_fork();
      if($pid == -1)
      {
          echo "Fork error !\n";
      }
      else if($pid)
      {
         $pids[] = $pid;
         echo "Worker pid : {$pid}\n";
      }
      else
      {
         call_user_func_array("run", array());
         exit(0);
     }
 }
 
 [...]
 
 function run()
 {
     $worker= new GearmanWorker();
     $worker->addServer("127.0.0.1", 4730);
     $worker->addFunction("process_image", "do_work");
     while($worker->work());
}
 
function do_work($job)
{
    $params = unserialize($job->workload());    
 
    // Code du traitement de l'image
}

A vous de l’adapter selon vos besoins, il n’y a la rien de bien compliqué.

Conclusion

Finalement, la mise en place d’un tel système s’avère assez simple et rapide. Il ne nous aura pas fallu plus d’une journée pour réaliser l’ensemble alors que nous n’avions jamais touché à Gearman auparavant.

La stabilité à l’air d’être au rendez-vous, nous n’avons eu aucun plantage de job ou autre depuis sa mise en tests et nous lançons environs 700 jobs par jours repartis sur 10 workers. C’est pas énorme mais on a prévu de charger un peu plus la bête dans un second temps.

Pour plus d’informations, voici quelques liens :

• http://fr.php.net/manual/en/book.gearman.php
• http://gearman.org/

Il faut soit  créer des virtual host pour tous vos sous-domaine.

Soit créer un seul virtual host en utilisant des wildcards dans le ServerAlias, du coup tous les sous-domaines pourraient correspondre à une application, plus besoin de créer autant de virtual hosts que de sous-domaine. Il doit même être possible d’utiliser les wildcards dans la déclaration du domaine dans le gestionnaire de dns.

ServerName domain.tld
ServerAlias *.domain.tld

Coté symfony

Il faut renommer le fichier web/index.php en web/frontend.php
Puis re-créer le fichier web/index.php en y mettant le code qui permettra de choisir l’application
en fonction du sous domaine.
Voici un exemple, il suffit de modifier le switch() pour l’adapter à vos besoins :

require_once(dirname(__FILE__).'/../config/ProjectConfiguration.class.php');
// Trouve le sous-domaine
list($subdomain, $domain, $tld) = explode('.', $_SERVER['HTTP_HOST']);
 
// En deduit l'application
switch($subdomain)
{
    case "documentation":
        $app = "documentation";
    break;
 
    default:
        $app = "frontend";
    break;
}
$configuration = ProjectConfiguration::getApplicationConfiguration($app, 'prod', false);
sfContext::createInstance($configuration)->dispatch();

On a donc un script lancé à intervalles réguliers qui lui même va lancer et gérer un certain nombre, configurable, de tâches concurrente. Voici comment j’ai procédé.

Avant de continuer, il est bon de noter que j’ai effectué tous mes tests sur une machine fonctionnant sous linux, je n’ai aucune idée de la façon dont ça peu fonctionner sous windows, si jamais ça fonctionne sous windows les fonctions pcntl ne fonctionnent pas sous windows, donc pas de multitâche, avec cette méthode en tous cas, pour cette plateforme.

Un petit exemple vaut mieux que de longs discours :

function task($msg)
{
    echo "Task say $msg\n";
}
 
$t = new Task();
$t->fork('task', array("hello"));

On peut sans problème lancer plusieurs tâches en créant plusieurs objets Task.

Et vérifier qu’une tâche est en cours avec la méthode is_running()

Ici, pour l’exemple, on lance simplement une nouvelle tâche dont l’action principale sera d’afficher du texte, mais en général on à tendance à faire des tâches pour effectuer un traitement lourd ou long. Par exemple si on doit vérifier qu’une liste sites répondent correctement (disons 10 000 sites) sans utiliser de multitâche, si on a un timeout de 5 secondes et que 10% des sites sont hs, on perdra 5000 secondes à attendre. Par contre si on lance 100 tâches, potentiellement, on divises par 100 le temps d’attente.

Voici le code de cette classe

class Task
{
    private $pid;
    private $priority=0;
 
    protected $children_pid=array();
 
    public function __construct()
    {
        if(!function_exists("pcntl_fork"))
        {
            throw new Exception ("Your system does not support pcntl (thread) functions");
        }
 
        // Set the default signal handler
        $this->add_signal(SIGTERM, array($this, "signal_handler"));
        $this->add_signal(SIGINT, array($this, "signal_handler"));
        $this->add_signal(SIGQUIT, array($this, "signal_handler"));
    } 
 
    public function __destruct()
    {
        $this->wait_children();
    } 
 
    public function is_running()
    {
        $pid = pcntl_waitpid($this->pid, $status, WNOHANG);
        return($pid === 0);
    }  
 
    public function wait_children()
    {
        foreach($this->children_pid as $child_pid)
        {
            pcntl_waitpid($child_pid, $status);
        }
    }
 
    public function fork($name, $params=array())
    {
        $pid = pcntl_fork();
 
        if($pid === -1)
        {
            throw new Exception("Unable to fork");
        }
        elseif($pid > 0)
        {
            // Parent
            $this->children_pid[] = $pid;
        }
        elseif($pid === 0)
        {
            // Child
            call_user_func_array($name, $params);
            exit(0);
        }
    }
 
    public function add_signal($signal, $function_name)
    {
        if(!pcntl_signal($signal, $function_name))
        {
            throw new Exception("Can't add the signal");
        }
    }
 
    public function signal_handler($signal)
    {
        switch($signal)
        {
            default:
            case SIGTERM:
                exit(0);
            break;
 
            case SIGQUIT:
            case SIGINT:
            case SIGKILL:
                exit(1);
            break;
        }
    }
 
    public function get_pid()
    {
        return $this->pid;
    }
 
    public function set_priority($priority, $process_identifier=PRIO_PROCESS)
    {
        if(!is_int($priority) || $priority < -20 || $priority > 20)
        {
            throw new Exception("Invalid priority");
        }
 
        if($process_identifier != PRIO_PROCESS || $process_identifier != PRIO_PGRP || $process_identifier != PRIO_USER)
        {
            throw new Exception("Invalid process identifier type");
        }
 
        if(!pcntl_setpriority($priority, $this->pid, $process_identifier))
        {
            throw new Exception("Can't set the priority");
        }
 
        $this->priority = $priority;
    }
 
    public function get_priority()
    {
        return $this->priority;
    }
 
    public function kill($pid)
    {
        posix_kill(pid, SIGHUP);
    }
}

La preuve :

var_dump(0 == "toto");

Voir ça sur codepad

Ajouter un produit

C’est le plus simple, il suffit de récupérer l’id du produit puis de tout simplement l’ajouter au panier

$id = Mage::getModel('catalog/product')->getIdBySku("product_sku");
$cart = Mage::getModel("checkout/cart");
$cart->addProductsByIds(array($id));
$cart->save();

Enlever un produit

C’est un peut plus compliqué, il faut parcourir tout le panier pour vérifier si l’id du produit à enlever est bien présent et le supprimer si c’est le cas

$cart = Mage::getModel("checkout/cart");
$id = Mage::getModel('catalog/product')->getIdBySku("product_sku");
 
$items = $cart->getItems();
foreach($items as $item)
{
    if($item->getProduct()->getId() == $id)
    {
        $itemId = $item->getItemId();
        $cart->removeItem($itemId)->save();
    }
}

Je pense que vous avez déjà installé PHP 5.3, sinon, cet article est pour vous.

Commencez par télécharger les sources de Xdebug sur le site officiel et décompactez les dans un répertoire, peut-importe où.

wget http://www.xdebug.org/link.php?url=xdebug203
tar -xvf xdebug-2.0.3.tgz
cd xdebug-2.0.3

Un fois fait, il faut lancer phpize, attention, il faut lancer le bon phpize, celui de PHP 5.3, chez moi il est dans /usr/local/php5.3/bin

/usr/local/php5.3/bin/phpize

Il ne reste plus qu’a compiler en indiquant bien quel php utiliser, comme avec phpize

./configure --enable-xdebug --with-php-config=/usr/local/php53/bin/php-config
make
cp modules/xdebug.so /usr/local/php53/xdebug.so

On ajoute le module au fichier php.ini (chez moi il est dans /usr/local/php53/lib/php.ini) et c’est fini :

zend_extension="/usr/local/php53/xdebug.so"

La suite, notamment la configuration et l’utilisation du profiler et le debug php pas à pas, est disponible sur le blog de Jean-Phi

Nous avons créé deux classes, Observable et Observer. La première sera héritée par les objets que nous souhaitons rendre observables et la seconde contient la définition de l’objet qui appellera le les méthodes déclenchées par les évènements.

Voici le code de ces deux classes, nous verrons après comment l’utilise.

Observer

final class Observer
{
    protected static $_instance;
    protected $_observed_events=array();
 
    public static function get_instance()
    {
        if(is_null(self::$_instance))
        {
            $c=__CLASS__;
            self::$_instance = new $c;
        }
        return self::$_instance;
    }
 
    public function observe($observed_class, $event, $called_class, $called_method, $arguments=array())
    {
        $this->_observed_events[]=array('observed_class' => $observed_class, 'event' => $event, 'called_class' => $called_class, 'called_method' => $called_method,'arguments' => $arguments);
    }   
 
    public function call_back($observed_class, $event)
    {
        $return_value=true;
        foreach ($this->_observed_events as $key => $value)
        {
            if($value['observed_class']==$observed_class && $value['event']==$event)
            {
                $return_value&=call_user_func_array(array($value['called_class'], $value['called_method']), $value['arguments']);
            }
        }
 
        return $return_value;
    }
}

Observable

interface iObservable
{
    public function __call($method_name, $arguments);
    public static function __callStatic($method_name, $arguments);
}
 
abstract class Observable implements iObservable
{
    public function __call($method_name, $arguments)
    {
        $ret = false;
        if(Observer::get_instance()->call_back(__CLASS__, 'before_'.$method_name))
        {
            $ret = call_user_func_array(array($this, '_'.$method_name), $arguments);
        }
        Observer::get_instance()->call_back(__CLASS__, 'on_'.$method_name, $ret);           
 
        return $ret;
    }
 
    public static function __callStatic($method_name, $arguments)
    {
        $ret = false;
        if(Observer::get_instance()->call_back(__CLASS__, 'before_'.$method_name))
        {
            $ret = call_user_func_array(array(__CLASS__, '_'.$method_name), $arguments);
        }
        Observer::get_instance()->call_back(__CLASS__, 'on_'.$method_name, $ret);       
 
        return $ret;
    }
    public function add_observer($event, $called_class, $called_method, $arguments=array())
    {
        Observer::get_instance()->observe(__CLASS__, $event, $called_class, $called_method, $arguments=array());
    }
}

Utilisation

Encore un peu de code pour illustrer tout ça, on commence par planter le décor avec nos deux classes.

class ClassA extends Observable
{
    public function _my_function_a()
    {
        return("Je suis dans ClassA");
    }
}
 
abstract class CalledClass
{
    public static $value;
 
    public static function callback_function_a()
    {
        self::$value = "je suis dans CalledClass";
        return true;
    }
}

Puis on place notre observer on on vérifie que tout c’est bien passé

ClassA::add_observer('on_my_function_a', 'CalledClass', 'callback_function_a');
 
$this->a = new ClassA();
echo $this->a->my_function_a();
echo CalledClass::$value;

Je vous laisse découvrir les petites subtilités du code que l’on n’a pas abordées ici, notamment dans les fonction magique.

Un indice : le callback est automatiquement appelé (s’il existe bien sûr) pour les méthodes qui commencent par un underscore, sinon vous pouvez placer des Observer::get_instance()->call_back(__CLASS__, $event); dans votre code aux endroits stratégiques de votre méthode observée.

Maintenant il faut télécharger PHP6 et le compiler, allez voir le blog de Jean-Phi, il a fait un billet qui détaille la procédure.

Voila, il ne reste plus qu’a configurer Apache, j’ai eu besoin d’utiliser le module Actions qui n’était pas activé chez moi, pour l’activer, c’est très simple :

sudo a2enmod actions

Passons à la configuration de votre virtual host, il suffit d’ajouter ce qui suit à un host :

ScriptAlias /php6-cgi /usr/local/bin
Action php6-script  /php6-cgi/php-cgi
AddHandler php6-script .php

Ce qui donne pour le virtual host complet :

<VirtualHost *>
        ServerName www.monsite.com
 
        DocumentRoot /home/mon_site/www/
        ScriptAlias /php6-cgi /usr/local/bin
        Action php6-script  /php6-cgi/php-cgi
        AddHandler php6-script .php
 
        <directory>
                Options Indexes FollowSymLinks MultiViews
                AllowOverride None
                Order allow,deny
                allow from all
        </directory>
<VirtualHost>

Le chemin du Scriptalias (/usr/local/bin) doit correspondre au répertoire où est installé php-cgi, celui qui à été installé manuellement avec PHP6

Après, vous pouvez modifier le AddHandler comme vous le souhaitez, dans cet exemple, les fichiers .php sont considérés comme du PHP6 mais si vous voulez, vous pouvez faire en sorte que seuls les fichiers .php6 soient interprétés par PHP6 comme ça les fichiers .php continueront d’être considérés comme du PHP5 :

ScriptAlias /php6-cgi /usr/local/bin
Action php6-script  /php6-cgi/php-cgi
AddHandler php6-script .php6

Un simple phpinfo(); devrait vous confirmer que votre configuration fonctionne.

Préquis

• Un serveur linux sur une base débian, ubuntu… pour profiter d’apt-get
• Un accès administrateur (au moins pouvoir faire des sudo)
• Apache, testé sur un apache 2.2 mais la version n’a pas vraiment d’importance

Installation

Comme nous allons compiler PHP nous aurons besoin des outils de compilation, si vous ne les avez pas déjà installés faites un sudo apt-get install build-esssensials automake pour installer gcc et tout son attirail.

Nous aurons aussi besoin de quelques bibliothèques :

sudo apt-get install apache2-prefork-dev
sudo apt-get install libicu36-dev
sudo apt-get install libxml-dev

Vous pouvez choisir apache2-threaded-dev à la place da apache2-prefork-dev, ça devrait aussi marcher.

Maintemant occupons nous de PHP6 : téléchargez les sources sur snaps.php.net et décompressez l’archive avec : tar xvfz <archive.tar.gz>

Allez dans ce répertoire et lancez la compilation :

./configure --with-apxs2=/usr/bin/apxs2 --enable-soap
make
make test
sudo make install

Sous root créez le fichier /etc/apache2/php6.conf et placez y :

<IfModule mod_php6.c>
  AddType application/x-httpd-php .php
  AddType application/x-httpd-php-source .phps
</IfModule>

De même avec le fichier /etc/apache2/php6.load

LoadModule php6_module /usr/lib/apache2/modules/libphp6.so

On initialise le module et on relance apache :

sudo a2enmod php6
sudo /etc/init.d/apache2 restart

Tests

Si tout s’est bien passé, un simple phpinfo devrait confirmer que PHP6 est bien installé, pour aller un peu plu loin, testez les namespaces.

Un petit bonus

Voici deux petits scripts pour passer de PHP5 à PHP6 et inversement de façon simple :

Activer PHP6

#!/bin/bash
sudo a2dismod php5
sudo a2enmod php6
sudo /etc/init.d/apache2 restart

Activer PHP5

#!/bin/bash
sudo a2dismod php6
sudo a2enmod php5
sudo /etc/init.d/apache2 restart

La suite

Si j’ai le temps, je me pencherai sur la configuration à mettre en place pour installe PHP6 et PHP5 conjointement sur le même serveur. Il faudra sûrement en installer un en module (PHP5) et l’autre en CGI (PHP6)

Encoder ses scripts

L’encodage permet de rendre illisible le code source d’un script sans en changer son comportement, le script encodé continuera de s’exécuter comme avant.

Il y a tout de même une contrainte : votre script doit entièrement être en php, pas de mélange php + html dans le même fichier. Je n’ai pas non plus testé cette méthode en profondeur, il y a sûrement plein de cas où elle n’est pas applicable, n’hésitez pas à poster des commentaires à ce sujet.

Fonctionnement de l’encodage

Le principe est assez simple : On commence par lire entièrement le fichier à encoder et on enlève les balises <?php et ?>, normalement il n’y en a que deux, une au début et une à la fin du fichier.

Ensuite on fait un simple encodage en base 64 du script, on mélange le tout en utilisant une table de correspondances et c’est tout.

Enfin presque, il ne nous reste plus qu’a ajouter le décodeur et à enregistrer le tout dans un autre fichier. Le décodeur fait l’opération inverse : il remet les données dans le bon ordre, applique un base_64decode() et lance le script grâce à un eval()

Voila le code de l’encodeur, il vous affiche le script encodé à la fin dans un textarea pour pouvoir le copier-coller facilement.

$nom_fichier = 'mon_script_a_encoder.php';
$fichier = trim(file_get_contents($nom_fichier));
$fichier = preg_replace("/^<\?(php)?/", '', $fichier);
$fichier = preg_replace("/\?>$/", '', $fichier);
 
echo '<h1>Encodage</h1>';
echo '<p>Nom : '.$nom_fichier.'</p>';
 
$b64 = base64_encode($fichier);
echo '<p>Base 64 : '.$b64.'</p>';
 
$tr = strtr($b64, " kCV]4m.DNvM>lstIKLBE6}ghf8[QAowPSR9ibX3cO{up=0anq27jF1eJx/UWGrzHT<5yZYd","ACv.sfKXY{dEn58wjIBToFUtb9>gL}=kqeZ0RuD[4lz Om<12PyHSWJGp7MaiVQr/cN]h63x");
echo '<p>Translation : '.$tr.'</p>';
 
$enc  = "\$__c='".$tr."';";
$enc .= "\$__s=strtr(\$__c,\"ACv.sfKXY{dEn58wjIBToFUtb9>gL}=kqeZ0RuD[4lz Om<12PyHSWJGp7MaiVQr/cN]h63x\",\" kCV]4m.DNvM>lstIKLBE6}ghf8[QAowPSR9ibX3cO{up=0anq27jF1eJx/UWGrzHT<5yZYd\");";
$enc .= '$__d=strrev("edoced_46esab");eval(\'$__x=$__d("$__s");\');eval($__x);';
 
echo '<h1>Résultat</h1>';
echo '<textarea cols="100" rows="10">';
echo '<?php '.$enc.' ?>';
echo '</textarea>';

Le mot de la fin

Vous avez vu que ce procédé est assez simple, il ne tiendra pas longtemps face à un vrai développeur mais devrait suffire dans la plupart des cas. Vous pouvez aussi vous amuser avec pobs pour obfusquer vos scripts ou si vous prévoyez une plus large diffusion vous devrez peut-être utiliser un encodeur plus évolué (bien plus) du genre de Zend Guard ou ionCube PHP encoder.