Dés mon arrivé, j’ai été surnommé Mr Jelix (amicalement bien sûr). Mon but n’était pas vraiment de dire symfony ça pue et jelix c’est bien mais vraiment de pouvoir poser des questions (pas forcement les plus intelligentes :p) et d’avoir une présentation de symfony par son auteur et ses contributeurs dans le cadre du choix d’un framework, une problématique qui se présente de plus en plus dans une offre de plus en plus pléthorique.

A l’accueil, on vous donne un petit sac avec quelques brochures, un callepin et une clé usb aux couleurs de Sensio Labs et de symfony. Un petit-déjeuner copieux était servi en attendant le début de la conférence.
J’ai pu discuté un moment avec Nicolas Perriault et voir un peu ce que symfony pouvait apporter au niveau des projets et j’ai pu aussi en apprendre davantage sur le framework.

La conférence était intéressante avec la possibilité de poser des questions à différents interlocuteurs, d’en savoir un peu plus.
Je n’avais pas d’à priori sur symfony mais pour le moment je reste sur mon impression de framework qui peut tout faire (ce qui est déjà très bien) mais que c’est au sacrifice bien sûr à mon avis des performances (je parle bien sûr de projets qui n’ont pas le budget serveur de yahoo par exemple), ce qui est normal.
Il ne colle pas vraiment avec mon idée de ce que je me fais d’un framework mais qui reste une option intéressante.
Sensio Labs propose maintenant un support sur symfony qui ne m’a pas trop convaincu en tant que développeur par rapport au rapport prix / type de support. Maintenant, c’est un plus non négligeable pour symfony.

A tester pour vous faire votre propre opinion.

Jelix c’est bien mais y a pas de support ?

Depuis quelques temps, Disruptive Innovations, qui emploi Laurent Jouanneau (le créateur de Jelix), propose du support, du conseil et autres services (assistance par téléphone notamment). Ce support est payant mais il y a la possibilité d’obtenir de l’aide via les forums et le channel irc. Il est rare de ne pas trouver solution à son problème.

Il y a plus de développeurs qui connaissent le framework X mais pas le framework Jelix…

Si un développeur ne sait pas s’adapter en peu de temps à un outil, il faut se poser la question de l’embauche car au final, cela reste un cadre de travail. Qui plus est, l’apprentissage de Jelix est rapide et ne nécessite pas de compétences supplémentaires autre que la connaissance de php et de quelques design patterns utilisé globalement dans la majorité des frameworks.

De plus, qui nous dit que dans 2 ans, ce sera encore symfony ou zend qui sera le framework le plus usité ?

Y a des sites à forte charges qui l’utilisent ?

Il n’y qu’à regarder le hall of fame de Jelix pour se rendre compte que Jelix est de plus en plus utilisé et pas seulement sur des petits sites.

Over-blog est une plate-forme de blog à fort traffic (plusieurs millions de pages lues par jour) qui utilise Jelix depuis sa version alpha parce qu’il convenait réellement à leurs besoins.

Il y aussi Kayuto qui a fait le choix de Jelix pour ses fonctionnalités et sa performance.

Est-il pérenne ?

Tout dépend ce qu’on entend par pérennité. Jelix a l’avantage d’être open-source, ce qui fait qu’on peut y contribuer, et pourquoi pas si on est désaccord avec la tournure du projet faire un fork.
La communauté autour de Jelix s’agrandit et pas seulement des développeurs individuels mais aussi des entreprises qui contribuent au code de Jelix, ce qui contribue à sa pérennité.

Voyons maintenant la pérennité sous l’angle des versions.
Un framework qui évolue en version N+1, N+2, N+3 aura des changements d’API certaines (il n’y a qu’à voir les changements occasionnés par le passage de symfony 1.0 à la version 1.1). Un projet que vous réaliser il y a deux ans avec la version N si vous souhaiter le migrer à la version N+1 aura besoin d’être adapter, migrer.
A cette effet, on peut dire que la pérennité d’une version N sur l’API n’existe pas vraiment, vu qu’elle évolue au fil des versions.

