L’un des problèmes communs quand on développe une application, ou quand on intégre différents composants, est le logging. On veut avoir des niveaux de logging différents. On veut aussi pouvoir loguer sur le système de fichiers,  envoyer des emails pour les problèmes plus urgents etc. Pour développer un systeme pareil from scratch, j’imagine que la tache ne sera pas aussi simple.

En effet, il existe Deja un framework Complet pour la gestion de cette tache, le projet Apache Log4php! Log4php est écrit PHP . Les habitués de Java et .Net reconnaîtront tout de suite le modèle, Log4php est en fait un portage de Log4j et Log4Net déjà existants dans ces deux langages. Éventuellement, le framework présente les memes notions et fonctionnalités.
Regardons ce que Log4php sait faire et comment l’utiliser :

Fonctionnalités

• Configuration via des fichiers XML ou ini avec la même structure que Log4j
• Gestion de loggers hiérarchiques
• Support de logging sur : fichier, fichier journalier, console, mail, pdo, erreurs php, logs système ou évènements NT (windows), sockets.
• Rotation de logs
• Layouts standard : Simple, TTCC, Pattern, HTML et XML
• gestion d’erreurs hiérarchiques : log, warn, error, fatal etc.

Installation

• Telecharger Log4php et decompressez le.
• Copier le repertoire  src/main/php dans votre application
• include/require la classe Logger (log4php/Logger.php) dans vos scripts

Comment ca marche?

Loggers, Appenders and Layouts

Log4php possède trois composants principaux: les loggers,  les appenders et les layouts.

• Les loggers s’occupent de loguer les messages selon le type de message et le niveau de loging.
• Les appenders quant a eux, déterminent ou le logging se fait (fichier, mail, bd etc.).
• Enfin, les Layouts permettent de formater les messages rapportés.

Exemples

Exemple de base

Voici un exemple de base d’un logger qui affiche les résultats en console et expose les méthodes pouvant etre appelées sur un logger :

1
2
3
4
5
6

   require_once('log4php/Logger.php');
  $logger = Logger::getLogger("main");
  $logger->info("foo");
  $logger->warn("bar");
  $logger->error("urgent");
  $logger->fatal("Fatal!");

Ce code affiche

1
2
3
4

Wed Nov 24 20:40:10 2010 [10093] INFO main - foo
Wed Nov 24 20:40:10 2010 [10093] WARN main - bar
Wed Nov 24 20:40:10 2010 [10093] ERROR main - urgent
Wed Nov 24 20:40:10 2010 [10093] FATAL main - Fatal!

Utiliser un fichier de configuration

1
2
3
4
5

log4php.appender.default = LoggerAppenderEcho
    log4php.appender.default.layout = LoggerLayoutSimple
    log4php.rootLogger = WARN, default
    log4php.logger.mylogger = INFO, default
    log4php.additivity.mylogger = "false"

Il est possible de définir une configuration dans un fichier ini. La configuration qui suit spécifie que l’appender par défaut utilisera la console (LoggerAppenderEcho) et un template (LoggerLayoutSimple). Le logger par défaut (rootLogger) loguera les messages a partir du niveau WARNING (et donc pas les message INFO). Un autre logger « myLogger » s’occupera de loguer les messages INFO. L’information additivity.mylogger = false indique que le niveau de propagation de l’erreur ne va pas en dessous du logger mylogger (Par defaut, le message se propage aux parents du logger).
Sauvegardez ces lignes en un fichier ini – disons config.ini – et appelez le depuis votre code. Voici un exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  require_once('log4php/Logger.php');
  Logger::configure('config.ini');
 
  class MyClass {
     private $logger;
 
     public function __construct() {
         $this->logger = Logger::getLogger(__CLASS__);
         $this->logger->debug('Dans le constructeur!');
     }
  } 
 
  $logger = Logger::getLogger('main');
  $logger->info('Warning externe');
 
  new MyClass();

Ceci affiche :

1

  DEBUG - Dans le constructeur!

Vous remarquerez que l’appel d’un logger non déclaré (‘main’ dans l’exemple) appellera le rootLogger. Aussi, vous remarquerez l’instanciation du logger en se servant de __CLASS__. De cette façon vous pouvez avoir un logger différent pour chacune de vos classes.

Héritage et niveaux de logs

Héritage de logs

Il est possible de faire heriter des loggers en utilisant des points comme separateurs dans les noms de logs (foo, foo.bar, foo.bar.x etc.). Le logger root est le parent de la hiérarchie, il est toujours présent et ne peut pas etre appelé par nom. pour l’appeler, utilisez plutot la méthode statique getRootLogger.

Niveaux de logs

Log4php permet de gérer cinq niveaux de base de logging : DEBUG, INFO, WARN, ERROR et FATAL. Log4php assume que ces niveaux sont ordonnés de cette facon :
DEBUG < INFO < WARN < ERROR < FATAL.
Prenons un exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

   // Recurperer une instance appelee "com.foo"
   $logger = Logger::getLogger("com.foo");
 
   // setLevel permet de setter le niveau de logging, Normalement
   // Vous n'avez pas a indiquer ceci programaticallement, vous
   // le faites plutot dans un fichier de configuration
   $logger->setLevel(LoggerLevel::INFO);
 
   // com.foo.Bar herite de com.foo
   $barlogger = Logger::getLogger("com.foo.Bar");
 
   // on peut executer la methode warn puisque  WARN >= INFO.
   $logger->warn("Warning message");
 
   // On ne peux pas executer cette methode puisque DEBUG < INFO.    $logger->debug("Debug message");
 
   // $barlogger (com.foo.Bar) va heriter son niveau de $logger (com.foo)
   // donc, la methode info pourra etre appelee puisque INFO >= INFO
   $barlogger->info("Informations");
 
   // De meme pour barlogger, cette methode ne peux pas etre appelee puisque DEBUG < INFO.    $barlogger->debug("Exiting gas station search");

Conclusion

Le présent tutoriel a été fortement inspiré par la documentation officielle. Vous trouverez des explications et des exemples plus complets sur les différentes notions sur le site officiel.
Log4php est un framework complet et qui suit les standards de logging. Aussi, il est supporté par Apache, ce qui vous donne une confiance d’utilisation. J’ai commencé a l’intégrer pour la prochaine version de Simple MVC et je peux vous dire que c’est du pur plaisir! A utiliser sans hésitation!

Liens

Téléchargement : http://logging.apache.org/log4php/download.html
Documentation : http://logging.apache.org/log4php/docs/introduction.html

Tympanus.net présente un tutoriel assez cool qui montre comment développer en jQuery un  Previsualiseur de nouvelles qui vous permet d’afficher dans un mode compact une série d’articles. Les articles sont affichés en liste avec pagination. Le clic sur un item affiche la description et un lien vers le détail complet de l’article. Le skin est personnalisable via CSS.

• Le tutoriel : http://tympanus.net/codrops/2010/10/03/compact-news-previewer/
• La demonstration : http://tympanus.net/Tutorials/CompactNewsPreviewer/
• Telechargement : http://tympanus.net/Tutorials/CompactNewsPreviewer/CompactNewsPreviewer.zip

Qu’est ce que Git

Il est absurde de développer sans utiliser un système de contrôle de révision; ce genre de système vous donne la liberté de faire ce que vous voulez avec votre code sans souci puisqu’il vous permet toujours de restaurer une version précédente.
Git s’inscrit dans ce cadre. C’est gestionnaire de versionning de code et un outil de developpement collaboratif Open source, il a été crée par Linus Torvalds lorsqu’il développait le noyau de Linux.
L’un des points importants que rajoute Git par rapport a d’autres système de gestion de versions ( comme SVN, CVS etc.) est qu’il vous permet d’avoir un environnement de « staging », c’est un . Je ferais une comparaison avec SVN pour éclaircir un peu le concept : Sous SVN, une fois vous effectuez vos changements et que vous voulez les soumettre, vous commitez. Ce code sera poussé dans le repository.
Avec Git, vous pouvez commiter votre code en local, retourner a des versions antérieures etc, toujours en local. Par la suite, vous pourrez commiter votre code sur le serveur. Vous pouvez voir cela comme un environnement de versionning local, mais qui est relie aussi a un environnement Maître.
Le lien : http://whygitisbetterthanx.com Explique via des graphiques Les différences de Git avec les autres systèmes de versionning.

Installation

Pour installer Git sous Ubuntu, tapez simplement :

1

sudo apt-get install git-core

Configuration

Avant de commencer d’utiliser Git, vous pouvez personnaliser votre identité en spécifiant votre nom et votre mail comme suit :

1
2

git config --global user.name "Votr nom"
git config --global user.email "votre@email.com"

Vous pouvez ajouter également des couleurs pour une meilleure lecture sur le terminal :

1
2
3

