<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook V4.1//EN">
<article id="lg66j-fr" lang="fr">
<articleinfo>
<title>CVS&nbsp;: Gestion de configuration client-serveur</title>
<subtitle>Linux Gazette numéro 66</subtitle>
<copyright>
<year>2001</year>
<holder>Kapil Sharma</holder>
</copyright>
<author>
<firstname>Kapil</firstname>
<surname>Sharma</surname>
<affiliation>
<address>
<email>kapil@linux4biz.net</email>
</address>
</affiliation>
<authorblurb><para>
Kapil est un consultant Linux/Unix et Internet. Il a travaillé sur des
systèmes Linux/Unix et la sécurité Internet depuis plus de trois ans. Il
gère un site web (<ulink
url="http://linux4biz.net">http://linux4biz.net</ulink>) qui fournit du
support gratuit et commercial autour des solutions web, Linux, et Unix.
</para></authorblurb>
</author>
<author>
<firstname>Jérôme</firstname>
<surname>Fenal</surname>
<affiliation>
<address>
<email>jerome@fenal.org</email>
</address>
</affiliation>
<contrib>Traduction française</contrib>
</author>
</articleinfo>
<!-- ###################################################################### -->
<sect1 id="lg66j-fr-1">
<title>Introduction</title>
<para>
CVS est un système de gestion de configuration. En l'utilisant, vous
pourrez enregistrer l'histoire de vos fichiers source. CVS aide si vous
faites parte d'un groupe de personnes travaillant sur le même projet,
partageant le même code. Plusieurs développeurs peuvent travailler sur
le même projet à distance en utilisant le modèle client serveur de CVS,
modèle dans lequel le code existe sur un serveur central, et où chaque
programmeur récupère le source sur sa machine locale depuis le serveur
CVS (checkout) et le re-sauvegarde sur le serveur CVS (checkin) après
développement. Chaque fois qu'un programmeur insère son nouveau code sur le
serveur CVS, seule la différence [avec la version précédente] est sauvegardée
au lieu d'écraser la précédente version. Cela autorise le serveur à recréer
quelque version précédente que ce soit à la demande, bien que distribuant, par
défaut, la dernière version.
</para>
</sect1>

<!-- ###################################################################### -->
<sect1 id="lg66j-fr-2"><title>Obtenir CVS</title>
<para>
Vous trouverez CVS dans votre distribution ou pouvez obtenir les
sources à <ulink
url="http://www.cvshome.org/downloads.html">http://www.cvshome.org/downloads.html</ulink>.
</para>
<para>La page d'accueil de CVS est <ulink
url="http://www.cvshome.org/">http://www.cvshome.org/</ulink>.
</para>
</sect1>

<!-- ###################################################################### -->
<sect1 id="lg66j-fr-3"><title>L'entrepôt de code</title>
<para>
L'entrepôt de code CVS stocke une copie complète de tous les fichiers et
répertoires qui sont soumis à la gestion de version. En temps normal,
vous n'avez pas à accéder directement à ces fichiers de l'entrepôt. En lieu
et place, vous utilisez les commandes CVS pour obtenir votre propre
copie des fichiers dans un répertoire de travail, puis travaillez sur
cette copie. Quand vous avez fini vos modifications, vous les validez
dans l'entrepôt. L'entrepôt contient ainsi les modifications que vous avez
faites, de même qu'il a enregistré ce que vous avez exactement
modifié, quand vous l'avez modifié, et autres informations du genre.
</para>
<!-- ===================================================================== -->
<sect2><title>Créer un dépôt</title>
<para>
Pour créer un entrepôt, lancez la commande CVS
<command>init</command>. Cela créera un dépôt vide dans la racine CVS
spécifiée de la manière habituelle.
<screen>
cvs -d /usr/local/cvsroot init
</screen>
Ici, le répertoire <filename
class="directory">/usr/local/cvsroot</filename> deviendra le dépôt.
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Variable d'environnement CVSROOT</title>
<para>
Positionnez la variable d'environnement <envar>CVSROOT</envar> dans
les scripts de démarrage de votre interpréteur de commande. Par
exemple, dans <filename>~/.bashrc</filename>&nbsp;:
<screen>
$ export CVSROOT=:pserver:username@foo.com:/usr/local/cvsroot
</screen>
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Sauvegarde du dépôt</title>
<para>
Il y a quelques points à considérer quand vous sauvegardez le
dépôt&nbsp;:
<itemizedlist>
<listitem><para>Personne ne doit utiliser le dépôt pendant la
sauvegarde, ou le logiciel de sauvegarde doit verrouiller CVS pendant
la sauvegarde&nbsp;;</para></listitem>
<listitem><para>Pour verrouiller CVS, vous devez créer un fichier
&laquo;&nbsp;<filename>#cvs.rfl</filename>&nbsp;&raquo; dans chaque
répertoire de dépôt.</para></listitem>
</itemizedlist>
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Dépôt distant</title>
<para>
La copie de travail de vos fichiers sources peut se situer sur une
autre machine que celle hébergeant le dépôt. Cette utilisation de CVS
est connue sous le terme de mode client/serveur.
</para>
<para>
Configuration du serveur&nbsp;: ajoutez l'entrée suivante dans le fichier <filename>/etc/inetd.conf</filename> du serveur&nbsp;:
<programlisting>2401 stream tcp nowait root /usr/local/bin/cvs cvs -f --allow-root=/usr/cvsroot pserver</programlisting>
Si votre super-daemon inetd veut un nom symbolique de service au lieu d'un simple numéro de port, alors ajoutez ceci dans le fichier <filename>/etc/services</filename>
<programlisting>cvspserver     2401/tcp</programlisting>
et mettez &laquo;&nbsp;cvspserver&nbsp;&raquo; au lieu de &laquo;&nbsp;2401&nbsp;&raquo; dans <filename>inetd.conf</filename>.
</para>
<para>Après avoir effectué vos changements, envoyez un signal HUP à <command>inetd</command>.
</para>
</sect2>

<!-- ===================================================================== -->
<sect2><title>Authentification par mot de passe pour les dépôts distants</title>
<para>
Pour configurer l'authentification par mot de passe, créez un fichier <filename>$CVSROOT/CVSROOT/passwd</filename>. Le contenu du fichier ressemblera à&nbsp;:
<programlisting>
anonymous:
kapil:1sOp854gDF3DY
melissa:tGX1fS8sun6rY:pubcvs
</programlisting>
</para>
<para>Les mots de passe sont chiffrés à la mode Unix. La première
ligne de l'exemple autorisera l'accès à n'importe client CVS cherchant
à s'authentifier avec l'utilisateur anonyme <systemitem
class="username">anonymous</systemitem>, quelque soit le mot de passe
qu'il emploie. La deuxième ligne autorisera l'accès à kapil s'il
fournit son mot de passe correspondant à la chaîne chiffrée.
</para>
<para>
La troisième ligne autorisera l'accès à melissa si elle donne son mot
de passe, mais ses opérations CVS se feront en tant que l'utilisateur
<systemitem class="username">pubcvs</systemitem>.
</para>
<para>
Note&nbsp;: CVS peut être configuré pour ne pas utiliser le vrai
fichier de mot de passe d'Unix, à savoir
<filename>/etc/passwd</filename>, pour l'authentification CVS en
positionnant le paramètre <option>SystemAuth</option> à
&laquo;&nbsp;no&nbsp;&raquo; dans le fichier de configuration de CVS
<filename>$CVSROOT/CVSROOT/config</filename>.
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Utilisation du client avec l'authentification par mot de
passe</title>
<para>
Vous devez vous connecter au serveur CVS pour la première fois&nbsp;:
<screen>
cvs -d :pserver:kapil@foo.com:/usr/local/cvsroot login
</screen>
Vous pouvez ensuite utiliser toutes les commandes de CVS sur la
machine distante&nbsp;:
<screen>
cvs -d :pserver:kapil@foo.com:/usr/local/cvsroot checkout someproj
</screen>
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Dépôts en accès lecture seulement</title>
<para>
Il est possible de n'autoriser l'accès qu'en lecture seule à certaines
personnes en utilisant le serveur authentifié par mot de passe. Il y a
deux façons de spécifier l'accès en lecture seule pour un
utilisateur&nbsp;: par inclusion ou par exclusion.
</para>
<para>
Par inclusion signifie spécifier un utilisateur dans le fichier
<filename>$CVSROOT/CVSROOT/readers</filename>, qui est une simple
liste d'utilisateurs sur des lignes séparées. En voici un
exemple&nbsp;:
<programlisting>
kapil
yogesh
john

</programlisting>
N'oubliez pas le dernier retour à la ligne après le dernier utilisateur.
</para>
<para>
Par exclusion, on signifie que tous les utilisateurs doivent avoir un
accès en lecture-écriture, et que tous les autres auront un accès en
lecture seule. Le fichier <filename>writers</filename> a le même
format que le fichier <filename>readers</filename>.
</para>
</sect2>

<!-- ===================================================================== -->
<sect2><title>Mise en place des fichiers dans le dépôt</title>
<para>
Si les fichiers que vous voulez installer dans CVS résident dans un
répertoire <filename class="directory">mon_projet</filename>, et que
vous voulez les voir apparaître dans le dépôt en tant que <filename
class="directory">$CVSROOT/mon_projet</filename>, vous pouvez faire
ceci&nbsp;:
<screen>
$ cd mon_projet
$ cvs import -m "sources importés" mon_projet vendor rel1-1
</screen>
Ici, la chaîne &laquo;&nbsp;vendor&nbsp;&raquo; est une balise pour
l'éditeur, la chaîne &laquo;&nbsp;rel1-1&nbsp;&raquo; est une balise
concernant la version du produit.
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Verrous CVS dans le dépôt</title>
<para>
Tout fichier dans le dépôt qui possède un nom commançant par
&laquo;&nbsp;#cvs.rfl.&nbsp;&raquo; est un verrou en lecture. Tout
fichier dont le nom commence par &laquo;&nbsp;#cvs.wfl.&nbsp;&raquo;
est un verrou en écriture. Le répertoire <filename
class="directory">#cvs.lock</filename> sert de verrou général. Cela
signifie qu'une personne doit d'abord obtenir ce verrou avant de
pouvoir créer les autres verrous.
</para>
<para>
Pour obtenir un verrou en lecture, créez d'abord le répertoire <filename
class="directory">#cvs.lock</filename>. Si la création échoue parce
que le répertoire existe déjà, attendez un peu et ré-eesayez. Après
avoir obtenu le verrou  <filename
class="directory">#cvs.lock</filename>, créez un fichier dont le nom
est <filename>#cvs.rfl.</filename> suivi par l'information de votre
choix (par exemple, un nom de machine ou un identifiant de
processus). Puis retirez le verrou <filename
class="directory">#cvs.lock</filename> pour relâcher le verrou
général. Vous pouvez maintenant lire le dépôt. Quand vous avez fini,
retirez le fichier <filename>#cvs.rfl.</filename> pour relâcher le verrou.
</para>
<para>
Pour obtenir un verrou en écriture, créez d'abord le répertoire verrou
<filename class="directory">#cvs.lock</filename>, comme pour le verrou
en lecture. Vérifiez ensuite qu'il existe pas de fichiers dont les
noms commencent par &laquo;&nbsp;#cvs.rfl.&nbsp;&raquo;. S'il en
existe, enlevez le verrou principal <filename
class="directory">#cvs.lock</filename>, attendez un peu, puis
recommencez. S'il n'y pas de lecteur, créez alors un fichier dont le
nom sera <filename>#cvs.wfl</filename> suivi d'informations de votre
choix (par exemple, nom de machine et identifiant de processus.)
Suspendez-vous au verrou <filename
class="directory">#cvs.lock</filename>. Procédez à vos écritures dans
le dépôt. Quand vous avez fini, retirez d'abord le verrou
<filename>#cvs.wfl</filename> puis le répertoire <filename class="directory">#cvs.lock</filename>.
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Révisions symboliques en utilisant les balises
CVS</title>
<para>
Le numéro de version des produits en version finale sont différents
des révisions dans CVS. Les numéros de révision peuvent changer
plusieurs fois entre deux versions. Vous pouvez utilisez la commande
<command>tag</command> pour donner un nom symbolique à une certaine
révision d'un fichier.
</para>
<para>
Changez de répertoire pour le répertoire de travail, and passez la
commande suivante pour baliser&nbsp;:
<screen>
$ cvs tag rel1-1 fichier.c
</screen>
Cette commande marquera le fichier <filename>fichier.c</filename>
comme étant de révision 1.1.
</para>
<para>
<screen>
$ cvs tag rel1-1 .
</screen>
Cette commande marquera récursivement tous les fichiers du répertoire
courant comme étant de révision 1.1.
</para>
<para>
Vous pouvez utilisez l'option <option>-v</option> de la commande
<command>status</command> pour voir toutes les balises assignées au
fichier, et quels numéros de révision ils représentent, en passant la
commande suivante&nbsp;:
<screen>
$ cvs status -v fichier.c
</screen>
</para>
<para>
Vous pouvez maintenant extraire n'importe quelle révision d'un module
en utilisant la commande suivante&nbsp;:
<screen>
$ cvs checkout -r rel1-1 module1
</screen>
où &laquo;&nbsp;module&nbsp;&raquo; est le nom du module. L'option
<option>-r</option> associé à la commande <command>checkout</command>
permettra à n'importe quel moment dans le futur d'extraire les sources constituant la
révision 1.1 du module &laquo;&nbsp;module1&nbsp;&raquo;.
</para>
</sect2>
</sect1>

<!-- ###################################################################### -->
<sect1 id="lg66j-fr-4"><title>Plusieurs développeurs</title>
<sect2><title>État des fichiers</title>
<para>
La commande <command>cvs status</command> donne l'état des
fichiers. Vous pouvez les obtenir en passant la commande&nbsp;:
<screen>
$ cvs status [options] files
</screen>
</para>
</sect2>
<!-- ===================================================================== -->
<sect2><title>Mettre un fichier à jour</title>
<para>
Quand vous voulez mettre à jour ou fusionner un fichier, utilisez la
commande <command>cvs update</command>. Elle amène à votre copie de
travail tous les changements que les autres développeurs auront
récemment validés. Vos modifications à un fichier ne sont jamais
perdues. Si aucune nouvelle révision n'est disponible, CVS fusionnera
alors tous les changements dans votre copie de travail.
</para>
</sect2>

<!-- ===================================================================== -->
<sect2><title>Résolution des conflits</title>
<para>
Si deux personnes font simultanément des modifications sur différentes
parties d'un fichier, CVS est suffisamment intelligent pour fusionner
les changements tout seul. Mais si deux personnes font des changements
sur la <emphasis>même</emphasis> partie d'un fichier, CVS ne peut
savoir quel doit être le résultat final, et va donc abandonner en se
plaignant&nbsp;: &laquo;&nbsp;Conflict&nbsp;!&nbsp;&raquo; Les
conflits surgissent quand un développeur valide un changement et qu'un
second développeur, qui n'a pas utilisé la commande <command>cvs
update</command> pour recevoir les modifications du premier
développeur, essaie de valider ses propres changements
incompatibles. La résolution des conflits peut prendre des heures
voire des jours. Dans cette section, je vous expliquerai comment
résoudre les conflits de source.
</para>
<para>
Quand vous utilisez la commande <command>cvs commit</command> pour
envoyer automatiquement sur le serveur tous les fichiers que vous avez
modifié ou ajouté à un projet, le serveur du dépôt CVS pourra vous
informer que vos fichiers modifiés localement ne sont pas à jour avec
le serveur, ou vous avez besoin de fusionner à la main un ou plusieurs
fichiers avec les nouvelles versions déjà validées sur le serveur par
un autre développeur. Voici un message d'avertissement typique
survenant lors d'une session CVS&nbsp;:
<screen>
$ cvs commit
cvs commit: Examining .
cvs commit: Up-to-date check failed for `andy.htm' 
cvs commit: Up-to-date check failed for `sample.htm' 
cvs commit: Up-to-date check failed for `index.htm'
...
cvs [commit aborted]: correct above errors first!
</screen>
Vous pouvez utiliser la commande <command>cvs update</command> pour
mettre à jour la copie locale de votre projet avec les derniers
changements du dépôt CVS. Pour mettre à jour l'intégralité de votre
copie locale, ouvrez un interpréteur de commandes, placez vous dans le
répertoire contenant le projet que vous développez, et lancez la
commande&nbsp;:
<screen>$ cvs update</screen>
Cela va mettre à jour et fusionner automatiquement tous les fichiers
qui ont changé depuis la dernière extraction de nouveaux fichiers du
dépôt CVS. Les mises à jour lignes à lignes sur des fichiers textes
(comme des fichiers HTML) peuvent souvent être gérées
automatiquement. CVS vous listera les fichiers qui requièreront votre
attention en vue d'une modification et fusion manuelle.
</para>
<sect3><title>Exemple de fusion automatique&nbsp;:</title>
<para>
Vous modifiez localement un fichier nommé
<filename>index.html</filename> et au moment où vous le validez dans
l'entrepôt CVS, CVS vous répond avec l'erreur suivante&nbsp;:
<screen>
$ cvs commit index.html
cvs commit: Up-to-date check failed for `index.html' 
cvs [commit aborted]: correct above errors first!
</screen>
Cela survient car il y a une nouvelleversion de de ce fichier dans
l'entrepôt CVS. Vous devez utiliser la commande <command>cvs
update</command> pour en obtenir la dernière version sur votre
machine&nbsp;:
<screen>
$ cvs update index.html
RCS file: /usr/local/cvsroot/index.html,v
retrieving revision 1.4
retrieving revision 1.5
Merging differences between 1.4 and 1.5 into index.html 
M index.htm
</screen>
Après la fusion automatique, vous devez vérifier la copie fusionnée
afin qu'elle fonctionne correctement. Une fois satisfait de votre
copie locale de <filename>index.html</filename>, vous la validez dans
l'entrepôt CVS&nbsp;:
<screen>
$ cvs commit index.htm
Checking in index.htm;
/usr/local/cvsroot/index.htm,v <-- index.htm
new revision: 1.6; previous revision: 1.5 
done
</screen>
</para>
</sect3

<sect3><title>Exemple de fusion manuelle</title>
<para>
Dans certains cas, votre récent travail sur certains fichiers peut
être si important que le CVS aura besoin de votre intervention
manuelle de façon à réintégrer les modifications de tout le monde dans
l'entrepôt.
<screen>
$ cvs commit index.html cvs commit: Up-to-date check failed for
`index.html' cvs [commit aborted]: correct above errors first!
</screen>
Utilisez la commande update pour mettre à jour votre copie
locale&nbsp;:
<screen>
$ cvs update
cvs update: Updating .
RCS file: /usr/local/cvsroot/index.html,v
retrieving revision 1.5
retrieving revision 1.6
Merging differences between 1.5 and 1.6 into index.htm
rcsmerge: warning: conflicts during merge
cvs update: conflicts found in activity.htm
C index.htm
</screen> 
Cette fois-ci, CVS a été incapable de fusionner les fichiers
automatiquement. Il a donc créé une copie spéciale du fichier
provoquant le conflit en lieu et place du fichier originel. Ce fichier
contient des lignes de marqueurs pour indiquer le début et la fin des
régions conflictuelles, par exemple&nbsp;:
<screen>
<<<<<<<< filename
</screen>
Pour résoudre les conflits, modifiez simplement le fichier
<filename>index.html</filename> et remplacez le texte entre les
marqueurs et testez le résultat jusqu'à ce que ça marche. Vous devez
aussi enlever les marqueurs&nbsp;:
<screen>
<<<<<<<<========>>>>>>>> 
</screen>
du fichier. Quand vous avez fini de corriger le fichier et l'avez
testé, utilisez la commande <command>cvs commit</command> pour envoyer
dans l'entrepôt cette dernière version de votre fichier&nbsp;:
<screen>
$ cvs commit
Checking in index.html;
/usr/local/cvsroot/index.html,v <-- index.html
new revision: 1.7; previous revision: 1.6 
done
</screen>
</para>
</sect3>
<sect3><title>Les yeux (communication CVS)</title>
<para>
CVS peut fonctionner en tant que moyen de communication de même que
main courante. La fonctionnalité «&nbsp;garder un oeil&nbsp;» permet à
plusieurs développeurs travaillant sur le même projet de notifier aux
autres qui travaille sur quoi à un instant donné. En positionnant un
oeil sur un fichier ou répertoire, un développeur peut demander à CVS
de lui dire si quelqu'un d'autre commence à travailler sur ce fichier
ou répertoire en lui envoyant un mél ou par un autre moyen.
</para>
<para>
Pour utiliser les yeux, vous devez modifier deux fichiers dans la
partie administrative de l'entrepôt de code. Vous devez modifier le
fichier <filename>$CVSROOT/CVSROOT/notify</filename> (qui spécifie à
CVS comment doivent se faire les notifications) et le fichier
<filename>$CVSROOT/CVSROOT/users</filename> (qui spécifie les adresses
mél externes.) Le meilleur moyen de modifier
</para>
</sect3>
</sect2>
<!-- ===================================================================== -->
<!-- ===================================================================== -->
<!-- ===================================================================== -->
</sect1>

<!-- ###################################################################### -->
<sect1 id="lg66j-fr-5"><title>Revenir à une précédente version</title>
<para>
</para>
</sect1>

<!-- ###################################################################### -->
<sect1 id="lg66j-fr-6"><title>Quelques commandes CVS</title>
<para></para>
</sect1>
<!-- ###################################################################### -->
<sect1 id="lg66j-fr-7"><title>Autres outils et ajouts à CVS</title>
<para></para>
</sect1>

<!-- ###################################################################### -->

<sect1 id="lg66j-fr-8">
<title>Pour plus d'information</title>
<itemizedlist>
<listitem><para>Manuel de CVS&nbsp;: <ulink
url="http://www.cvshome.org/docs/manual/cvs.html">http://www.cvshome.org/docs/manual/cvs.html</ulink></para></listitem>
<listitem><para>Listes de distribution CVS&nbsp;: <ulink
url="http://www.cvshome.org/communication.html">http://www.cvshome.org/communication.html</ulink></para></listitem>
</itemizedlist>
<para>Copyright &copy; 2001, Kapil Sharma</para>
<para>Copying license <ulink url="http://www.linuxgazette.com/copying.html">http://www.linuxgazette.com/copying.html</ulink>
</para>
<para>Paru dans le numéro 66 de la Linux Gazette, Mai 2001.</para>
<para>Traduction française par Jérôme Fenal <email>jerome@fenal.org</email>.</para>
</sect1>
</article>

