Mirmo Dynamics - Tag - doc

Débuter avec le Zend Framework

Geoffrey — Thu, 12 Apr 2007 00:31:00 +0200

Je suis un peu triste parce que je voulais m'atteler à cette tâche, mais bon il faut croire que j'ai trop lambiné :)

Mini Howto: Serveur et Packages PEAR

Geoffrey — Fri, 02 Mar 2007 12:11:00 +0100

Pour installer le serveur PEAR, c'est simple:

pear channel-discover pear.chiaraquartet.net
pear install chiara/Chiara_PEAR_Server
pear run-scripts Chiara_PEAR_Server

Ensuite on répond aux question, et c'est automagique.

Après, pour créer des packages, ça se corse. Tout d'abord, on a besoin de PEAR_PackageFileManager:

pear install PEAR_PackageFileManager

Ensuite, le but est de générer les package.xml qui vont bien. Voilà comment j'ai procédé pour le package Zend:

mkdir -p ~/pear/zend/src && cd ~/pear/zend
wget http://framework.zend.com/download/tgz -O - | tar xzC ~
mv ~/ZendFramework-0.8.0/library/Zend* src/
php ./mkpkg.php make
cd src && pear package

Ceux qui ont bien suivi auront noté que mkpkg.php est sorti un peu de l'espace :-) Vous trouverez son contenu à la fin du billet.

Pour résumer, on créé un répertoire de travail (~/pear/zend/), dans lequel on créé un répertoire src, qui contiendra tous les fichiers du package, puis le script mkpkg.php se charge 1) d'analyser le contenu de src, et 2) de créer le package.xml qui va bien, selon les instructions qui lui sont fournies.

Nous disposons désormais d'un package Zend-0.8.0.tgz dans ~/pear/zend/src, que nous n'avons plus qu'a uploader via l'interface d'administration du serveur PEAR précédemment installé :-)

Le fichier mkpkg.php:

<?php

require_once('PEAR/PackageFileManager2.php');

PEAR::setErrorHandling(PEAR_ERROR_DIE);

$packagexml = new PEAR_PackageFileManager2;

$e = $packagexml->setOptions(array(
    'baseinstalldir' => '/',
    'packagedirectory' => dirname(__FILE__).'/src',
));

$packagexml->setPackage('Zend');
$packagexml->setSummary('Zend Framework');
$packagexml->setDescription('The Zend\'s PHP Framework');
$packagexml->setChannel('pear.phpmafia.net');
$packagexml->setAPIVersion('0.8.0');
$packagexml->setReleaseVersion('0.8.0');
$packagexml->setReleaseStability('devel');
$packagexml->setAPIStability('devel');
$packagexml->setNotes("Still a preview release");
$packagexml->setPackageType('php'); // this is a PEAR-style php script package
$packagexml->addRelease(); // set up a release section
$packagexml->setPhpDep('5.1.2');
$packagexml->setPearinstallerDep('1.4.0a12');
$packagexml->addMaintainer('lead', 'ash', 'Geoffrey Bachelet', 'geoffrey+pear@zubrowka.org');
$packagexml->setLicense('New BSD License', 'http://framework.zend.com/license/new-bsd');
$packagexml->generateContents(); // create the <contents> tag

$pkg = &$packagexml->exportCompatiblePackageFile1(); // get a PEAR_PackageFile object

if (isset($_GET['make']) || (isset($_SERVER['argv']) && @$_SERVER['argv'][1] == 'make')) {
    $pkg->writePackageFile();
    $packagexml->writePackageFile();
} else {
    $pkg->debugPackageFile();
    $packagexml->debugPackageFile();
}

?>

Interfaces et Classes Abstraites

Geoffrey — Wed, 31 Jan 2007 09:08:00 +0100

Les concepts de classes abstraites et d'interfaces sont souvents assez flous quand on débute dans la programmation objet, et on se fourvoie assez souvent sur leur utilisation et leur but. Voila une petite explication qui j'espère sera 1) juste et 2) assez claire pour tout le monde. Si vous pensez que je me fourvoie sur ces 2 concepts de base de la POO, n'hésitez pas à me le faire savoir !

Commençons par le commencement: l'Interface. Une Interface définit une API (Application Programming Interface), dont le seul et unique but est de décrire les méthodes disponibles pour un objet donné. Une Interface ne contient pas de code fonctionnel, seulement des synopsis de méthodes et d'attributs. Par exemple, l'utilisation du mot clé "instanceof" permet de déterminer si un objet donné implémente ou non une interface donnée, et d'adapter le comportement de l'application selon la réponse. Le "type hinting" permet également ce genre de choses:

<?php

interface Bar_Interface {
      public function doSomething();
}

class Bar implements Bar_Interface {
      public function doSomething() {
            echo "something was done.";
      }
}

class Foo {
      public function doSomething(Bar_Interface $bar) {
            $bar->doSomething();
      }
}

?>

Dans cet exemple, quand Foo::doSomething() est executée, on est certain que l'objet $bar dispose de la méthode doSomething car il implémente l'Interface Bar_Interface.

Vient ensuite la classe abstraite. La classe abstraite, "abstract class" en V.O., se comporte comme un squelette d'objet. Elle est utile dans le cas où on utilise une série d'objets d'une même famille qui partagent du code commun, mais qui comportent tous leurs particularités propres. Dans ce cas de figure, on commence par implémenter le code commun dans la classe abstraite, dont hériteront les autres objets, dans lesquels le code spécifique pourra à son tour être implémenté. C'est très utile pour certains Design Pattern, comme par exemple "Adapter" ou "Proxy", qui ont tous deux pour but de permettre des stratégies différentes pour une même situation, situation qui présente le plus souvent des points similaires quelque soit la stratégie adoptée.

En règle générale, une classe abstraite implémente une interface (et un exemple d'Adapter en cadeau bonux):

<?php

interface Bar_Adapter_Interface {
      public function doSomething();
}

class Bar {
      public function __construct(Bar_Adapter_Interface $adapter) {
            $this->_adapter = $adapter;
      }

      public function doSomething() {
            return $this->_adapter->doSomething();
      }

      static public function factory($adapter) {
            $className = "Bar_Adapter_".$adapter;
            if (!class_exists($className)) {
                  throw new Exception('Adapter not available: '.$adapter);
            } else {
                  return new Bar(new $className);
            }
      }
}

abstract class Bar_Adapter_Abstract implements Bar_Adapter_Interface {
      protected function getSomething() {
            return "la méthode pour accéder a ce truc est la même pour tout le monde";
      }
}

class Bar_Adapter_Explode extends Bar_Adapter_Abstract {
      public function doSomething() {
            return explode(' ', $this->getSomething());
      }
}

class Bar_Adapter_PregSplit extends Bar_Adapter_Abstract {
      public function doSomething() {
            return preg_split('/ /', $this->getSomething());
      }
}

$bar = Bar::factory('Explode');
print_r($bar->doSomething());

?>

Ici, l'objet Bar offre la méthode doSomething, qui présentement retourne une chaine explosée, et on propose deux adapteurs pour se faire, l'un utilisant explode(), l'autre preg_split(). Bien sur, cet exemple est complètement trivial :-)

Migrer un dépot subversion

Geoffrey — Thu, 09 Nov 2006 17:25:00 +0100

Imaginons que vous souhaitiez déplacer votre dépôt subversion myproject d'une machine old-server à une machine new-server. Vite fait, bien fait:

old-server# svnadmin dump /var/lib/subversion/myproject > ~/myproject.svndump
old-server# scp ~/myproject.svndump new-server:
new-server# svnadmin create /var/lib/subversion/myproject
new-server# svnadmin load /var/lib/subversion/myproject < ~/myproject.svndump

Attention, il vous faut par contre migrer vos éventuelles hooks à la main, ils ne sont effectivement pas gérés par svndump. Une autre méthode, incluant les hooks celle-ci, serait d'utiliser svnadmin hotcopy, mais je n'ai pas testé.

Plus d'infos:

Incubated

Geoffrey — Wed, 01 Nov 2006 16:10:00 +0100

Les liens interressants (ou pas) de la semaine:

J'ai pas mal entendu parler des microformats ces derniers temps, sans vraiment prendre le temps de me pencher dessus. microformats.org présente l'occasion de se plonger dedans et de comprendre que finalement, les microformats peuvent être un facteur de développement non négligeable pour un site ou une application web. GeoRSS de son côté propose une implémentation simple et puissante (c'est eux qui le disent) du Geotagging. A voir si on ne peut pas coupler tout ça avec quelques pirouettes sur Google Maps...

Pendant ce temps, chez Canonical, on établit déjà les specifications fonctionnelles de Feisty Fawn, et c'est assez prometteur :-)

Enfin, dans le petit monde du PHP et du webdev en général, il n'est jamais trop tard pour souligner l'existence de protocoles d'authentification centralisée libres comme OpenID, qui de plus à lancé un concours d'implémentation sous forme de bounties ! On notera également les débuts de l'extension d' input filtering pour PHP, qui promet de simplifier grandement la validation de données externes dans les applis PHP. Enfin, les slides de la conférences PHP Best Practices qui a eu lieu à la ZendCon, c'est vraiment rempli de bons conseils.

Howto: Utiliser Zend_Controller_RewriteRouter avec Zend_Config

Geoffrey — Tue, 31 Oct 2006 20:26:00 +0100

Comme je le disais plus bas, le Zend Framework Preview 0.2.0 est dans les bacs ! Cette nouvelle mouture apporte son lot de nouveautés, et nous allons nous pencher sur une des plus interressantes: le RewriteRouter. Le RewriteRouter est un routeur pour le composant MVC du Zend Framework qui va nous permettre de configurer nos URL comme dans Ruby on Rails, c'est à dire (en gros), via un fichier de configuration, et c'est là que Zend_Config entre en jeu.

Mettre en place le routeur

C'est bien beau tout ça, mais pour l'utiliser, il faut déjà en informer le controlleur. Pour cela, rien de plus simple, on utilise la méthode addRouter:

$router = new Zend_Controller_RewriteRouter;
$controller = Zend_Controller_Front::getInstance();
$controller->setRouter($router);

Le RewriteRouter est pré-configuré avec deux routes qui permettent d'assurer la compatibilité descendante avec l'ancien routeur, donc jusque là, tout va bien.

Déclarer les routes

Nous utiliserons un fichier de configuration dédié aux routes, que nous appellerons sobrement routes.ini, et que nous placerons dans app/, à coté de son compagnon config.ini. Ce fichier de configuration contiendra une unique section [routes], qui contiendra à son tour les multiples définitions de routes que nous souhaitons y caser. Une route se compose de 5 éléments principaux:

L'identifiant de la route. C'est un identifiant interne utilisé par le RewriteRouter,
l'URL de la route, c'est ce qui permet au routeur de reconnaitre la route à utiliser,
les valeurs par défauts des variables,
les requirements de la route, qui permettent de déterminer si une route est bien formée ou non.

Sans plus attendre, un petit exemple: la route qui pourrait permettre d'accéder à un billet dans dotclear 2:

post.route = post/:year/:month/:day/:title
post.reqs.year = "\d+"
post.reqs.month = "\d+"
post.reqs.day = "\d+"
post.reqs.title = "[a-zA-Z0-9_:-]"+
post.defaults.controller = post
post.defaults.action = view
post.defaults.title =

Elle pourrait seulement, car en fait, la regexp du title est trop restrictive (une URL peut contenir d'autres caractères que ceux là), et de plus, les URL stockées par dotclear 2 en base de données comprennent tout ce qui se trouve après post/ (par exemple le champs post_url de ce billet contient: 2006/10/31/Howto:-Utiliser-Zend_Controller_RewriteRouter-avec-Zend_Config).

Cela étant dit, la route que nous venons de décrire s'appliquera aux URLs suivantes:

/post/2006/30/10/ZendFramework
/post/42/2006/56/Foobar
/post/2006/30/10/
etc.

Mais pas à:

/post/2006/Foobar
/post/Foobar/2006/30/01
etc.

On note donc d'ores et déjà:

que la validation des composants d'une route se fait par expression régulière
qu'on peut ommettre le dernier composant d'une route si il possède une valeur par défaut (récursivement)
qu'on ne peut pas modifier l'ordre des composants d'une route
qu'on doit spécifier manuellement le nom du controlleur et de l'action à utiliser
et c'est déjà pas mal.

Décortiquons maintenant une URL: /post/2006/30/10/ZendFramework. Le routeur va diviser cette URL ainsi:

Controller: post (d'après les defaults)
Action: view (d'après les defaults)
Paramètres: year: 2006, month: 30, day: 10, title: ZendFramework (d'après l'URL)

Les paramètres ainsi détectés seront disponibles via la méthode $this->_getParam($name); a l'intérieur du controlleur.

Dernier point de ce chapitre, une déclaration de route peut comporter deux variables spéciales: :controller et :action, qui servent respectivement à détecter le controller et l'action à utiliser dans l'url. Par exemple, la route builtin compat chargé d'assurer la compatibilité descendante se déclare ainsi:

compat.route = :controller/:action
compat.defaults.controller = index
compat.defaults.action = index

Assembler le tout

Dernière étape, transférer directement toutes ces déclarations dans le Routeur: n'y allons pas par quatre chemin:

$router->addConfig(new Zend_Config_Ini('/path/to/routes.ini', null), 'routes');

C'est aussi simple que ça. Ce qui nous donne, en prenant en compte le morceau de code du début de l'article:

$router = new Zend_Controller_RewriteRouter;
$router->addConfig(new Zend_Config_Ini($routes_path, null), 'routes');
$controller = Zend_Controller_Front::getInstance();
$controller->setRouter($router);

And voilà. Je ne saurais que vous conseiller la lecture du manuel pour plus d'informations (sachant qu'en fait, addRoute attend en deuxième argument une instance de Zend_Controller_Router_Route, mais qui s'instancie avec les paramètres qu'ils passent à addRoute, petite coquille du manuel :p).

Relayer un stream audio avec icecast2

Geoffrey — Fri, 20 Oct 2006 22:05:00 +0200

Pour économiser la bande passante au boulot, j'ai décidé de relayer le stream Club ! de 1.fm sur le LAN. Après avoir vainement tenté d'utiliser streamripper (on verra plus tard pourquoi vainement), j'ai sorti l'artillerie lourde: icecast2:

sudo apt-get install icecast2

Si on sait un peu lire, le script de post-configuration nous incite à aller fourrer notre nez dans /etc/default/icecast2, où l'on apprend (vers la fin) que icecast est désactivé par défaut à cause de la directive ENABLED=false. C'est en fait une feinte pour nous pousser à configurer le bousin (de toute façon si on le configure pas, il marchera pas). Direction /etc/icecast2/icecast.xml donc, pour un brin de configuration (les explications qui suivent se basent sur le fichier par défaut d'une installation sur une ubuntu).

La première partie qui nous interresse s'intitule authentication (vers la ligne 23). Elle contient les informations d'authentification pour les clients qui se connectent en tant que source (source-password), les serveurs qui se connectent en tant que slave (relay-password, en fait je ne suis pas sur à 100%, c'est une déduction) et pour l'interface d'administration (admin-user et admin-password). Une fois ces informations modifiées, direction la directive hostname, qu'on remplira avec au choix, le nom de la machine, son ip, etc. J'ai personellement mis l'ip privée de ma machine (172.16.x.y), pour que ça correspondent à la prochaine directive qui nous interresse: listen-socket. Ici on définit le port et l'ip sur laquelle icecast va écouter. En gros, si vous spécifier 127.0.0.1, votre serveur de streaming ne sera accessible qu'en local. On y met donc en général la même chose que dans hostname (172.16.x.y par exemple), avec un port qui va bien, libre de préférence (8000 par défaut).

Maintenant on passe a la partie qui nous interresse vraiment, la section relay. Rien de bien compliqué ici. Le stream que je souhaite relayer se trouve là: http://64.62.253.223:8060/, or icecast nous demande un server, un port, un point de montage (mount) et un point de montage local (local-mount). Vous avez déjà compris qu'on arrive a cette configuration:

   <relay>
       <server>64.62.253.223</server>
       <port>8060</port>
       <mount>/</mount>
       <local-mount>/1.fm</local-mount>
       <on-demand>0</on-demand>
       <relay-shoutcast-metadata>1</relay-shoutcast-metadata>
   </relay>

Ainsi parés, il ne nous reste plus qu'a lancer modifier la directive ENABLED=false en ENABLED=true dans /etc/default/icecast2 et à lancer icecast:

sudo /etc/init.d/icecast2 start

Si vous avez bien tout fait, vous devriez pouvoir streamer depuis http://172.16.x.y:8000/1.fm, et vos collègues également ! Vous pouvez avoir une vue d'ensemble du serveur ainsi que quelques options d'administration en vous rendant sur l'interface d'admin: http://172.16.x.y:8000/ et en utilisant admin-user et admin-password pour vous authentifier.

A cela on peut ajouter un petit streamripper:

streamripper http://172.16.x.y:8000/1.fm -d ~/streamripped

Pour enregistrer. En parlant de streamripper, j'avais tenté au début de relayer avec streamripper -r, mais malgrès les apparences du netstat -pl (*:8000 LISTEN), il ne bind qu'en local, donc impossible d'en faire profiter les collègues :-)

Écrire de la doc...

Geoffrey — Mon, 16 Oct 2006 11:46:00 +0200

... c'est chiant. Surtout pendant cinq longues heures. Mais le résultat est appréciable, merci phpdoc :-)