CVS Handbook

Note technique CODICIEL-LMFA No : 2001 - 01
CODICIEL - UPS CNRS S 0856
CVS Handbook
A. Cadiou
LMFA
LMFA - UMR CNRS 5509, BP 163, 69131 ECULLY Cedex
CVS Handbook - 11 Décembre 2001
CNRS-LMFA
CVS Handbook
Le 11 Décembre 2001
LMFA - UMR CNRS 5509, BP 163, 69131 ECULLY Cedex
Table des matières
1 Qu’est-ce que CVS ?
1
2 Création et accès à une base CVS
2.1 Accès à la base CVS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Création de la base CVS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Déposer un projet dans la base CVS . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
2
2
2
3 Utiliser CVS
3.1 Obtenir une copie de travail . . . . . . . . . . . .
3.2 Archiver les modifications . . . . . . . . . . . . .
3.3 Ajouter ou supprimer des éléments . . . . . . . .
3.4 Suivre l’historique . . . . . . . . . . . . . . . . .
3.5 Définition de noms de versions et branches . . . .
3.6 Revenir en arrière . . . . . . . . . . . . . . . . . .
3.7 Tableau récapitulatif des principales commandes
.
.
.
.
.
.
.
3
3
3
3
3
4
4
4
4 Environnements utilisant CVS
4.1 tkcvs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 xemacs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
5
5
Références
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
CVS Handbook - 11 Décembre 2001
ii
CNRS-LMFA
CVS Handbook - 11 Décembre 2001
Cette notice simplifiée de l’utilisation de CVS s’inspire très largement du manuel CVS [2] et des
différents documents cités en bibliographie. Elle s’appuie également sur les différents sites disponibles
sur internet, dont http ://www.loria.fr/ molli/cvs-index.html et http ://www.cvshome.org.
1
Qu’est-ce que CVS ?
CVS (Concurrent Version System) est un système de gestion de versions de fichiers. Il permet de
conserver la trace des modifications successives effectuées sur les projets placés sous CVS, ainsi que
d’archiver l’historique et la description de ces changements [2]. Il est développé par Cyclic Software
et est sous licence GNU.
CVS aide à gérer le développement d’un projet effectué en parallèle par plusieurs utilisateurs en
identifiant les zones de conflit pour lesquelles un arbitrage humain est requis. Un projet sous CVS est
organisé sous forme de modules, représentant l’arborescence des fichiers. Il est placé dans une base.
CVS peut fonctionner en accès direct sur un système de fichiers réparti comme NFS ou en mode
client/serveur autorisant les développements répartis sur plusieurs sites. CVS se sert de l’heure pour
effectuer ses opérations. Il est donc important de synchroniser les horloges des machines connectées
par un réseau IP , par exemple en utilisant Network Time Protocol.
2
Création et accès à une base CVS
Un projet géré sous CVS est organisé sous forme de modules, comprenant l’arborescence de l’ensemble des fichiers archivés, récupérables par un utilisateur. Ces modules sont placés dans la base
CVS, localisée par exemple sous :
/usr/local/cvs
Pour pouvoir récupérer un projet, c’est-à-dire obtenir une copie de travail d’un module, il est nécessaire
d’avoir accès à la base CVS. Il existe trois méthodes d’accès à une base CVS. Chaque méthode peut être
utilisée simultanément avec la même base. Seules les copies de travail d’un utilisateur donné doivent
toujours utiliser la même méthode d’accès à la base. Le choix de la méthode d’accès s’effectue en
commençant par définir la variable d’environnement CVSROOT. La façon de définir la variable CVSROOT
pour chacune des trois méthodes d’accès, qui sont l’accès direct, en mode serveur pserver ou en
mode rsh/ssh est précisée au paragraphe suivant.
Copie de travail
pserver
Base CVS
rsh/ssh
Copie de travail
direct
Copie de travail
Figure 1 – Accès à la base CVS
CNRS-LMFA
1
CVS Handbook - 11 Décembre 2001
2.1
Accès à la base CVS
Pour un accès direct, soit sur sa propre machine, soit sur un système de fichiers réparti comme
NFS, la variable CVSROOT est définie par :
setenv CVSROOT /usr/local/cvs
en csh ou tcsh, ou encore
export CVSROOT=/usr/local/cvs
en bash.
En mode serveur, l’exécutable CVS attend les requêtes des clients. Sur une machine cliente, la
variable CVSROOT est définie par :
setenv CVSROOT :pserver :user@server :/usr/local/cvs
où user est le nom de l’utilisateur sur la machine server. La connexion est authentifiée par la
commande
cvs login
exécutée sur la machine cliente. Cette commande demande un mot de passe vérifié par le serveur et
stocké dans le fichier .cvspass de l’utilisateur. Après cette authentification, CVS se servira du mot
de passe pour accéder au serveur. La sécurité de cette méthode est équivalente à la sécurité d’accès
au fichier .cvspass. Il est donc préférable d’utiliser un mot de passe différent pour CVS et pour se
connecter au serveur. Cela limite les risques.
En mode rsh/ssh, la variable CVSROOT est définie lorsque la commande rsh est utilisée par :
setenv CVSROOT :ext :user@server :/projet/base
Il peut être intéressant de tester si le programme CVS est disponible sur le serveur server en se
connectant sous l’utilisateur user, par :
rsh -l user server cvs -v
Pour utiliser un ssh, il faut définir la variable d’environnement CVS_RSH par :
setenv CVS_RSH ssh
Il est recommandé d’utiliser cette méthode sécurisée.
2.2
Création de la base CVS
La base, ou repository est créée par la commande
cvs init
Cette commande crée les fichiers d’administration de CVS dans le répertoire défini par la variable
CVSROOT. Un répertoire CVSROOT est également créé. Il est important de n’accéder à ces répertoires
que par l’intermédaire des commandes CVS.
2.3
Déposer un projet dans la base CVS
L’utilisateur possède par exemple un programme source en fortran qu’il souhaite administrer sous
CVS, et qui existe dans le répertoire :
/home/user/cfd/src
Pour enregistrer ce programme sous un module qui sera appelé par exemple src_cvs, la commande
import est utilisée :
cvs import -m "initial version" src_cvs user V0
L’option -m permet de rentrer un commentaire en ligne, ici initial version, associé à la commande
import. Vient ensuite le nom du module déposé, le nom de son auteur et un label désignant le nom
de la version. Il est important que le répertoire /home/user/cfd/src ne contienne que des fichiers à
effectivement placer sous CVS. En effet, chaque action sur un fichier placé dans un module CVS est
gardée en mémoire par CVS. Il ne faut pas créer ou détruire de fichier ou de répertoire directement
dans la base CVS, mais passer par les commandes CVS.
2
CNRS-LMFA
CVS Handbook - 11 Décembre 2001
3
3.1
Utiliser CVS
Obtenir une copie de travail
Pour obtenir une copie de travail des fichiers d’un module, en créant l’arborescence nécessaire, la
commande checkout est utilisée. Par exemple, pour récupérer la dernière version de src_cvs, il faut
demander :
cvs checkout src_cvs
Une copie du module src_cvs est créée sur la machine de l’utilisateur. En pratique, cette commande
ne s’effectue qu’une seule fois, au début du travail. Lorsque l’utilisateur n’utilise plus sa copie de
travail, il peut vouloir la détruire. La commande
cvs release -d src_cvs
permet de la détruire en vérifiant qu’il n’y a pas de modification non archivée dans la base.
3.2
Archiver les modifications
Lorsque les fichiers ont été localement modifiés par l’utilisateur à l’aide de ses outils habituels et
que les modifications sont suffisamment validées pour être archivées, l’utilisateur peut soumettre tout
ou une partie de ses fichiers à CVS, par la commande :
cvs commit -m "Symmetry Boundary condition updated"
Les commentaires permettent de décrire la nature du changement effectué. Cette commande associe
de façon automatique à chaque fichier un numéro de révision du type 1.1 ou 1.1.1.1, puis 1.2, 1.3 et
ainsi de suite.
3.3
Ajouter ou supprimer des éléments
Pour ajouter des fichiers dans la base, il est nécessaire que les noms des fichiers soient stables. Pour
ajouter un fichier dans le module, il faut effectuer les deux commandes suivantes :
cvs add -m "Copyright file" copyright
cvs commit -m "Add first Copyright version" copyright
La première commande n’a aucune action sur CVS. Elle informe CVS que ces fichiers feront prochainement partie de la base. La seconde commande réalise l’ajout. Après modification, la commande log
peut être utilisée pour vérification. Pour détruire un fichier, la commande remove intervient :
cvs remove copyright
cvs commit -m "remove Copyright version" copyright
Elle est également validée par l’action cvs commit.
3.4
Suivre l’historique
Les commentaires associés aux différentes versions de fichiers lors des archivages sont consultables
par la commande :
cvs log main.f
où l’historique du fichier main.f du projet src_cvs s’affiche. L’état des fichiers de la version de travail
peut être à tout moment comparé à l’état des fichiers de la base, pour voir si ces fichiers ont été
modifiés dans la base.
cvs status main.f
S’il est à jour par rapport à la base, il sera décrit comme Up-to-date. Les différences entre deux
versions de la base peuvent être consultées avec la commande diff. Par exemple la comparaison du
fichier main.f entre la version 1.2 et la copie de travail de l’utilisateur s’effectue par :
cvs diff -r 1.2 main.f
CNRS-LMFA
3
CVS Handbook - 11 Décembre 2001
Pour mettre à jour un fichier, la commande update est utilisée.
cvs update main.f
Les conflits éventuels entre des fichiers de différentes versions peuvent ressortir à l’issue de cette
opération.
3.5
Définition de noms de versions et branches
Une opération importante consiste à nommer une version de fichier ou d’un ensemble de fichiers.
Il s’agit d’y associer un tag. Ce nom est alors utilisé à la place du numéro de version dans toutes les
commandes CVS. Par exemple, pour livrer la version V1_0 du module, le tag suivant peut être ajouté
sur le projet :
cvs rtag V1_0 src_cvs
La commande cvs status -v permet alors d’afficher l’état des noms des versions. De façon naturelle,
l’extension de cette notion de tag, est la notion de branche. CVS permet de gérer plusieurs branches
de développement des modules. C’est utile par exemple, lorsque des corrections doivent être effectuées
alors que le développement s’est poursuivi dans la branche principale. Il suffit alors de créer une
branche secondaire à partir de la version antérieure, de corriger et d’archiver les fichiers dans cette
branche secondaire. La version secondaire peut être livrée sans perturber les modifications en cours
dans la branche principale. Pour créer une branche, la commande cvs rtag est utilisée avec l’option
-b :
cvs rtag -b -r V1_0 CORRECTIONS-V1_0 src_cvs
La fusion des branches se fait ensuite par la commande :
cvs checkout -j CORRECTIONS-V1_0 src_cvs
3.6
Revenir en arrière
Si au cours du développement, il apparait souhaitable de revenir à une version antérieure à la
dernière version de la base, il est nécessaire de mettre à jour la dernière version des fichiers concernés,
de les remplacer par une version antérieure et de replacer cette version dans la version de base. Par
exemple, le fichier main.f sous sa version de révision actuelle 1.2 doit être remplacé par celui qui
existait dans la version 1.1. Ceci s’effectue de la manière suivante :
cvs update -A main.f
rm main.f
cvs update -p -r1.1 main.f > main.f
cvs commit -m "back to initial version" main.f
La commande cvs commit valide encore la modification.
3.7
Tableau récapitulatif des principales commandes
Les sous-commandes disponibles avec la commande cvs peuvent être obtenues par :
cvs --help-commands
Ces sous-commandes possèdent des options consultables par :
cvs --help-options
alors que les options spécifiques à une sous-commande donnée sont décrites par :
cvs -H <sous-commande>
La forme générale d’une commande CVS est la suivante :
cvs [options générales] <sous-commande> [options spécifiques]
Les principales commandes sont listées dans le tableau ci-dessous.
4
CNRS-LMFA
CVS Handbook - 11 Décembre 2001
commande
add
checkout
commit
diff
history
import
init
log
release
remove
rtag
status
tag
update
4
descriptif de l’action
ajoute un fichier ou un répertoire à la base
extrait une copie de travail
archive une version dans la base
visualise les différences entre deux versions
visualise l’historique de la base
archive une aborescence de fichiers dans une branche d’un module de la base
met en place une base CVS
liste les informations sur les fichiers et leurs versions
quitte la copie de travail d’un module
retire un fichier d’un module
manipule un nom symbolique de version pour un ou plusieurs modules
visualise l’état des fichiers par rapport à la base CVS
manipule un nom symbolique de version pour un ou plusieurs fichiers
met à jour une copie de travail par rapport aux versions de la base
Environnements utilisant CVS
Il existe de nombreux outils intégrant CVS dans leur environnement. Ils permettent en général une
utilisation relativement conviviale de CVS. Deux de ces outils ont été sélectionnés ci-dessous.
4.1
tkcvs
tkcvs permet d’utiliser les commandes CVS graphiquement avec une interface tk. La différence
entre les fichiers est visualisée par tkdiff. tkcvs permet d’utiliser un éditeur de texte pour travailler sous son interface. Cet éditeur est souvent vi par défaut. tkcvs peut être personnalisé en
installant un fichier .tkcvs qui peut être généré à partir de la configuration par défaut du fichier
/usr/lib/tkcvs/tkcvs_def.tcl. L’interface typique est illustrée à la figure 2.
Les boutons de l’interface permettent d’effectuer les commandes checkout, diff et log aisément.
Les arborescences peuvent être visualisées sous tkcvs, comme le montre la figure 3.
4.2
xemacs
xemacs est interfacé avec CVS par ses modules vc et ediff ainsi que pcl-cvs.
vc (version control) permet d’accéder au versionnement des fichiers individuellement. Les commandes add, update, commit, diff et annotate sont proposées dans le menu.
ediff permet de visualiser la différence entre deux fichiers. Contrairement aux outils basés sur
la commande unix diff qui compare les fichiers lignes par lignes, les fichiers peuvent être comparés
mots par mots.
pcl-cvs complète vc en permettant des mises à jour globales de la version de travail.
Les outils liés à xemacs utilisent la même fenêtre que l’éditeur (cf figure 4). Les clefs des commandes
sont répertoriées dans l’aide associée à xemacs.
CNRS-LMFA
5
CVS Handbook - 11 Décembre 2001
Figure 2 – Interface tkcvs
6
CNRS-LMFA
CVS Handbook - 11 Décembre 2001
Figure 3 – Arborescence tkcvs
CNRS-LMFA
7
CVS Handbook - 11 Décembre 2001
Figure 4 – Interface xemacs
8
CNRS-LMFA
CVS Handbook - 11 Décembre 2001
Références
[1] P. Cederqvist. Version Management with CVS. Signum Support, 1992.
[2] F. Lepied. CVS Configuration et mise en oeuvre. O’Reilly, 2000.
[3] A. Marin. Mini-howto CVS sous unix. Technical Report 1.18, Inria, 2000.
CNRS-LMFA
9
Note technique CODICIEL-LMFA No : 2001 - 01
Authors : A. Cadiou
Title : CVS Handbook
Title : Manuel simplifié d’utilisation de CVS
Résumé : CVS est un logiciel de suivi de versions. Il permet de gérer plus facilement le développement d’un
projet informatique en permettant de visualiser les modifications successives, de revenir en arrière en cas d’erreur
ou de travailler sur des branches parallèles. Il possède par conséquent un intérêt non négligeable dans le cadre d’un
travail en équipe. Ce document présente les principales commandes à connaı̂tre pour un utilisateur travaillant sous CVS.
Mots clés : Gestion de projet, suivi de version
Abstract : CVS (Concurrent Version System) is a version control software. CVS allows to simplify the development of a common project within a group by providing a way to visualize the various modifications proposed by the
developers and archive them, to get back to a previous version when necessary or to work simultaneously on parallel
branches on the same project. This is therefore an interesting tool for team work and development. This document
summarizes the major commands used by co-workers under CVS.
Key words : Version control system