Si jamais le framework venait à ne plus évoluer ou qu’il n’est pas décidé de ne pas migrer sur la version n+1 du framework, il faut savoir que :

• la documentations sera toujours disponible
• le site aussi
• au pire il est possible de faire une copie intégrale de la documentation de la version N

Qui peut dire demain que Zend Framework ou synfony seront toujours à la mode ? Il peut malheureusement avoir un nouveau framework qui sort dans les mois à venir et vers lesquelles tous les développeurs vont se tourner et ainsi réduire les communautés des différentes framework. Cela s’est malheureusement déjà vu sur des projets open-source.

Enfin, il est également possible que les équipes dirigeantes d’un framework peuvent complètement changer et par conséquent la philosophie du projet et ses objectifs.

Pour ces différentes raisons, la question de la pérennité est une mauvaise question. Un framework est un framework. La version que vous aurez choisi marchera toujours à l’identique dans un an, dans 10 ans, dans 20 ans.
A ce niveau, les différentes versions de Jelix seront maintenues le plus longtemps possible avec les corrections de bugs, de sécurité qui vont bien et à mon sens, les changements d’API bien que présent sont moins sensibles que ce que j’ai pu constaté sur d’autres frameworks.

Les vraies bonnes questions à se poser

• Est-ce qu’à court terme et à moyen terme, Jelix va répondre aux besoins ?
• Est-ce que Jelix va plaire aux développeurs qui l’utiliseront ?

Pour se forger une idée, vous pouvez consulter ma présentation de jelix ou bien aller sur le site officiel.

J’ai rédigé ce billet en espérant qu’il vous donnera envie de passer sous Jelix. J’ai repris pas mal de la substance des échanges que j’ai eu avec Laurent sur Jelix et sur le channel IRC, j’espère qu’il m’en voudra pas de les avoir reprise ici.

Jelix est un framework initié par un français Laurent Jouanneau qui a l’origine si je ne dis pas de bêtise avait bossé sur Copix.

Cette article va présenter plus en détails les différents API de Jelix et permettre par la suite d’aborder plus sereinement un petit tutoriel.

Fonctionnement

Jelix est, comme la grande majorité des framework, basé sur le design pattern MVC afin d’avoir une séparation logique du code de notre site.
Le modèle est une classe donné qui va interagir avec la base de données (récupération de données, etc…). La vue est ce que l’utilisateur va obtenir au final (un flux RSS, une page HTML, un fichier XUL) avec les données qu’on obtenu préalablement avec le modèle. La vue est dans Jelix assuré par des templates dont la syntaxe est proche de Smarty.
Quand au contrôleur, il est le chef d’orchestre, il va se charger de mettre les données en relation avec la vue pour générer au final une sortie vers l’utilisateur.
Jelix intègre une sécurité supplémentaire qui permet de “typer” la vue et d’être sûr du format de sortie.
En effet, Jelix permet via des objets Responses de générer à partir d’un même modèle un flux RSS, une page HTML, des données JSON, etc…

Mécanisme des Urls

Jelix utilise un point d’entrée pour appeler les différents modules et les actions associés. Pour ce faire, Jelix se sert de la syntaxe suivante :

Ces urls peuvent être réécrite soit à l’aide de mod_rewrite soit à l’aide de Jelix (voir ci-dessous).

Structure du projet

Sur la figure ci-dessus, on peut voir trois dossiers racines :

