Créer un dépôt SVN local

Subversion, désormais Apache Subversion est un système de gestion de versions, celui-ci permet d’historiser les modifications effectuées sur des fichiers afin de pouvoir revenir sur des versions anciennes. Bien que très utilisé pour le développement, Subversion – en bref SVN – ne se limite pas à cela et peut fonctionner pour n’importe quel type d’utilisation (documents, images, etc), il faut juste garder à l’esprit que SVN est principalement fait pour gérer des fichiers dont le contenu évolue dans le temps. Par exemple, pour simplement partager des photos ou de la musique, SVN ne serait pas vraiment approprié car un fichier photo ou musical ne changent en principe pas dans le temps, alors qu’une lettre type, une documentation en cours ou des fichiers de développement bougent sans cesse et il est possible d’avoir besoin de revenir sur d’anciennes versions.

Cette article explique comment mettre en place un dépôt SVN pour les fichiers d’un site web. Le tutoriel est assez global, mais pour information il a été réalisé sur une Fedora 14.

Fonctionnement

Voici briévement comment fonctionne SVN. C’est un système de fichiers virtuels, on ajoute, édite, supprime des fichiers ou répertoires comme dans un système de fichiers traditionnel, mais tout se passe en interne, les différentes révisions des fichiers ne sont pas vraiment physiquement présentes. Pour mettre en pratique ce tutoriel, nous allons tout d’abord créer un dépôt (repository) où toute la gestion sera faite. Puis, dans un second temps nous allons importer un projet existant pour qu’il soit géré par SVN et c’est après que la magie s’opère ^.^

Création d’un dépôt local

Subversion possède deux commandes principales, l’une d’administration svnadmin et la commande de gestion svn. Pour créer un nouveau dépôt svn_projet, nous utilisons la première :

$ svnadmin create --fs-type fsfs /chemin/depot/svn_projet

Un nouveau dossier svn_projet est crée, voici son contenu :

$ ls -l svn_projet/
total 368
drwxr-xr-x  2 fabien subversion   4096 Apr  8 11:52 conf
drwxr-sr-x  6 fabien subversion   4096 Apr  8 11:52 db
-r--r--r--  1 fabien subversion      2 Apr  8 11:52 format
drwxr-xr-x  2 fabien subversion   4096 Apr  8 11:52 hooks
drwxr-xr-x  2 fabien subversion   4096 Apr  8 11:52 locks
-rw-r--r--  1 fabien subversion    229 Apr  8 11:52 README.txt

Il est rare d’aller voir les fichiers à l’intérieur du dépôt et il n’est pas recommandé d’y toucher. Voyons les informations sur notre nouveau dépôt :

$ svn info file:///chemin/depot/svn_projet/
Path: svn_projet
URL: file:///chemin/depot/svn_projet
Repository Root: file:///chemin/depot/svn_projet
Repository UUID: d9d451c0-72b9-4830-93bf-3f8829278afe
Revision: 0
Node Kind: directory
Last Changed Rev: 0
Last Changed Date: 2011-04-08 11:52:00 +0200 (Fri, 08 Apr 2011)

On peut voir que la syntaxe pour interroger ce dépôt commence par file:// pour une gestion locale. Ceci pourrait etre remplacé par http://, ssh://, svn:// ou svn+ssh:// pour un dépôt distant. Pour l’exemple, nous partons avec un projet tout simple composé d’un fichier index.html et d’un fichier style.css dans un répertoire css :

$ tree -a /chemin/projet/web
/chemin/projet/web/
├── css
│   └── style.css
└── index.html

1 directory, 2 files

Nous allons maintenant importer les fichiers non encore gérés par SVN dans le dépôt, ceci se fait avec la commande svn import. Je ne vais pas m’attarder là-dessus, mais par convention, il est bon de créer 3 répertoires dans notre dépôt : trunk, tags et branches. Le premier sera les fichiers du projet les plus récents, il s’agit de la version de travail la plus actuelle. tags contiendra en général les versions historisés (version 1, version 2, etc) et branches représente des dérivations dans le temps de l’évolution des éléments.
Assez de blabla, importons!

$ cd projet
$ svn import /chemin/projet/web file:///chemin/depot/svn_projet/trunk -m 'Initial import.'
Adding         web/css
Adding         web/css/style.css
Adding         web/index.html

Committed revision 1.

Le projet est importé, celui-ci existe désormais dans le dépôt, il s’agit de la version, plus précisément de la révision 1 et un commentaire est ajouté dans le log avec l’option -m, sans cette option l’éditeur par défaut s’ouvrirait et il serait demandé d’écrire une petite bafouille, sans quoi, pas de commit. L’action commit permet de figer un numéro de révision et ainsi de pouvoir y revenir plus tard. Chaque commit incrémente le compteur.

Nous pouvons vérifier notre log :

$ svn log file:///chemin/depot/svn_projet
------------------------------------------------------------------------
r1 | amannf | 2011-04-15 15:10:46 +0200 (Fri, 15 Apr 2011) | 1 line

Initial import.
------------------------------------------------------------------------

A ce stade, il faut comprendre que notre site web est géré par SVN, une première révision existe belle et bien, il est donc possible de supprimer les anciens fichiers non historisés :

$ rm -rf /chemin/projet/web

On se retrouve sans rien… ou presque. Le site est connu de SVN mais nous n’avons plus de fichiers de travail, il faut alors les (re)créer avec l’option checkout de la commande svn, celle-ci permet d’extraire une version qui servira de base au futur développement.

$ mkdir /chemin/travail/web
$ cd /chemin/travail/web
$ svn checkout file:///chemin/depot/svn_projet /chemin/travail/web
A    trunk
A    trunk/css
A    trunk/css/style.css
A    trunk/index.html
Checked out revision 1.

