CVS est un logiciel Unix pour gérer différentes versions
de beaucoup de fichiers produits éventuellement par de multiples
utilisateurs.
Attention, ce logiciel est assez ancien et assez peu utilisé de nos jours. Subversion en est un remplaçant moderne.
Les tuteurs informatique ont utilisé CVS pour gérer ce site
par le passé. Ils utilisent à présent git.
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 :
L'idéal, pour éviter ces problèmes, serait de pouvoir concilier deux exigences apparemment contradictoires :
CVS réunit ces deux avantages, en respectant les principes suivants :
Pour vous initier à CVS, nous allons successivement vous présenter comment mettre un projet sous CVS, puis comment travailler au quotidien sous CVS.
Pour mettre des projets sous CVS, il faut procéder en deux temps :
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.
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.
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.
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).
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
Pour retirer des fichiers, utilisez la commande :
bireme ~/turing-test $ cvs remove fichier1 fichier2 etc
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.
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.
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.
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
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
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 !
Vous pouvez accéder à la petite documentation rédigée par David Monniaux
(au format .ps.gz).
La documentation officielle se trouve là-bas.