• lib : C’est l’ensemble des librairies de Jelix
• temp : c’est le dossier de cache de votre application
• jactu : C’est le dossier de votre application (que vous pouvez appeler comme vous voulez) qui est scindé en plusieurs sous-dossiers : 
• les modules (répertoire demo par exemple), permet de séparer les différentes fonctionnalités de votre site (par exemple, un module forum, recherche, profil). Ce découpage facilite la réutilisation de code. Chaque module comporte les dossiers suivants :
• les classes (dossier classes) : contient les classes métiers et autres objets. Les fichiers doivent suivre la nomenclature suivante monfichier.class.php
• les contrôleurs (dossier controllers)
• les daos (dossier daos)
• les formulaires (dossier forms)
• les locales (dossier locales)
• les templates (dossier templates)
• les zones (dossier zones)
• les plugins (répertoire plugins) :
• la configuration (répertoire var) : la configuration est simple à éditer, ce sont des fichiers ini qui vont permettre de personnaliser les différentes options du framework (la langue par défaut, les paramètres d’accès à la base de données). Ce répertoire contient également les fichiers de log que vous pouvez créer ou utiliser le fichier par défaut.
• le point d’entrée (répertoire www) : c’est ici que les visiteurs atterrissent, ils n’ont pas accès aux autres ressources directement.

Les API

Jelix propose des API qui peuvent vous aider à résoudre les problèmes que vous pouvez rencontrer dans vos développements quotidiens.
Certains de ses API sont facultatives et libre à vous de les utiliser ou non. Néanmoins, ce serait passer à côté de la puissance de Jelix.

Le cache

Au coeur de Jelix, il existe différents types de fichiers : XML, ini ou même des templates. Sans système de cache, à chaque requête utilisateur le framework serait obligé de lire les fichiers de configuration, de générer les templates, etc…
Fort heureusement, Jelix intègre un mécanisme de cache intelligent. Ainsi, les fichiers XML, ini, templates et autres sont traduits en code PHP pour la plupart et ensuite mis en cache pour éviter le processus décrit précédemment.
Si vous modifier un de ces fichiers, son cache va être régénérer à la prochaine requête utilisateur.

Abstraction des chemins d’accès

Il est souvent assez pénible de spécifier qu’on veut accéder à tel classe situé dans deux dossiers supérieurs à la classe qu’on est train de créer. Sous Jelix, les chemins sont représentés de la manière suivante module~nomdelaressource.

Url Rewriting

Pas forcément simple de devoir réécrire toutes les urls de vos différents modules et actions à l’aide de mod_rewrite ! C’est pour cela que Jelix permet à l’aide d’un simple fichier XML de mapper des urls sur vos modules et vos actions et aussi de typer les paramètres.

jDAO

C’est sûrement l’une des API les plus intéressantes de Jelix. jDao permet de représenter via un fichier XML (rédiger manuellement ou générer automatiquement à partir de votre base de données) vos différentes tables. Chaque table est représenter par un fichier XML mais il est possible également de combiner plusieurs tables ayant des relations dans un même fichier.
Au coeur de ses fichiers, il est aisé de rajouter des méthodes soit à l’aide de la syntaxe XML soit à l’aide de PHP.
L’immense avantage de cette API est qu’il est profite du cache géré par Jelix. Le gain de productivité n’est donc pas mise à mal par une éventuelle perte de performances.
Cette article parle de jDao face à d’autres ORM comme Doctrine.

jForms

C’est la partie formulaire de Jelix. Qui n’as jamais pesté contre la réalisation d’un formulaire avec validation client et serveur ?
jForms répond à cette problématique de la façon la plus simple qui soit. On décrit notre formulaire à l’aide d’un fichier xml et c’est terminé (il est possible également de le générer à partir d’un fichier dao). On aura les différents validateurs (client et serveur) qui seront mise en place en quelques lignes de code.
La prochaine version de jForms proposera un composant WYSIWYG pour la saisie de texte avancé ainsi qu’un captcha automatisé. Dans un avenir proche, jForms permettra de générer à partir du même fichier XML différents types de formulaires (Ajax, XUL, XForms).

Générateur de CRUD

Quoi de plus rébarbatif que la réalisation d’une page d’administration ? Pourquoi ne pas bénéficier des autres API ? Grâce à la combinaison des jForms et des jDao, il est possible d’obtenir une page d’administration avec toutes les actions possible (Création, Lecture, Mise à jour et Suppression) en seulement quelques lignes de code.

Les test unitaires