D’accord, mais pourquoi à l’étape précèdente nous avons supprimé nos fichiers pour maintenant les rajouter, car il s’agit des mêmes.. Simplement parce que désormais cette copie va être gérée par SVN, nous pouvons d’ailleurs voir qu’il y a un répertoire .svn à la racine de chaque répertoire et sous-répertoire de notre copie de travail. Attention à ne jamais les supprimer, au risque de passer un précieux temps à remettre sur pieds un dépôt bancal.
Au passage, on peut de nouveau vérifier l’état du dépôt :

$ svn info file:///chemin/depot/svn_projet/
Path: svn_projet
URL: file:///chemin/depot/svn_projet
Repository Root: file:///chemin/depot/svn_projet
Repository UUID: d9d451c0-72b9-4830-93bf-3f8829278afe
Revision: 1
Node Kind: directory
Last Changed Author: amannf
Last Changed Rev: 1
Last Changed Date: 2011-04-08 12:52:00 +0200 (Fri, 08 Apr 2011)

Faire des modifications de structure

Nous allons ajouter un répertoire js contenant un fichier fonctions.js :

$ cd /chemin/travail/web
$ mkdir trunk/js
$ touch trunk/js/fonction.js

Le répertoire doit être pris en compte par le dépôt maintenant. Ceci ne va pas faire un commit mais juste indiquer au dépôt la présence de ce nouveau dossier (et de ce qu’il contient) :

$ svn add trunk/js
A         trunk/js
A         trunk/js/fonction.js

Notre version a évolué avec ce nouveau répertoire js, il est temps de faire notre premier commit, c’est-à-dire d’incrémenter le numéro de révision de notre site web :

$ svn commit -m 'First commit.'
Adding         trunk/js
Adding         trunk/js/fonction.js
Transmitting file data ..
Committed revision 2.

Voilà, nous sommes passés en révision 2 ^.^ Le principe est le même avec la suppression de fichiers/répertoires, le mot clé est – je vous le donne en mille – delete, par example :

$ svn delete trunk/js/fonctions.js
D         trunk/js/fonction.js

Pour valider le changement :

$ svn commit -m 'Delete fonctions.js file.'
Deleting       trunk/js/fonction.js

Committed revision 3.

Et voilà la révision 3. Nous estimons que ceci va correspondre à notre première version officielle, fini la beta! C’est là qu’entre le principe des tags, nous allons créer un tags pour la version 1, c’est-à-dire faire une copie à ce stade, et le développement normal continuera sur le trunk. Vous avez saisi le système du trunk et des branches maintenant. Alors, dans l’ordre cela donne :

$ mkdir tags
$ svn add tags
A         tags
$ svn copy trunk/ tags/version_1.0
A         tags/version_1.0

Voilà, notre version 1.0 est historisée. Presque. Il manque le commit :

$ svn commit -m 'Tagged version 1.0.' tags/
Adding         tags
Adding         tags/version_1.0
Adding         tags/version_1.0/js
Deleting       tags/version_1.0/js/fonction.js
Adding         tags/version_1.0/test

Committed revision 4.

Petite vérification du log :

$ svn log file:///chemin/depot/svn_projet/
------------------------------------------------------------------------
r4 | amannf | 2011-04-15 15:57:49 +0200 (Fri, 15 Apr 2011) | 1 line

Tagged version 1.0.
------------------------------------------------------------------------
r3 | amannf | 2011-04-15 15:48:30 +0200 (Fri, 15 Apr 2011) | 1 line

Delete fonctions.js file.
------------------------------------------------------------------------
r2 | amannf | 2011-04-15 15:41:28 +0200 (Fri, 15 Apr 2011) | 1 line

First commit.
------------------------------------------------------------------------
r1 | amannf | 2011-04-15 15:10:46 +0200 (Fri, 15 Apr 2011) | 1 line

Initial import.
------------------------------------------------------------------------

Revenir sur une ancienne version

C’est bien beau de gérer les révisions de projets, mais encore faut-il pouvoir au besoin revenir sur une ancienne version. Rien de plus simple. Le plus difficile étant de savoir où revenir, d’où la nécessité de bien documenter ses commits (option -m). Dans notre cas, je veux revenir à la version avec le fichier fonctions.js avant sa suppression donc, d’après notre log du point précédent, on voit qu’il faut revenir en r1 :

$ svn co -r 1 file:///chemin/depot/svn_projet/trunk /nouveau/chemin/
A    css
A    css/style.css
A    index.html
Checked out revision 1.

La révision 1 est désormais accessible sous /nouveau/chemin.

Conclusion

Voici une introduction par la pratique de Subversion, certe un peu rapide, mais les grands principes sont là et cela permet de se lancer dans l’aventure.

5 réflexions sur « Créer un dépôt SVN local »

  1. Bonjour, Merci pour ton tuto. J’ai une petite question. le projet initial et le projet importé par SVN ne sont pas synchronisé…. comment faire pour voir les modifications apportées directement dans le dossier de déploiement.

    1. Qu’entends-tu par le projet « initial »? Par exemple pour voir les différences entre la copie de travail et la dernière version du repository, il faut faire un svn diff fichier, pour une version plus ancienne svn diff -r N fichier, ou entre deux versions svn diff -r versionX:versionY.

    2. j’ai pensé au hook. c’est à dire un export dans le post commit, mais comment faire quand on utilise Eclipse.

  2. merci beaucoup pour ce tutoriel qui met effectivemnt en pratique la création de trunk et de tags. il m’a permis de bien m’assurer de cet aspect trop souvent négligé par les auteurs de tutoriels.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *