Le contrôle de versions avec CVS

CVS est un logiciel Unix pour gérer différentes versions de beaucoup de fichiers produits éventuellement par de multiples utilisateurs.

Par exemple, les tuteurs informatique utilisent CVS pour gérer ce site.

Pourquoi CVS ?

L'enfer, c'est les autres

Supposons par exemple que vous conceviez un mémoire de maîtrise en collaboration avec un camarade, ou encore que vous écriviez un programme informatique en collaboration avec une équipe de développeurs. Plusieurs scénarii-catastrophes peuvent être envisagés, et vous pouvez être sûr qu'au moins l'un d'entre eux se réalisera tôt ou tard :

  1. l'un des contributeurs efface par erreur tout ou partie du travail commun mené jusque là, alors même que vous approchiez de son terme ;
  2. un contributeur apporte des corrections à une version obsolète du travail commun, car il ne savait pas où trouver la version la plus récente ;
  3. deux contributeurs travaillaient simultanémlent sans le savoir, et le deuxième a effacé sans le vouloir tout le travail du premier ;
  4. un contributeur a commis de nombreuses erreurs, et l'on doit revenir sur chacune de ses modifications, en espérant ne pas laisser d'erreurs ;
  5. etc., etc.

La solution : CVS

L'idéal, pour éviter ces problèmes, serait de pouvoir concilier deux exigences apparemment contradictoires :

  1. centraliser les versions officielles pour éviter toute ambiguïté ;
  2. décentraliser les versions de travail, sur lesquelles les contributeurs apportent leurs modifications.

CVS réunit ces deux avantages, en respectant les principes suivants :

  1. centralisation des versions officielles ;
  2. numérotation des versions ;
  3. possibilité de retour à une version antérieure ;
  4. gestion des conflits entre deux modifications contradictoires des mêmes fichiers ;
  5. décentralisation des répertoires de travail, ce qui permet à plusieurs utilisateurs de travailler simultanément, et de ne pas officialiser les modifications tant qu'elles ne sont pas terminées.

Pour vous initier à CVS, nous allons successivement vous présenter comment mettre un projet sous CVS, puis comment travailler au quotidien sous CVS.

Préliminaires à l'utilisation de CVS

Pour mettre des projets sous CVS, il faut procéder en deux temps :

  1. créer un répertoire de dépôt CVS (en anglais repository), où seront stockées toutes les versions officielles et leurs modifications ;
  2. ajouter à ce répertoire les différents projets que vous voulez mener à l'aide de CVS.

Créer un répertoire de dépôt CVS (repository)

Commençons par créer un répertoire de dépôt, c'est-à-dire un répertoire où CVS stocke toutes les versions et leurs modifications. Rassurez-vous : CVS investit toute son ingéniosité pour réduire au maximum l'espace disque utilisé, en ne retenant que les modifications, au lieu de recopier à chaque fois l'intégralité des fichiers d'un projet.

Pour cela, il faut d'abord créer matériellement ce répertoire, par exemple $HOME/cvs, puis créer la variable d'environnement CVSROOT : 

bireme ~ $ mkdir $HOME/cvs
bireme ~ $ CVSROOT="$HOME/cvs"
bireme ~ $ export CVSROOT

Mais attention ! dans ce cas, la variable CVSROOT disparaîtra quand vous vous déloguerez ou fermerez le terminal courant. Aussi faut-il écrire dans votre fichier .profile (au moins dans le cas de la configuration des machines de l'ENS ; sur une machine personnelle ça peut être différent) : 

CVSROOT="$HOME/cvs"; export CVSROOT

Une fois que ce répertoire existe, il faut « faire les présentations » avec CVS. Tapez : 

bireme ~ $ cd cvs 
bireme ~/cvs $ cvs init

Maintenant, vous avez un répertoire de dépôt prêt à recevoir et à stocker les différents projets. Il ne reste plus qu'à le remplir !

Plusieurs fois, cvs ouvrira un éditeur de texte en vous demandant de commenter ce que vous êtes en train de faire. Commentez vos modifications d'une avec un peu de précision : évitez par exemple d'écrire simplement « modifications diverses », mais plutôt « orthographe, typographie, paragraphe sur X ou Y, fontion Z ou T, etc. » L'objectif est qu'un autre contributeur (ou vous-même à une date ultérieure) puisse ne lire que ce commentaire et savoir la nature de vos modifications.

Créer un projet

Supposons que vous soyez en train de concevoir un projet nommé « turing-test », dont tous les fichiers sont réunis dans le répertoire $HOME/programmation/turing-test.

Tapez : 

bireme ~ $ cd programmation/turing-test
bireme ~/programmation/turing-test $ cvs import turing votre_nom version0

Ainsi est créé un répertoire $HOME/cvs/turing contenant des fichiers correspondant à ceux du répertoire $HOME/programmation/turing-test.

La mention votre_nom vous désigne ; vous pouvez mettre votre login, ou autre chose si vous préférez.

Quant à la mention version0, il s'agit juste d'un nom pour la version initiale : vous pouvez tout aussi bien mettre start, debut, etc. Seule contrainte : le premier caractère doit être une lettre.

Créer un répertoire de travail

Maintenant que vous avez créé votre projet sous CVS, vous pouvez vous créer un répertoire de travail. 

bireme ~ $ mkdir rep-travail
bireme ~ $ cd rep-travail
bireme ~/rep-travail $ cvs checkout turing

La commande cvs checkout projet crée un répertoire de travail pour le projet indiqué. Vous pouvez en créer autant que vous voulez (si vous en avez vraiment l'utilité...). En particulier, plusieurs utilisateurs différents peuvent en créer : c'est précisément ce qui fait l'intérêt de CVS.

CVS au quotidien

Mettre à jour son répertoire de travail

Avant de modifier les fichiers mis sous CVS, vous devrez à chaque fois les mettre à jour, ce qui vous permet de partir de versions récentes de ces fichiers. Pour mettre à jour votre répertoire de travail, tapez : 

bireme ~/turing-test $ cvs update turing

Vous serez alors sûr d'avoir des fichiers à jour.

Vous pouvez aussi ne mettre à jour qu'un fichier, ou une liste de fichiers : 

bireme ~/turing-test $ cvs update fichier1 fichier2 etc

Vous pouvez encore indiquer en ligne de commande quel répertoire mettre à jour : 

bireme ~/turing-test $ cvs update -d ~/programmation/turing-test

Cette dernière commande peut être intégrée à un script, ce qui est très pratique si vous voulez que les modifications soient prises en compte à plusieurs endroits différents (par exemple, dans votre répertoire de travail et sur votre page web, si vous avez mis votre page web sous CVS).

Ajouter des fichiers

Un projet est rarement fixé dès sa première version ; aussi des fichiers peuvent-ils s'ajouter aux fichiers intégrés à l'origine (avec la commande cvs import), d'autres en être retirés.

Pour ajouter des fichiers, la façon de s'y prendre dépend de la nature du fichier en question. En effet, si le fichier est un fichier binaire, il ne sert à rien que CVS le lise ligne à ligne à chaque partage de modifications pour vérifier s'il a changé ; tandis que s'il s'agit d'un fichier texte, CVS est là pour ça.

Par conséquent, si c'est un fichier texte (un texte simple, un script, le code source d'un programme, un fichier TeX, etc.), tapez : 

bireme ~/turing-test $ cvs add fichier1 fichier2 etc

En revanche, si vous voulez ajouter un fichier binaire (un fichier exécutable, un document PS, PDF, une image JPEG, PNG, etc.), tapez : 

bireme ~/turing-test $ cvs add -kb fichier1 fichier2 etc

Vous pouvez vérifier le statut des fichiers (binaires ou non) avec la commande : 

bireme ~/turing-test $ cvs status fichier

Lisez le champ « Sticky Options ». Si sa valeur est « (none) », c'est que votre fichier n'est pas déclaré comme binaire ; s'il vaut « -kb », c'est qu'il l'est.

Il arrive parfois que l'on oublie de déclarer comme binaires certains fichiers, notamment lors de l'enregistrement du projet dans le répertoire de dépôt CVS. Il n'est pas trop tard pour se rattraper : 

bireme ~/turing-test $ cvs update -kb fichier1 fichier2 etc

Ce qui équivaut à la succession de commandes suivante : 

bireme ~/turing-test $ cvs admin -kb fichier1 fichier2 etc

bireme ~/turing-test $ cvs update fichier1 fichier2 etc

Retirer des fichiers

Pour retirer des fichiers, utilisez la commande : 

bireme ~/turing-test $ cvs remove fichier1 fichier2 etc

Partager les modifications

Quand vous avez terminé vos modifications et que vous estimez que le monde est prêt à les recevoir, partagez-les : 

bireme ~/turing-test $ cvs commit

Les modifications seront alors enregistrées dans le répertoire de dépôt.

Vous pouvez aussi ne partager qu'un fichier, ou une liste de fichiers : 

bireme ~/turing-test $ cvs commit fichier1 fichier2 etc

Quand vous partagez vos modifications, un éditeur de texte s'ouvre et vous demande de les commenter. Vous n'êtes pas obligé d'être bavard, mais soyez relativement précis.

Nettoyer son répertoire de travail

Si vous ne contribuez qu'occasionnellement à tel ou tel projet, vous pouvez vouloir ne pas conserver en permanence une version d'un projet donné dans votre répertoire de travail. Pour vous en débarrasser, vous avez bien sûr la possibilité d'effacer les fichiers d'une manière « traditionnelle », au moyen de la commande rm. Mais CVS propose un outil plus puissant : 

bireme ~/turing-test $ cvs release -d turing

Cette commande vérifie que vous avez bien partagé toutes vos modifications avant d'effacer les fichiers de votre répertoire de travail. Ceci vous épargne bien des migraines !

Si vous ne voulez pas effacer vos fichiers, mais simplement vérifier qu'aucun fichier n'a été modifié sans être partagé, tapez simplement : 

bireme ~/turing-test $ cvs release turing

Cette commande annule le cvs checkout.

Fonctionnalités avancées de CVS

Historique des modifications

CVS garde l'historique de toutes les modifications. Si vous voulez voir l'historique complet, tapez : 

bireme ~/turing-test $ cvs log

Vous pouvez aussi ne consulter l'historique que d'un fichier, ou d'une liste de fichiers : 

bireme ~/turing-test $ cvs log fichier1 fichier2 etc

Devant vos yeux ébahis s'affichera alors la liste de toutes les versions de ces fichiers, accompagnées des commentaires déposés par les contributeurs.

Comparer des versions

Vous voulez savoir précisément en quoi telle version d'un fichier diffère de telle autre ; pour cela, tapez : 

bireme ~/turing-test $ cvs diff -r 1.2 fichier

Ainsi, vous pourrez comparer l'état actuel du fichier avec sa version 1.2. Mais vous pouvez aussi comparer deux versions quelconques : 

bireme ~/turing-test $ cvs diff -r 1.1 -r 1.2 fichier

Revenir sur des modifications

Oups ! Vous avez fait une erreur, et dans votre précipitation, vous l'avez déjà partagée. Heureusement, CVS permet de revenir à des versions antérieures. Tapez : 

bireme ~/turing-test $ cvs update -A fichier
bireme ~/turing-test $ rm fichier
bireme ~/turing-test $ cvs update -p -r1.1 fichier > fichier
bireme ~/turing-test $ cvs commit fichier

Astuce : utiliser l'outil make

Imaginons la situation suivante : vous avez un site web sur lequel vous voulez travailler à l'aide de CVS. Vous avez donc un répertoire de dépôt (par exemple ~/cvs/www) et un répertoire de travail (par exemple ~/cvs-travail/www). Mais vous voulez aussi mettre à jour le site en lui-même lorsque vous partagez des modifications, et ce site est dans le répertoire ~/www. Ce répertoire ne peut pas être le même que pour le dépôt, car celui-ci doit lui être exclusivement consacré ; et il ne peut pas non plus être votre répertoire de travail, car la moindre modification (et surtout la moindre erreur) serait immédiatement publiée...

Vous devrez donc taper, à chaque fois que vous voudrez partager vos modifications, les lignes suivantes : 

bireme ~/cvs-travail/www $ cvs commit
bireme ~/cvs-travail/www $ cvs update -d ~/www

Le problème, c'est que cette séquence de commandes sera toujours la même et que vous risquerez toujours d'en oublier une sur les deux... Aussi avez-vous la possibilité d'utiliser l'utilitaire make, outil très puissant, notamment dans ces circonstances (il est très utilisé par les programmeurs).

Commencez donc par éditer un fichier Makefile dans le répertoire souche de votre projet dans le répertoire de travail ; dans notre exemple, il s'agit de ~/cvs-travail/www. Dans ce fichier, écrivez : 

install:
        cvs commit
        cvs update -d /users/ma_promo/ma_section/mon_login/www

Ensuite, ajoutez ce fichier Makefile au CVS : 

bireme ~/cvs-travail/www $ cvs add Makefile

Et à partir de maintenant, au lieu de taper cvs commit pour partager vos modifications, vous taperez simplement : 

bireme ~/cvs-travail/www $ make install

et make se chargera de tout à votre place !

Vous êtes maintenant prêt à utiliser CVS. Sa puissance est telle que cet outil est devenu l'un des standards incontournables. Profitez-en bien !

Bibliographie

Vous pouvez accéder à la petite documentation rédigée par David Monniaux (au format .ps.gz).

La documentation officielle se trouve là-bas.

Auteurs : Baptiste Mélès, Joël Riou.