Les tests unitaires sont de plus en plus usités et c’est à ce titre que SimpleTest a été intégré à Jelix. Chaque module se voit greffer un dossier tests dans lequel on écrit des classes spécifiques qui vont permettre de vérifier que nos différentes classes marchent correctement.
Il suffit ensuite de les lancer soit en ligne de commande soit via une interface web dédié à cette effet. Il est possible bien sûr de lancer les tests individuellement, par module ou tous les tests.

Internationalisation

Quoi de plus problématique que la gestion de plusieurs langues au sein d’un même site internet ? Il faut déjà détecter la langue de l’utilisateur, passer par plusieurs librairies, fournir un fichier de langues à un traducteur, le retranscrire en fichier adéquate (gettext ou autre), s’assurer que ça marche bien sur le serveur de production… C’est n’est pas la panacée.
Pour résoudre ces différents problématiques, Jelix utilise des simples fichiers textes de clé valeurs comme par exemple :

Il est aisé de fournir ce fichier à un traducteur sans avoir à ensuite le retranscrire en fichiers gettext ou autre. Enfin, la détection de la langue du visiteur qui permet de changer la langue dynamiquement en fonction des paramètres du navigateur du visiteur. Cela permet d’avoir dés son arrivé sur votre site, une page dans la langue du visiteur.
Pratique non ?

Template

Le moteur de template est assuré par jTpl qui existe en version stand-alone.
jTpl a une syntaxe très proche de celle utilisé par Smarty, ce qui peut être un inconvénient pour certains développeurs mais la syntaxe est vraiment proche de celle de PHP en plus légère et permet de ne pas surcharger ses templates d’instruction PHP par forcément utile.
Il existe aussi des zones qui sont des portions de template qu’on veut pouvoir inclure au besoin sur les pages de notre choix et gérer de manière autonome du reste d’un template principal.

Les templates (zones y compris) bénéficient également du système de cache de Jelix.

Abstraction de la base de données

jDb est une API qui repose sur PDO et sur les librairies natives d’accès aux différentes bases de données (MySQL par exemple). Son avantage est de rendre l’usage de ses différentes librairies transparentes et d’uniformiser leurs utilisations.
Quelque soit la librairie choisi, vous utiliserez les mêmes fonctions et obtiendrez les mêmes ResultSet.

Connexion et gestion des droits utilisateur

Jelix fournit une API pour l’authentification utilisateur qui s’appelle jAuth. Elle est assez simple à mettre en place et se présente sous la forme d’un plug-in qu’il suffit de configurer en quelques lignes. Cela permet d’avoir simplement une gestion des sessions utilisateurs assez poussés sans effort. Au niveau du contrôleur, une ligne suffit pour indiquer que l’accés à tel ou tel action (ou l’ensemble des actions) sont réservés aux utilisateurs connectés.
Pour ce qui est de la gestion des droits utilisateurs, une autre API jAcl permet de gérer les accès utilisateurs à vos différents modules et actions. Il est possible ainsi de définir des groupes d’utilisateurs et leurs droits associés.
Cette API est un peu plus compliqué à mettre en place mais va être bientôt remplacé par sa version 2 avec un script de migration si je me trompe pas.

En conclusion

Il n’est évidemment pas possible de passer en revue toutes les fonctionnalités de Jelix, j’ai présenté assez succinctement les parties les plus intéressantes de ce framework qui mérite d’être encore plus connu.
Je vous invite à l’utiliser et pourquoi pas à contribuer si vous vous senter l’âme d’un contributeur.
Si vous désirez en savoir plus, je vous invite à venir sur le site officiel, à parcourir les forums ou à participer sur le channel irc dédié à cette effet.

- MAMP
- XAAMP
- Utilisation des packages pré-compilés
- Compilation soi-même

Même si Leopard est fourni désormais avec php 5, certaines librairies sont manquantes et il peut être utile de se faire sa propre installation de zéro.

MAMP