git config --global color.diff auto
git config --global color.status auto
git config --global color.branch auto

git init

1
2
3
4

$ mkdir gitTest
$ cd gitTest
$ git init
Initialized empty Git repository in /home/user/gitTest/.git/

La commande git init va initialiser votre répertoire. git init crée une branche Maître (branche principale). Vous pouvez par la suite créer différentes branches si le besoin se présente.

Pour ajouter des fichiers vous utiliserez la commande git add

1
2
3

git add . // ajouter le repertoire courant
git add *.php // ajouter tous les fichiers php dans le repertoire courant
git add index.php // ajouter le fichier index.php

tapez par la commande git commit.

1

~/gitTest$ git commit -m "Initial commit"

Le paramètre -m sert a définir votre message de commit. en omettant ce paramètre, un éditeur est ouvert afin de vous permettre de saisir votre message. A la sauvegarde de vos changements, le/les fichiers seront commites et vous aurez un message similaire :

1
2
3

Created initial commit b2c73d2: First commit
 1 files changed, 2 insertions(+), 0 deletions(-)
 create mode 100644 index.php

Par défaut, l’éditeur utilise est nano. Pour changer votre éditeur a vi par exemple, vous pouvez taper :

1

export SVN_EDITOR=vi

Le commit qu’on vient de faire commite nos fichiers en local. Pour voir l’état de notre projet, tapez git status

1
2
3
4
5
6
7
8

~/gitTest$ git status
# On branch master
# Changed but not updated:
#   (use "git add ..." to update what will be committed)
#
#	modified:   index.php
#
no changes added to commit (use "git add" and/or "git commit -a")

Comme vous le lisez sur le code ci-dessous, git vous suggère d’utiliser l’option -a de git commit pour pousser les changements dans la repository.

1
2
3
4
5
6

~/gitTest$ git commit -a
Created commit bc061fc: First revision
 1 files changed, 1 insertions(+), 1 deletions(-)
~/gitTest$ git status
# On branch master
nothing to commit (working directory clean)

git status

Comme on a vu, la commande git status permet d’afficher l’etat des fichiers dans votre repertoire de travail.
Nous allons créer un autre fichier index2.php, écrire une ligne ou deux et le sauvegarder. Nous allons aussi faire un changement dans le fichier index.php déjà ajoute et commite. Par la suite on tape un git status.

1
2
3
4
5
6
7
8
9
10
11
12

~/gitTest$ git status
# On branch master
# Changed but not updated:
#   (use "git add ..." to update what will be committed)
#
#	modified:   index.php
#
# Untracked files:
#   (use "git add ..." to include in what will be committed)
#
#	index2.php
no changes added to commit (use "git add" and/or "git commit -a")

La section Untracked files affiche les fichiers qui ne sont pas encore ajoutes a git. Si un fichier a été modifié, git le détecte aussi et vous le signale.
la commande git add permettra a la fois de mettre a jour le fichier auparavant versionne, et d’ajouter le nouveau fichier.
pour commiter directement les changements tapez

1
2
3
4

~/gitTest$ git commit -am 'version 3'
~/gitTest$ git status
# On branch master
nothing to commit (working directory clean)

git branch

Tout ce qu’on vient de faire jusque la était commité a la branche principale, ou encore la branche « master ». git nous le disait dans les commentaires de commit (# On branch master). Pour créer une nouvelle branche, on utilisera la commande git branch.

1

~/gitTest$ git branch

la commande git branch sans options liste les branches. Il nous faudra spécifier le nom de la branche si on veut en créer une:

1

~/gitTest$ git branch nouvelleBranche

Pour changer l’environnement de travail a la nouvelle branche créée, utiliser la commande git checkout

1
2

~/gitTest$ git checkout nouvelleBranche
Switched to branch "nouvelleBranche"

On aurait pu créer la branche et switcher directement dedans en tapant :

1

~/gitTest$ git checkout -b nouvelleBranche

On peut ajouter un fichier « onNouvelleBranche.php » dans cette branche

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

~/gitTest$ vi onNouvelleBranche.php // editer, ajouter quelques lignes et sauvegarder
~/gitTest$ git add onNouvelleBranche.php
~/gitTest$ git status
# On branch nouvelleBranche
# Changes to be committed:
#   (use "git reset HEAD ..." to unstage)
#
#	new file:   onNouvelleBranche.php
#
~/gitTest$ git commit onNouvelleBranche.php
Created commit 9136ef3: Added on nouvellebranche.php
 1 files changed, 2 insertions(+), 0 deletions(-)
~/gitTest$ git status
# On branch nouvelleBranche
nothing to commit (working directory clean)

On peut voir qu’on a un le fichier onNouvelleBranche.php qui est seulement dans la branche nouvelleBranche :

1
2
3
4
5
6
7
8

~/gitTest$ git checkout master
Switched to branch "master"
~/gitTest$ ls
index2.php  index3.php  index.php
~/gitTest$ git checkout nouvelleBranche
Switched to branch "nouvelleBranche"
~/gitTest$ ls
index2.php  index3.php  index.php  onNouvelleBranche.php

git merge

Maintenant que nous avons deux branches, la branche master et la branche nouvelleBranche. On peut imaginer le scénario la ou notre code est devenu suffisamment stable sur la branche nouvelleBranche, et qu’on voudrait le merger avec la branche principale. Pour ce faire, dans la branche master, on peut utiliser git merge :

1
2
3
4
5
6
7
8
9
10

~/gitTest$ git checkout master
Switched to branch "master"
~/gitTest$ git merge nouvelleBranche
Updating d7f806b..9136ef3
Fast forward
 onNouvelleBranche.php |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)
 create mode 100644 onNouvelleBranche.php
