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.

Comment accéder aux données

Sur le principe du CRUD (Create Read Update Delete), cette classe contient des méthodes permettant d’effectuer les opérations de base.
Pour illustrer les exemples, nous utiliserons une table auteurs associée à l’objet Auteurs dont une instance est dans la variable $auteurs. Toujours pour l’exemple, la table est structurée ainsi :

• un entier qui sert d’index : id
• une chaîne pour le nom : nom

L’ajout de données

Pour ajouter un champ dans un table, il faut utiliser la méthode add. Elle prend en paramètre une table contenant toutes les données à ajouter. Les clés de la table doivent correspondrent aux noms des champs. Exemple :

/* On récupère les données issues du formulaire */
$auteur = $_POST['auteur'];if($auteurs->add($auteur))
{
    /* L'auteur à été ajouté */
}

associé au formulaire suivant :

<form action="ajoute-auteur.html" method="post">
<input name="auteur[nom]" type="text" />
<input name="auteur_ajout" value="Ajouter cet auteur" type="submit" />
</form>

Vous noterez que je n’ai rien mis pour le champ id, c’est parce que je le crée toujours en auto-incrément et c’est donc mySQL qui s’occupera d’y affecter une valeur lors de l’ajout. Cela s’applique aussi à tous les champs qui seraient définis avec une valeur par défaut : leur présence dans le tableau n’est pas obligatoire.

La lecture

Pour l’extraction de données j’ai créé trois fonctions :

• find_first()
• find_by_id()
• find_all()

find_first() et find_all() ont un seul paramètre : un tableau contenant la description de notre requête, la façon de construire ce tableau est assez simple : vous pouvez y mettre trois ordres : conditions, order et limit. Par exemple :

/* Trouver les 10 premiers auteurs classés suivant leur nom */
$ressource_mysql = $auteurs->find_all( array('order'=>'nom ASC', 'limit'=>10) );
 
/* Trouver le premier auteur classé suivant le nom */
$tableau_de_retour = $auteurs->find_first( array('order'=>'nom ASC') );
 
/* Trouver les 10 premiers auteurs classes dont le nom commence par 'bal' */
$ressource_mysql = $auteurs->find_all( array('conditions'=>"nom LIKE 'bal%'", 'limit'=>10) );
 
/* Trouver l'auteur qui a l'id 123 */
$tableau_de_retour = $auteurs->find_by_id(123);

La mise à jour

La façon de faire est exactement la même que pour l’ajout de données si ce n’est qu’il faut utiliser la fonction update_attributes($id, $donnees)

• $id est l’index du champ à mettre à jour.
• $données est le tableau contenant les données. Vous n’êtes pas obligé de mettre tous les champs présents dans la table, seul ceux qui sont dans le tableau sont mis à jour.

Il existe aussi une fonction permettant de mettre à jour un seul champ : update_attribute($id, $champ, $valeur)

La suppression de données

La aussi c’est très simple : la fonction destroy($id) permet de supprimer un enregistrement.

Extensions

Selon vos besoins et selon vos donnés, vous devrez ajouter des fonctionnalités à ces méthodes, par exemple : rechercher tous les auteurs selon leur nom. Ajoutez vos méthodes dans les fichiers correspondant à vos tables. Dans notre exemple vous pouvez créer une méthode find_all_by_name() dans le fichier auteurs.php

class Auteurs extends Database{
    function __construct($connexion, $table_name)
    {
        parent::__construct($connexion, $table_name);
    }
 
    public function find_all_by_name($name)
    {
        return $this->find_all(array("conditions"=>"name = 'hobb'");
    }
}

Ce qu’il reste à faire

Comme je l’ai déjà dit, le but de cette classe est juste de rendre service en gérant simplement des données, c’est pourquoi il n’y a pas d’abstraction au niveau de la gestion de la base de données même : On accède uniquement à une base mySQL. Il serait intéressant de sortir cette gestion de cette classe et de créer une autre couche permettant d’accéder à d’autres base de données comme PostgreSQL ou SQLite.

Si vous utilisez cette classe dans un de vos projets, vous pouvez m’envoyer l’adresse du site en question avec une petite description du projet afin d’être cité dans le billet des utilisateurs de cette classe.