MAMP est la solution tout en un qui ne nécessite aucune connaissance particulière. Un simple glisser-déposer dans le dossier Application et vous avez vos serveurs qui sont prêt à démarrer.
Aucune configuration particulière.
L’avantage est qu’en quelques clicks on a une installation complète d’une solution basé sur Mac MySQL et PHP. Néanmoins, dés lors qu’on souhaite pousser la solution et par exemple installer une librairie via Pear, on constate que cela ne marche pas vraiment et on se retrouve coincé :/.
MAMP est donc à recommandé pour les personnes qui n’ont pas de besoins spécifiques et qui peuvent se contenter des librairies fournies.

XAMPP

XAMPP est une solution que j’ai découverte récemment grâce à un commentaire sur mon blog. Il fonctionne un peu comme MAMP sauf qu’il fournit également Perl. C’est encore une version en cours de développement qui est proposé, donc certaines fonctionnalité ne marche pas totalement.
J’ai notamment eu quelques soucis à faire marcher pear avec certaines librairies ou framework.
A garder de côté pour le moment. Je pense qu’il aura plus de succès que MAMP d’ici les mois qui viennent.

Utiliser les packages pré-compilés

A défaut de pouvoir utiliser les différentes solutions toute faites, il faut mettre un peu la main dans la cambouis. Par chance, Marc Liyanage maintient depuis quelques temps des versions compilés de php pour Tiger et Leopard.
Même si la version Leopard porte la mention bêta, elle fonctionne parfaitement et ne nécessite que quelques lignes de commandes pour pouvoir fonctionner pleinement.
Nous n’avons besoin que de php car Apple fournit par défaut avec MacOS X un serveur Apache parfaitement fonctionnel. Nous allons donc garder cette version d’apache qui va nous faciliter la vie.

Avant toute chose il faut télécharger la version qui correspond à votre version de MacOS (voir ci-dessus). Double-cliquer sur le fichier en question pour obtenir un dossier php5.
Il faut maintenant ouvrir le Terminal (que l’on peut trouver dans /Applications/Utilitaires/) pour y taper les lignes suivantes :

On a maintenant une installation de php fonctionnelle qui est installé, il ne reste plus qu’à configurer l’ensemble.

Il faut à présent avec l’éditeur de votre choix modifier le fichier /etc/apache2/httpd.conf pour qu’il utilise la nouvelle version de php fraîchement installé.
Il faut remplacé la ligne suivante

par

Afin de pouvoir utiliser nos commandes php à n’importe quoi sans les préfixer de /usr/local/php5/bin, il faut modifier la variable PATH de notre environnement. Pour cela, à l’aide du terminal, tapez :

Dans ce fichier, il faut rajouter les lignes suivantes :

Sauvegarder le fichier. Pour que les modifications soit effectives, il faut fermer votre fenêtre du terminal et en ouvrir une nouvelle. Il vous suffit de taper la commande php –version afin de vérifier que c’est la bonne version. Pour cela, il faut vérifier le numéro de version, la 5.2.5 et la date de compilation built: Feb 20 2008 12:30:47.
Vous obtiendrez une sortie comme celle-ci :

Il ne reste plus qu’à redémarrer apache en tapant toujours dans le terminal

Pour les allergiques à la ligne de commande, il est possible de passer directement par les préférences systèmes

Il suffit de cocher, décocher l’option partage web pour redémarrer Apache.

Pour accéder à vos sites, ils doivent être stockés dans le dossier Sites de votre répertoire personnel.

Installation de MySQL

L’installation de MySQL se trouve ici. Elle est simple à utiliser, il suffit de faire suivant, suivant en lisant néanmoins bien les éventuelles indications.

Une fois, l’installation terminé, je vous invite à installer le fichier dont l’extension est prefpane, cela va rajouter un panneau dans les préférences systèmes pour démarrer ou stopper le serveur MySQL.

Une dernière étape est requise pour autoriser votre utilisateur à lancer MySQL. Avec le finder, il faut se rendre dans la dossier /usr/local/mysql/. Etant donné que certains dossiers sont masqués par le finder, il faudra utiliser le menu “Aller” et “Aller au dossier” (avec le clavier POMME+SHIFT+G).
Une fois dans ce dossier, POMME+I sur le dossier data. Les informations de Partage et permissions vont être modifié. Il suffit de cliquer sur le + pour rajouter votre utilisateur.
Il faut que ces modifications s’appliquent au dossier et à ses sous-dossiers. Il faut pour cela cliquer sur l’icône à côté du - et sélectionner Appliquer aux éléments inclus.