~/gitTest$ ls
index2.php  index3.php  index.php  onNouvelleBranche.php

Comme vous le remarquez, le fichier onNouvelleBranche.php a ete rajoute dans la branche principale.

git log

Pour afficher les actions effectuées sur le repository, vous pouvez utiliser la commande git log :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

~/gitTest$ git log
commit 9136ef3e840148e6e867589301dd0a6fc02afadb
Author: Anis
Date:   Sat Oct 31 18:32:41 2009 -0400
 
    Added on nouvellebranche.php
 
commit d7f806b98f7528e5247c59eb730405b94ea13c73
Author: Anis
Date:   Sat Oct 31 13:27:41 2009 -0400
 
    Updated index.php
 
commit ae8a77c7fe24e64bfc9a04efc45ae2333ad9e2b1
Author: Anis
Date:   Fri Oct 30 23:46:33 2009 -0400
 
    version 3
 
commit 76eb6058709baa2703bb900e8a321bd8ce5c79e8
Author: Anis
Date:   Fri Oct 30 23:44:08 2009 -0400
 
    added index2 and updated index
 
commit bc061fce5d91dc9e7ea44337b9c99c380d582d72
Author: Anis
Date:   Fri Oct 30 23:06:25 2009 -0400
 
    First revision
 
commit b2c73d23cf1ce6c12f3a6ebbe3d37ecd0c7bbf66
Author: Anis
Date:   Fri Oct 30 22:57:16 2009 -0400
 
    First commit

Pour un meilleur affichage, on peut utiliser l’option –graph, ou encore mieux, on peut utiliser gitk. gitk est un utilitaire graphique qui permet d’afficher l’ensemble des opérations effectuées sur votre repository, les diffs, les logs etc. Vous pouvez installer gitk sous ubuntu avec un simple « sudo apt-get install gitk »

GitHub

GitHub est un site hébergeant des repositories Git. Vous pouvez vous y inscrire et creer votre propre compte et vous aurez 300 Mo de stockage et un nombre illimité de repositories et de collaborateurs.
Vous aurez besoin de votre cle publique pour utiliser le service de GitHub.
Pour generer votre cle publique vous tapez :

1

~/gitTest$ ssh-keygen -t rsa -C "votre.mail@serveur.com"

Suivez les étapes de création, le programme vous indiquera l’emplacement du fichier contenant votre clé publique. C’est généralement sous votre répertoire home : ~/.ssh/id_rsa.pub. Copiez le contenu de ce fichier dans l’espace réservé lors de l’inscription. Ensuite, tapez :

1

~/gitTest$ ssh git@github.com

Vous serez demandes a taper votre pass-phrase pour valider l’authentification.

git clone

Maintenant que nous avons un compte chez github. essayons de « checkouter » un projet. Je choisis le projet PHP AUTOLOAD MANAGER de Bashar :

1
2
3
4
5
6
7
8
9

~$ git clone git://github.com/alfallouji/PHP-Autoload-Manager.git
Initialized empty Git repository in /home/bachkoutou/PHP-Autoload-Manager/.git/
remote: Counting objects: 37, done.
remote: Compressing objects: 100% (37/37), done.
remote: Total 37 (delta 11), reused 0 (delta 0)
Receiving objects: 100% (37/37), 7.16 KiB, done.
Resolving deltas: 100% (11/11), done.
~$ ls
gitTest PHP-Autoload-Manager

git push et git pull

La commande git push permet de pousser vos fichiers dans une repository distante. Je me suis fait créer une repo test sous GitHub. Je vais y pousser mes fichiers crées au cours de ce tutoriel comme suit :

1
2
3
4
5
6
7
8

~/gitTest$ git remote add origin git@github.com:bachkoutou/test.git
~/gitTest$ git push origin master
Counting objects: 19, done.
Compressing objects: 100% (13/13), done.
Writing objects: 100% (19/19), 1.62 KiB, done.
Total 19 (delta 2), reused 0 (delta 0)
To git@github.com:bachkoutou/test.git
 * [new branch]      master -> master

La première commande permet de donner le nom « origin » a notre repository distant. La deuxième va pousser les fichiers qui sont dans la branche master dans ce repository.

Si vous êtes un autre développeur sur le projet test, vous pouvez utiliser la commande git pull qui effectue a la fois un git fetch pour récupérer les changements et un git merge pour les merger avec votre version.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

~$ mkdir gitTestCollaborator
~$ cd gitTestCollaborator/
~/gitTestCollaborator$ vi indexCollaborator.php
~/gitTestCollaborator$ git init
Initialized empty Git repository in /home/bachkoutou/gitTestCollaborator/.git/
~/gitTestCollaborator$ git pull git://github.com/bachkoutou/test.git
remote: Counting objects: 19, done.
remote: Compressing objects: 100% (13/13), done.
remote: Total 19 (delta 2), reused 0 (delta 0)
Unpacking objects: 100% (19/19), done.
From git://github.com/bachkoutou/test
 * branch            HEAD       -> FETCH_HEAD
~/gitTestCollaborator$ git status
# On branch master
# Untracked files:
#   (use "git add ..." to include in what will be committed)
#
#	indexCollaborator.php
nothing added to commit but untracked files present (use "git add" to track)
~/gitTestCollaborator$ git add indexCollaborator.php
~/gitTestCollaborator$ git commit -m "Added file from collaborator"
Created commit f71f97b: Added file from collaborator
 1 files changed, 2 insertions(+), 0 deletions(-)
 create mode 100644 indexCollaborator.php
~/gitTestCollaborator$ git status
# On branch master
nothing to commit (working directory clean)
~/gitTestCollaborator$ git remote add origin git@github.com:bachkoutou/test.git
~/gitTestCollaborator$ git push origin master
Counting objects: 4, done.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 338 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To git@github.com:bachkoutou/test.git
   9136ef3..f71f97b  master -> master
~/gitTestCollaborator$ git status
# On branch master
nothing to commit (working directory clean)

Pour illustrer ce scenario, je viens de

• créer un répertoire gitTestCollaborator et l’acceder
• ajouter un fichier indexCollaborator.php dans lequel j’ai ajouté une ligne
• initialiser le projet avec git init
• checkouter le projet GitHub/bachkoutou/test avec git pull git://github.com/bachkoutou/test.git
• executer git status pour vous montrer que le fichier indexCollaborator.php n’est pas encore ajouté au projet
• ajouter le fichier indexCollaborator.php avec git add
• commiter mes changements avec git commit
• pousser mes changements dans GitHub avec git remote et git push
• executer un autre git status pour s’assurer que tout est bien passe

Je vais revenir maintenant au répertoire gitTest et effectuer un git pull pour récupérer le fichier indexCollaborator.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

~/gitTestCollaborator$ cd ../gitTest
~/gitTest$ ls
index2.php  index3.php  index.php  onNouvelleBranche.php
~/gitTest$ git pull git://github.com/bachkoutou/test.git
remote: Counting objects: 4, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 1), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From git://github.com/bachkoutou/test
 * branch            HEAD       -> FETCH_HEAD
Updating 9136ef3..f71f97b
Fast forward
 indexCollaborator.php |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)
 create mode 100644 indexCollaborator.php
~/gitTest$ ls
index2.php  index3.php  indexCollaborator.php  index.php  onNouvelleBranche.php

Le screenshot suivant affiche le contenu de mes fichiers sur GitHub

Conclusion

Au cours de ce tuto, nous venons de decouvrir comment utiliser Git pour un projet collaboratif et pour versionner vos fichier. Si vous avez des remarques ou des questions n’hesitez surtout pas!