Développement

• Une mise a jour de PHP 5.3 est disponible dès aujourd’hui, elle corrige une faille de sécurité critique.
• Crypter des données avec une clé Privée/Publique en php : www.joeldare.com/wiki/php:php_public_private_key_cryptography
• Refaire la timeline de Facebook en js+css, tout est expliqué pas à pas ici  : www.9lessons.info/2012/01/facebook-timeline-design-using-jquery.html

SEO

• Le pagerank est-il vraiment utile pour le positionnement ? www.lemarketingenligne.com/non-classe/dites-adieu-au-pagerank
• Deux logiciels de spinning gratuits : www.effi10.com/seo-referencement/logiciel-spinning-gratuit et lab.webimago.fr/web-imago-spin

Voila, une petite chronique, il n’y a pas grand chose mais c’est volontaire je ne souhaite y mettre que ce qui m’a réellement marqué.

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/

// Préparation des handles cURL
 
do
{
    curl_multi_exec($mh, $running);
}while($running>0);
 
// Traitement des requetes

C’est biensûr la boucle do … while qui est en cause ici.

Pourtant il y a une méthode simple pour indiquer à cURL d’attendre tant qu’il y a de l’activité sur un handle. Méthode que je ne connaissais pas et que voici :

Il suffit d’utiliser curl_multi_select()

// Préparation des handles cURL
 
do
{
    curl_multi_exec($mh, $running);
    $ready = curl_multi_select($mh);
}while($running>0 && $ready!=-1);
 
// Traitement des requetes

C’est tout, mon script est passé de 100% de charge à environ 2%.

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

Cette dernière année à été riche en évènements pour moi, beaucoup de changements, dans l’ordre :

• Je me suis marié !
• J’ai trouvé un travail qui me plait beaucoup dans une petite entreprise bien sympathique et dynamique.
• J’ai déménagé et j’ai changé de région (J’ai quitté le Vaucluse pour la Savoie)
• Et surtout, je suis l’heureux papa de la plus jolie de toutes les petites filles.
  Julie est née le 28 janvier 2010 !

Ça commence et ça termine bien non ?

Faites vite, seuls les 3 premiers en auront une.

Pour empêcher ça avec apache, quelques lignes dans votre httpd.conf suffisent :

<Directory ~ ".*\.svn">
    Order allow,deny
    Deny from all
    Satisfy All
</Directory>

Thanks Anton Isaykin for pointing that out to us.

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();
    }
}