Enfin, pour pouvoir accéder aux programmes de mysql (le client, mysqladmin, etc…), il faut modifier le .bash_profile comme nous l’avons fait pour php.

Attention, toutefois votre serveur MySQL dispose d’un compte root sans mot de passe avec tous les accès. Il ne faudra pas oublier de modifier ces paramètres.

Compilation soi-même

MacOS X étant un Unix, il est possible de compiler certains logiciels grâce à des gestionnaires de paquet comme FinkPorts ou DarwinPorts.
Néanmoins, l’opération est relativement longue selon le processeur de votre machine et assez compliqué à mettre en oeuvre pour un débutant.
Elle a le mérite d’exister.
Pour pouvoir utiliser ces outils, il vous faut les outils développeurs fourni sur votre dvd d’installation de MacOS X.

A quand une version de WAMPServer pour Mac ?

Références et diverses sources : Olivier Mansour

Aujourd’hui deux mini-outils à l’honneur : Open In Terminal Here et Open in Textmate qui s’ajoutent dans la barre du finder et qui vous permet d’ouvrir un terminal dans le répertoire actuel et d’ouvrir les fichiers sélectionnés (dossier, groupe de fichiers) dans Textmate directement.

Il suffit de copier les applications dans le dossier Applications et de les glisser-déposer sur la barre du finder.

Que se passe-t-il si on a envie d’afficher son statut si un site qui ne permet pas d’afficher son statut mais qui permet de modifier sa description ou sa signature ?
Même si la plupart des sites communautaire permet d’afficher son dernier twit, c’est un bon cas pratique pour découvrir cURL et son utilisation avec php.

Nous allons voir dans cette article comment faire avec PHP et cURL pour pouvoir le faire de maniére automatisé.

Pré-requis

Il faut avoir PHP compilé avec le support cURL sinon impossible de faire ses manipulations.

cURL, c’est une technique de curling ?

cURL est un utilitaire qui existe en ligne de commande et qui permet à l’instar de wget d’aller récupérer des pages, images, etc.. sur Internet.
Il sait gérer les formulaires, les cookies, etc…
cURL se comporte comme un navigateur web sans interface graphique.

PHP supporte cURL et permet son utilisation de maniére totalement transparente et simplifié.

Dans le cadre de notre projet, nous avons besoin de :
- pouvoir nous identifier auprès du site
- pouvoir poster un formulaire de données
- pouvoir récupérer le contenu d’une page donnée

Créeons notre objet

Avant de commencer à jouer avec cURL, il faut d’abord prendre en compte un paramétre important.
PHP s’execute avec un temps d’attente maximum de 30 secondes. Nous allons surcharger ce paramétre afin d’éviter que notre script s’arrête en plein milieu d’un envoi d’information.

En effet, selon le temps de réponse du site, il peut arriver que cela prenne rapidement plus de 30 secondes.
Pour cela, nous allons utiliser la ligne de code suivante afin d’éviter de rencontrer ce problème :

/* suppression du temps limite */
set_time_limit(0);

cURL s’utilise de la manière suivante :
- on initialise la librairie et on récupéré une instance
- on définit les options
- on exécute l’action (récupération de page, envoie de données, etc…)
- on récupère le retour (contenu ou code http)
- on libère l’instance

Pour initialiser l’instance, rien de bien compliqué :

$monInstance = curl_init();

Voyons maintenant quelles options peuvent nous interresser. Si on fait un petit détour par le manuel de php, on constate qu’il y a des lignes et des lignes d’options pas souvent facile à comprendre.

J’en ai sélectionné quelques unes qui sont indispensables pour les actions que nous allons effectué.

Pour définir une option, il suffit d’utiliser curl_setopt comme ci-dessous :

curl_setopt($monInstance, NOMDELOPTION, VALEUR);

Une fois l’instance configuré comme nous le souhaitons, il ne reste plus qu’à lancer notre action (envoi de formulaire, récupération de contenu, etc…)

$contenu = curl_exec($monInstance);

La variable contenu va contenir le code HTML de la page ou le contenu binaire du fichier que vous avez souhaité récupérer.

Pour obtenir plus d’informations sur comment la requête HTTP s’est passé, il est possible de récupérer un tableau contenant ces paramètres.

$info = curl_getinfo($monInstance);

Enfin, si on ne souhaite plus utiliser notre instance, il faut la libérer avec curl_close. Si vous souhaitez récupérer une autre page, etc… il est possible d’utiliser la même instance en changeant l’option CURLOPT_POST et éventuellement celle qui vous sont nécessaire.

curl_close($monInstance);

Voici un exemple par exemple pour se logguer sur le site City974

$monInstance = curl_init();
curl_setopt($monInstance, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($monInstance, CURLOPT_HEADER, false);
curl_setopt($monInstance, CURLOPT_USERAGENT, 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X; fr; rv:1.8.1.9) Gecko/20071025 Firefox/2.0.0.9');
curl_setopt($monInstance, CURLOPT_TIMEOUT, 60);
curl_setopt($monInstance, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($monInstance, CURLOPT_MAXREDIRS, 10);
curl_setopt($monInstance, CURLOPT_COOKIESESSION, true);
curl_setopt($monInstance, CURLOPT_COOKIEJAR, './cookie.txt');
curl_setopt($monInstance, CURLOPT_URL, 'http://www.city974.com/ident/identification.php');
curl_setopt($monInstance, CURLOPT_POST, 1);
//remplacer les paramètres par vos informations
curl_setopt($monInstance, CURLOPT_POSTFIELDS, 'pseudo=ahahahaha&mdp=ouioui&retenir=1&Submit=Ok');
$contenu = curl_exec($monInstance);
$info = curl_getinfo($monInstance);
//affiche le contenu pour voir qu'on est loggué
echo $contenu;
curl_close($monInstance);

Récupérer son dernier Twitt

Twitter comme tout bon site web 2.0 propose une API assez simple à utiliser.
Il suffit d’utiliser un cURL avec l’url adéquate pour récupérer ce qui nous intéresse.

L’url pour récupérer nos tweets sont de la forme http://www.twitter.com/statuses/user_timeline/username.format?count=10 où username est votre nom d’utilisateur et format le format dans lesquels vous souhaitez récupérer ces informations (xml et json principalement).

Voici comment faire avec cURL pour récupérer ce flux.

$monInstance = curl_init();
curl_setopt($monInstance, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($monInstance, CURLOPT_HEADER, false);
curl_setopt($monInstance, CURLOPT_TIMEOUT, 60);
curl_setopt($monInstance, CURLOPT_MAXREDIRS, 10);
curl_setopt($monInstance, CURLOPT_URL, 'http://www.twitter.com/statuses/user_timeline/despekiroule.xml?count=10');
$contenu = curl_exec($monInstance);
$info = curl_getinfo($monInstance);
$xml = $curl->getContent('');
$twitts = new SimpleXMLElement($contenu);
$lastTwitt = $twitts->status[0]->text;

Conclusion

Nous avons vu de manière succincte comment utiliser cURL pour récupérer et poster des informations dans le cadre précis de pouvoir poster son statut Twitter un peu n’importe où.
Un exemple plus complet est disponible ici.

Avant-propos

Gentoo est une distribution qu’on appelle source car elle compile chaque application et permet d’obtenir un gain sensible de performances et permet surtout de gérer plus finement les dépendances.
Il est possible d’opter pour d’autres distributions plus user-friendly lors de l’achat de votre serveur.
A vous d’opter pour celle qui vous correspond le mieux.
Les USE FLAGS qui vous seront présenté plus loin, sont en fait des options que tel ou tel paquet supporte et qu’on peut activer ou désactiver à notre convenance.

Pré-requis

Pouvoir se connecter en ssh et avoir quelques connaissances en ligne de commande Linux.

Premier pas avec le serveur

Avant de commencer, on va mettre à jour son gestionnaire de paquets. Sous gentoo, il s’appelle emerge.

Il suffit de taper la commande suivante pour mettre à jour les paquets.

Dans un second temps, il faut vérifier le fichier /etc/hosts qui est souvent erroné.

En effet, pour une raison étrange, chaque nom de domaine se voit précédé d’un 2-nomduserveur.ovh.net.
Il suffit de l’enlever pour éviter d’éventuels problèmes.

Choix des options

Avant de lancer la compilation et l’installation de nos serveurs, il faut spécifier les différentes options que l’on souhaite activer pour chaque serveur.
Par exemple, les différentes librairies qu’on souhaite activer pour PHP.

Pour lister les options possibles d’un paquet il suffit de taper :

Ces options sont à renseigner dans le fichier /etc/portage/package.use sous la forme :

Evidemment, certains options peuvent paraître obscures et c’est pour ça que Gentoo Portage est là !
Pour l’utiliser, rien de plus simple, il suffit de taper le nom du logiciel que vous souhaitez installer, de choisir celui qui correspond.
Vous obtiendrez alors une liste de versions du paquet et tout en bas plusieurs onglets. Il suffit de regarder l’onglet “USE FLAGS” qui présente toutes les options.

Apache [USE FLAGS]

Apache utilise deux fichiers pour spécifier ses différentes options.
Dans package.use, on va spécifier les options générales tandis que les make.conf on va définir les modules à compiler (APACHE2_MODULES) et le type de fonctionnement d’apache (APACHE2_MPMS).

Voici pour exemple ma configuration.

/etc/portage/package.use

/etc/make.conf

PHP [USE FLAGS]

Voici un exemple de configuration :

MySQL [USE FLAGS]

Voici un exemple de configuration possible :

Installation des serveurs

Il suffit de taper la commande suivante

Une fois la compilation terminé et qu’il n’y a pas d’erreurs pendant la compilation, il ne reste plus qu’à enregistrer les serveurs dans la séquence de démarrage.

Maintenant, même en cas de redémarrage du serveur, Apache et MySQL démarreront sans intervention de votre part.

Configuration des serveurs

Apache

Selon les modules que vous avez choisi, le fichier /etc/conf.d/apache2 peut différer.
Il faut s’assurer néanmoins que sur la ligne APACHE2_OPTS la valeur -D PHP5 soit présente pour que le module php soit chargé.

MySQL

En remplaçant bien sur, 5.0.19 par la version que vous avez installé.
Derniére étape pour sécuriser le serveur,

Il suffit juste de répondre aux questions que le programme vous pose pour fermer quelques petits trous qui sont ouverts par défaut.

Voilà vous avez un serveur fin prêt à accueillir vos sites. J’ai passé sous silence d’autres aspects de la configuration qui sont spécifiques (les Virtual Hosts, optimiser MySQL) vu qu’il s’agissait ici des premiers pas avec son serveur.

Symfony est un framework PHP orienté objet développé par Fabien Potencier.
Il reprend des designs patterns comme MVC notamment pour la séparation des couches.

Ce petit déjeuner aura lieu le jeudi 10 Avril au Centre Etoile Saint Honore (Paris 8ème) à partir de 8h45.

Prochain rendez-vous le mercredi 23 avril.

Pour s’inscrire c’est par ici.

- Apéro PHP le 22 avril à la Panfoulia à partir de 20h00, 20h30. [s'inscrire]

- Industrialiser les développements PHP, le cas eTF1, le 29 avril de 20h00 à 21h30 à la FIAP. [s'inscrire]

- PHP et Silverlight animé par Christophe Lauer et Pierre Lagarde, le 14 mai à la Cantine (Paris) à partir de 19h00. [s'inscrire]

Ca me fait penser qu’il faudrait que j’adhère à l’AFUP.