[svnbook] r3706 committed - Translation to French of Chapter 8 : done.

svnbook at googlecode.com svnbook at googlecode.com
Tue Mar 16 17:13:27 CDT 2010

Revision: 3706
Author: christophe.nanteuil
Date: Tue Mar 16 15:12:27 2010
Log: Translation to French of Chapter 8 : done.



--- /trunk/src/fr/book/ch08-embedding-svn.xml	Wed Aug  6 01:45:58 2008
+++ /trunk/src/fr/book/ch08-embedding-svn.xml	Tue Mar 16 15:12:27 2010
@@ -1,585 +1,627 @@
  <chapter id="svn.developer">
-  <title>Embedding Subversion</title>
-  <para>Subversion has a modular design: it's implemented as a
-    collection of libraries written in C.  Each library has a
-    well-defined purpose and application programming interface (API),
-    and that interface is available not only for Subversion itself to
-    use, but for any software that wishes to embed or otherwise
-    programmatically control Subversion.  Additionally, Subversion's
-    API is available not only to other C programs, but also to
-    programs written in higher-level languages such as Python, Perl,
-    Java, and Ruby.</para>
-  <para>This chapter is for those who wish to interact with Subversion
-    through its public API or its various language bindings.  If you
-    wish to write robust wrapper scripts around Subversion
-    functionality to simplify your own life, are trying to develop
-    more complex integrations between Subversion and other pieces of
-    software, or just have an interest in Subversion's various library
-    modules and what they offer, this chapter is for you.  If,
-    however, you don't foresee yourself participating with Subversion
-    at such a level, feel free to skip this chapter with the
-    confidence that your experience as a Subversion user will not be
-    affected.</para>
+  <title>Intégration de Subversion</title>
+  <para>Subversion est conçu de manière modulaire : il est
+    constitué d'un ensemble de bibliothèques écrites en langage C.
+    Chaque bibliothèque a un but et une interface de programmation
+    (API, <quote>application programming interface</quote> en anglais) bien
+    définis ; cette interface est disponible non seulement pour le
+    propre usage de Subversion mais aussi pour n'importe quel programme
+    qui souhaite inclure ou piloter Subversion d'une manière ou d'une
+    autre. En plus, l'API Subversion est non seulement disponible pour
+    les programmes écrits en langage C, mais aussi pour les programmes
+    écrits dans des langages de plus haut niveau tels que Python, Perl,
+    Java et Ruby.</para>
+  <para>Ce chapitre est destiné à ceux qui souhaitent interagir avec
+    Subversion au moyen de son API publique ou d'une de ses nombreuses
+    interfaces avec d'autres langages. Si vous souhaitez écrire des
+    scripts robustes qui encapsulent les fonctionnalités de Subversion
+    afin de vous rendre la vie plus facile, si vous essayez de
+    développer des intégrations plus poussées entre Subversion et
+    d'autres logiciels ou si vous êtes juste intéressé par les nombreux
+    modules de Subversion et ce qu'ils ont à offrir, ce chapitre est
+    fait pour vous. Si, par contre, vous ne vous voyez pas participer
+    à Subversion à ce niveau, vous pouvez sauter ce chapitre sans la
+    moindre crainte pour vos compétences en tant qu'utilisateur de
+    Subversion.</para>

    <!-- =================================================================  
    <!-- =================================================================  
    <!-- =================================================================  
    <sect1 id="svn.developer.layerlib">
-    <title>Layered Library Design</title>
-    <para>Each of Subversion's core libraries can be said to exist in
-      one of three main layers—the Repository layer, the
-      Repository Access (RA) layer, or the Client layer (see <xref
-      linkend="svn.intro.architecture.dia-1" /> in the Preface).  We will  
-      these layers shortly, but first, let's briefly summarize
-      Subversion's various libraries.  For the sake of consistency, we
-      will refer to the libraries by their extensionless Unix library
-      names (<filename>libsvn_fs</filename>,  
+    <title>Organisation des bibliothèques en couches successives</title>
+    <para>Chaque bibliothèque au sein de Subversion peut être classée
+      dans une des trois couches principales — la couche dépôt, la
+      couche d'accès au dépôt (RA pour <quote>repository access</quote>
+      en anglais) et la couche client (voir la <xref
+      linkend="svn.intro.architecture.dia-1" /> de la préface). Nous
+      allons examiner ces trois couches rapidement mais, d'abord,
+      passons brièvement en revue les différentes bibliothèques de
+      Subversion. Pour des raisons de cohérence, nous nous référons à
+      ces bibliothèques par leurs noms Unix sans extension
+      (<filename>libsvn_fs</filename>, <filename>libsvn_wc</filename>,
        <filename>mod_dav_svn</filename>, etc.).</para>

-        <listitem><para>Primary interface for client
-          programs</para></listitem>
+        <listitem><para>interface principale pour les programmes
+          clients ;</para></listitem>
-        <listitem><para>Tree and byte-stream differencing
-          routines</para></listitem>
+        <listitem><para>routines de recherche de différences pour les
+          arborescences et les flux d'octets ;</para></listitem>
-        <listitem><para>Contextual differencing and merging
-          routines</para></listitem>
+        <listitem><para>routines de recherche de différences et de
+          fusions contextuelles ;</para></listitem>
-        <listitem><para>Filesystem commons and module
-          loader</para></listitem>
+        <listitem><para>chargeur de modules et outils communs pour le
+          système de fichiers ;</para></listitem>
-        <listitem><para>The Berkeley DB filesystem
-          backend</para></listitem>
+        <listitem><para>gestion du magasin de données Berkeley
+          DB ;</para></listitem>
-        <listitem><para>The native filesystem (FSFS)
-          backend</para></listitem>
+        <listitem><para>gestion du magasin de données natif
+          FSFS ;</para></listitem>
-        <listitem><para>Repository Access commons and module
-          loader</para></listitem>
+        <listitem><para>outils communs pour l'accès au dépôt et
+          chargeur de modules ;</para></listitem>
-        <listitem><para>The local Repository Access
-          module</para></listitem>
+        <listitem><para>module d'accès au dépôt en
+          local ;</para></listitem>
-        <listitem><para>The WebDAV Repository Access
-          module</para></listitem>
+        <listitem><para>module d'accès au dépôt par
+          WebDAV ;</para></listitem>
-        <listitem><para>Another (experimental) WebDAV Repository
-          Access module</para></listitem>
+        <listitem><para>autre module (expérimental) d'accès au dépôt par
+          WebDAV ;</para></listitem>
-        <listitem><para>The custom protocol Repository Access
-          module</para></listitem>
+        <listitem><para>modèle d'accès au dépôt par le protocole
+          Subversion ;</para></listitem>
-        <listitem><para>Repository interface</para></listitem>
+        <listitem><para>interface du dépôt ;</para></listitem>
-        <listitem><para>Miscellaneous helpful
-          subroutines</para></listitem>
+        <listitem><para>diverses routines utiles ;</para></listitem>
-        <listitem><para>The working copy management
-          library</para></listitem>
+        <listitem><para>bibliothèque pour la gestion de la copie de
+          travail local ;</para></listitem>
-        <listitem><para>Apache authorization module for Subversion
-          repositories access via WebDAV</para></listitem>
+        <listitem><para>module Apache d'authentification pour les accès
+          aux dépôts Subversion par WebDAV ;</para></listitem>
-        <listitem><para>Apache module for mapping WebDAV operations to
-          Subversion ones</para></listitem>
+        <listitem><para>module Apache de correspondance entre les
+          opérations WebDAV et les opérations Subversion.</para></listitem>

-    <para>The fact that the word <quote>miscellaneous</quote>
-      appears only once in the previous list is a good sign.  The
-      Subversion development team is serious about making sure that
-      functionality lives in the right layer and libraries.  Perhaps
-      the greatest advantage of the modular design is its lack of
-      complexity from a developer's point of view.  As a developer,
-      you can quickly formulate that kind of <quote>big
-      picture</quote> that allows you to pinpoint the location of
-      certain pieces of functionality with relative ease.</para>
-    <para>Another benefit of modularity is the ability to replace a
-      given module with a whole new library that implements the same
-      API without affecting the rest of the code base.  In some sense,
-      this happens within Subversion already.  The
+    <para>Le fait que le mot <quote>divers</quote> n'apparaisse qu'une
+      seule fois dans la liste précédente est plutôt un bon signe.
+      L'équipe de développement de Subversion est particulièrement
+      soucieuse de placer les fonctionnalités dans les couches et
+      bibliothèques appropriées. Un des plus grands avantages de cette
+      conception modulaire, du point de vue du développeur, est sûrement
+      l'absence de complexité. En tant que développeur, vous pouvez vous
+      forger rapidement une image mentale de cette architecture et ainsi
+      trouver relativement facilement l'emplacement des fonctionnalités
+      qui vous intéressent.</para>
+    <para>Un autre avantage de la modularité est la possibilité de
+      remplacer un module par une autre bibliothèque qui implémente la
+      même API sans affecter le reste du code. Dans un certain sens,
+      c'est ce qui se passe déjà dans Subversion. Les bibliothèques
-      <filename>libsvn_ra_serf</filename>, and
-      <filename>libsvn_ra_svn</filename> libraries each implement the
-      same interface, all working as plug-ins to
-      <filename>libsvn_ra</filename>.  And all four communicate with
-      the Repository layer—<filename>libsvn_ra_local</filename>  
connects to the
-      repository directly; the other three do so over a network.  The
-      <filename>libsvn_fs_base</filename> and
-      <filename>libsvn_fs_fs</filename> libraries are another pair of
-      libraries that implement the same functionality in different
-      ways—both are plug-ins to the common
-      <filename>libsvn_fs</filename> library.</para>
-    <para>The client itself also highlights the benefits of modularity
-      in the Subversion design.  Subversion's
-      <filename>libsvn_client</filename> library is a one-stop shop
-      for most of the functionality necessary for designing a working
-      Subversion client (see <xref
-      linkend="svn.developer.layerlib.client"/>).  So while the
-      Subversion distribution provides only the <command>svn</command>
-      command-line client program, several third-party
-      programs provide various forms of graphical client UIs.
-      These GUIs use the same APIs that the stock command-line client
-      does.  This type of modularity has played a large role in the
-      proliferation of available Subversion clients and IDE
-      integrations and, by extension, to the tremendous adoption rate
-      of Subversion itself.</para>
+      <filename>libsvn_ra_serf</filename> et
+      <filename>libsvn_ra_svn</filename> implémentent toutes la même
+      interface et fonctionnent comme des greffons pour
+      <filename>libsvn_ra</filename>.  Et toutes les quatre communiquent
+      avec la couche dépôt — <filename>libsvn_ra_local</filename>
+      se connectant directement au dépôt, les trois autres le faisant à
+      travers le réseau.
+      <filename>libsvn_fs_base</filename> et
+      <filename>libsvn_fs_fs</filename> sont un autre exemple de
+      bibliothèques qui implémentent les mêmes fonctionnalités de
+      différentes manières — les deux sont des greffons pour la
+      bibliothèque commune <filename>libsvn_fs</filename>.</para>
+    <para>Le client lui-même illustre également les avantages de la
+      modularité dans l'architecture de Subversion. La bibliothèque
+      <filename>libsvn_client</filename> est un point d'entrée unique
+      pour la plupart des fonctionnalités nécessaires à la conception
+      d'un client Subversion fonctionnel (voir <xref
+      linkend="svn.developer.layerlib.client"/>). Ainsi, bien que la
+      distribution Subversion fournisse seulement le programme en ligne
+      de commande <command>svn</command>, de nombreux programmes tiers
+      fournissent différents types d'IHM. Ces interfaces graphiques
+      utilisent la même API que le client en ligne de commande fourni en
+      standard. Depuis le début, cette modularité joue un rôle majeur
+      dans la prolifération des différents clients Subversion (sous la
+      forme de clients autonomes ou greffés dans des environnements de
+      développement intégrés [IDE en anglais]) et, par extension, dans
+      l'adoption formidablement rapide de Subversion lui-même.</para>

      <!-- ===============================================================  
      <sect2 id="svn.developer.layerlib.repos">
-      <title>Repository Layer</title>
-      <para>When referring to Subversion's Repository layer, we're
-        generally talking about two basic concepts—the versioned
-        filesystem implementation (accessed via
-        <filename>libsvn_fs</filename>, and supported by its
-        <filename>libsvn_fs_base</filename> and
-        <filename>libsvn_fs_fs</filename> plug-ins), and the repository
-        logic that wraps it (as implemented in
-        <filename>libsvn_repos</filename>).  These libraries provide
-        the storage and reporting mechanisms for the various revisions
-        of your version-controlled data.  This layer is connected to
-        the Client layer via the Repository Access layer, and is, from
-        the perspective of the Subversion user, the stuff at the
-        <quote>other end of the line.</quote></para>
-      <para>The Subversion filesystem is not a kernel-level filesystem
-        that one would install in an operating system (such as the
-        Linux ext2 or NTFS), but instead is a virtual filesystem.
-        Rather than storing <quote>files</quote> and
-        <quote>directories</quote> as real files and directories (the
-        kind you can navigate through using your favorite shell
-        program), it uses one of two available abstract storage
-        backends—either a Berkeley DB database environment or a
-        flat-file representation.  (To learn more about the two
-        repository backends, see <xref
-        linkend="svn.reposadmin.basics.backends"/>.)  There has even
-        been considerable interest by the development community in
-        giving future releases of Subversion the ability to use other
-        backend database systems, perhaps through a mechanism such as
-        Open Database Connectivity (ODBC).  In fact, Google did
-        something similar to this before launching the Google Code
-        Project Hosting service:  they announced in mid-2006 that
-        members of its open source team had written a new proprietary
-        Subversion filesystem plug-in that used Google's ultra-scalable
-        Bigtable database for its storage.</para>
-      <para>The filesystem API exported by
-        <filename>libsvn_fs</filename> contains the kinds of
-        functionality you would expect from any other filesystem
-        API—you can create and remove files and directories,
-        copy and move them around, modify file contents, and so on.
-        It also has features that are not quite as common, such as the
-        ability to add, modify, and remove metadata
-        (<quote>properties</quote>) on each file or directory.
-        Furthermore, the Subversion filesystem is a versioning
-        filesystem, which means that as you make changes to your
-        directory tree, Subversion remembers what your tree looked
-        like before those changes.  And before the previous changes.
-        And the previous ones.  And so on, all the way back through
-        versioning time to (and just beyond) the moment you first
-        started adding things to the filesystem.</para>
-      <para>All the modifications you make to your tree are done
-        within the context of a Subversion commit transaction.  The
-        following is a simplified general routine for modifying your
-        filesystem:</para>
+      <title>Couche dépôt</title>
+      <para>Quand nous faisons référence à la couche dépôt de
+        Subversion, nous parlons généralement de deux concepts de
+        base : l'implémentation du système de fichiers suivi en
+        versions (auquel on a accès via
+        <filename>libsvn_fs</filename> et qui est supporté par les
+        greffons associés <filename>libsvn_fs_base</filename> et
+        <filename>libsvn_fs_fs</filename>) et la logique du dépôt qui
+        l'habille (telle qu'elle est implémentée dans
+        <filename>libsvn_repos</filename>). Ces bibliothèques
+        fournissent les mécanismes de stockage et de comptes-rendus pour
+        les différentes révisions de vos données suivies en versions.
+        Cette couche est connectée à la couche client via la couche
+        d'accès au dépôt et est, du point de vue de l'utilisateur de
+        Subversion, le <quote>truc à l'autre bout de la
+        ligne</quote>.</para>
+      <para>Le système de fichiers Subversion n'est pas un système de
+        fichiers de bas niveau que vous pourriez installer sur votre
+        système d'exploitation (tels que NTFS ou ext2 pour Linux) mais
+        un système de fichiers virtuel. Plutôt que de stocker les
+        fichiers et répertoires comme des fichiers et des répertoires
+        réels (du type de ceux dans lesquels vous naviguez avec votre
+        navigateur de fichiers), il utilise un des deux magasins de
+        données abstraits disponibles : soit le système de gestion
+        de bases de données Berkeley DB, soit une représentation dans
+        des fichiers ordinaires, dite <quote>à plat</quote> (pour en
+        apprendre plus sur les deux magasins de données, reportez-vous
+        à <xref linkend="svn.reposadmin.basics.backends"/>). La
+        communauté de développement Subversion a même exprimé le souhait
+        que les futures versions de Subversion puissent utiliser
+        d'autres magasins de données, peut-être à travers un mécanisme
+        tel que ODBC (Open Database Connectivity , standard ouvert de
+        connexion à des bases de données). En fait, Google a fait
+        quelque chose de semblable avant de lancer le service
+        <quote>Google Code Project Hosting</quote> (Hébergement de code
+        source de projets) : ils ont annoncé mi-2006 que les
+        membres de leur équipe open source avaient écrit un nouveau
+        greffon propriétaire de système de fichiers pour Subversion, qui
+        utilisait leur base de données <quote>Google ultra-scalable
+        Bigtable</quote> comme magasin de données.</para>
+      <para>L'API du système de fichiers, mise à disposition par
+        <filename>libsvn_fs</filename>, contient les fonctionnalités que
+        vous pouvez attendre de n'importe quel autre système de
+        fichiers : vous pouvez créer et supprimer des fichiers et
+        des répertoires, les copier et les déplacer, modifier le contenu
+        d'un fichier, etc. Elle possède également des caractéristiques
+        peu communes comme la capacité d'ajouter, modifier et supprimer
+        des méta-données (<quote>propriétés</quote>) sur chaque fichier
+        ou répertoire. En outre, le système de fichiers Subversion est
+        un système de fichiers suivi en versions, ce qui veut dire que
+        si vous faites des modifications dans votre arborescence,
+        Subversion se souvient de l'état de votre arborescence avant les
+        modifications. Et il se souvient aussi de l'état avant les
+        modifications précédentes, et l'état encore antérieur, et ainsi
+        de suite. Vous pouvez ainsi remonter le temps (c'est-à-dire les
+        versions) jusqu'au moment où vous avez commencé à ajouter des
+        éléments dans le système de fichiers.</para>
+      <para>Toutes les modifications faites sur l'arborescence ont pour
+        contexte les transactions de propagation de Subversion. Ce qui
+        suit est la démarche générale simplifiée de modification du
+        système de fichiers :</para>

-          <para>Begin a Subversion commit transaction.</para>
+          <para>Commencer une transaction de propagation de
+            Subversion ;</para>
-          <para>Make your changes (adds, deletes, property
-            modifications, etc.).</para>
+          <para>Effectuer les modifications (ajouts, suppressions,
+            modifications de propriétés, etc.) ;</para>
-          <para>Commit your transaction.</para>
+          <para>Clore la transaction.</para>

-      <para>Once you have committed your transaction, your filesystem
-        modifications are permanently stored as historical artifacts.
-        Each of these cycles generates a single new revision of your
-        tree, and each revision is forever accessible as an immutable
-        snapshot of <quote>the way things were.</quote></para>
+      <para>Une fois que la transaction est cloturée, les
+        modifications du système de fichiers sont stockées de
+        façon permanente en tant qu'éléments de l'historique. Chacun de
+        ces cycles génère une nouvelle révision de l'arborescence et
+        chaque révision est accessible pour toujours sous la forme d'un
+        cliché, immuable, de l'état de l'arborescence à un moment
+        précis.</para>

-        <title>The Transaction Distraction</title>
-        <para>The notion of a Subversion transaction can become easily
-          confused with the transaction support provided by the
-          underlying database itself, especially given the former's
-          close proximity to the Berkeley DB database code in
-          <filename>libsvn_fs_base</filename>.  Both types of
-          transaction exist to provide atomicity and isolation.  In
-          other words, transactions give you the ability to perform a
-          set of actions in an all-or-nothing fashion—either all
-          the actions in the set complete with success, or they all
-          get treated as though <emphasis>none</emphasis> of them ever
-          happened—and in a way that does not interfere with
-          other processes acting on the data.</para>
-        <para>Database transactions generally encompass small
-          operations related specifically to the modification of data
-          in the database itself (such as changing the contents of a
-          table row).  Subversion transactions are larger in scope,
-          encompassing higher-level operations such as making
-          modifications to a set of files and directories that are
-          intended to be stored as the next revision of the filesystem
-          tree.  If that isn't confusing enough, consider the fact
-          that Subversion uses a database transaction during the
-          creation of a Subversion transaction (so that if the
-          creation of a Subversion transaction fails, the database will
-          look as though we had never attempted that creation in the first
-          place)!</para>
-        <para>Fortunately for users of the filesystem API, the
-          transaction support provided by the database system itself
-          is hidden almost entirely from view (as should be expected
-          from a properly modularized library scheme).  It is only
-          when you start digging into the implementation of the
-          filesystem itself that such things become visible (or
-          interesting).</para>
+        <title>Digression sur les transactions</title>
+        <para>La notion de transaction Subversion peut être facilement
+          confondue avec la notion de transaction concernant le magasin
+          de données sous-jacent, en particulier à cause de la proximité
+          du code des transactions Subversion dans
+          <filename>libsvn_fs_base</filename> et du code du gestionnaire
+          de bases de données Berkeley DB. Ces deux types de
+          transactions assurent l'atomicité et l'isolation. En d'autres
+          termes, les transactions vous permettent d'effectuer un
+          ensemble d'actions avec une logique tout-ou-rien (soit toutes
+          les actions de l'ensemble se terminent avec succès, soit c'est
+          comme si aucune n'avait eu lieu), ce qui permet de ne pas
+          interférer avec les autres processus qui travaillent sur les
+          données.</para>
+        <para>Les transactions dans les bases de données comprennent
+          généralement de petites opérations relatives à la modification
+          de données dans la base elle-même (comme changer le contenu
+          d'une ligne dans une table). Les transactions Subversion ont
+          un champ d'action plus large, elles comprennent des opérations
+          de plus haut niveau telles que modifier un ensemble de
+          fichiers et de répertoires qui doivent être stockés dans la
+          prochaine révision de l'arborescence suivie en versions. Pour
+          ajouter à la confusion, Subversion utilise une transaction de
+          base de données pendant la création d'une transaction
+          Subversion (ainsi, si la création de la transaction Subversion
+          échoue, la base de données sera telle que si la demande de
+          création n'avait jamais eu lieu) !</para>
+        <para>Heureusement pour les utilisateurs de l'API du système de
+          fichiers, la notion de transaction du système de gestion de
+          bases de données lui-même est presque entièrement masquée
+          (comme on peut s'y attendre dans une architecture modulaire
+          bien construite). C'est seulement si vous commencez à fouiller
+          dans l'implémentation du système de fichiers que de telles
+          choses deviennent visibles (ou intéressantes).</para>


-      <para>Most of the functionality the filesystem
-        interface provides deals with actions that occur on individual
-        filesystem paths.  That is, from outside the filesystem, the
-        primary mechanism for describing and accessing the individual
-        revisions of files and directories comes through the use of
-        path strings such as <filename>/foo/bar</filename>, just as though
-        you were addressing files and directories through your
-        favorite shell program.  You add new files and directories by
-        passing their paths-to-be to the right API functions.  You
-        query for information about them by the same mechanism.</para>
-      <para>Unlike most filesystems, though, a path alone is not
-        enough information to identify a file or directory in
-        Subversion.  Think of a directory tree as a two-dimensional
-        system, where a node's siblings represent a sort of
-        left-and-right motion, and navigating into the node's
-        subdirectories represents a downward motion.  <xref
-        linkend="svn.developer.layerlib.repos.dia-1"/> shows a typical
-        representation of a tree as exactly that.</para>
+      <para>La majeure partie des fonctionnalités offertes par
+        l'interface du système de fichiers traite d'actions relatives à
+        un chemin unique du système de fichiers. C'est-à-dire que, vu de
+        l'extérieur du système de fichiers, le mécanisme de base pour
+        décrire et accéder à une révision donnée d'un fichier ou d'un
+        répertoire utilise des chemins classiques tels que
+        <filename>/machin/bidule</filename>, de la même manière que
+        quand vous indiquez un fichier ou un répertoire dans votre
+        interface en ligne de commande favorite. Vous ajoutez de
+        nouveaux fichiers ou répertoires en passant leur
+        <quote>futur</quote> chemin à la fonction idoine de l'API. Vous
+        faites des requêtes sur ces éléments avec le même
+        mécanisme.</para>
+      <para>Cependant, contrairement à la plupart des systèmes de
+        fichiers, le chemin n'est pas une information suffisante pour
+        identifier un fichier ou un répertoire dans Subversion.
+        Représentez-vous l'arborescence des répertoires comme un système
+        à deux dimensions, où l'on atteint les frères d'un nœud en se
+        déplaçant horizontalement, à droite ou à gauche, et où la
+        navigation dans les sous-répertoires de ce nœud peut être
+        assimilée à un mouvement vers le bas. La <xref
+        linkend="svn.developer.layerlib.repos.dia-1"/> illustre ce
+        concept pour une arborescence classique.</para>

        <figure id="svn.developer.layerlib.repos.dia-1">
-        <title>Files and directories in two dimensions</title>
+        <title>Fichiers et répertoires en deux dimensions</title>
          <graphic fileref="images/ch08dia1.png"/>

-      <para>The difference here is that the Subversion filesystem has a
-        nifty third dimension that most filesystems do not
-        have—Time!
-        <footnote>
-          <para>We understand that this may come as a shock to sci-fi
-            fans who have long been under the impression that Time was
-            actually the <emphasis>fourth</emphasis> dimension, and we
-            apologize for any emotional trauma induced by our
-            assertion of a different theory.</para>
-        </footnote>
-        In the filesystem interface, nearly every function that has a
-        <parameter>path</parameter> argument also expects a
-        <parameter>root</parameter> argument.  This
-        <literal>svn_fs_root_t</literal> argument describes
-        either a revision or a Subversion transaction (which is simply
-        a revision in the making) and provides that third dimension
-        of context needed to understand the difference between
-        <filename>/foo/bar</filename> in revision 32, and the same
-        path as it exists in revision 98.  <xref
-        linkend="svn.developer.layerlib.repos.dia-2"/> shows revision
-        history as an added dimension to the Subversion filesystem
-        universe.</para>
+      <para>Ici, la différence est que le système de fichiers Subversion
+        possède une élégante troisième dimension que la plupart des
+        systèmes de fichiers n'ont pas : le temps<footnote>
+          <para>Nous comprenons que cela puisse être un choc énorme pour
+            les amateurs de science-fiction, qui ont longtemps cru que
+            le Temps était en fait la quatrième dimension. Nous nous
+            excusons pour le traumatisme psychologique causé par
+            l'affirmation de cette théorie divergente.</para>
+        </footnote>.
+        Dans l'interface du système de fichiers, presque chaque fonction
+        qui demande un argument de type <literal>chemin</literal> attend
+        également un argument de type <literal>racine</literal> (dénommé
+        en fait <literal>svn_fs_root_t</literal>). Cet argument décrit
+        soit une révision soit une transaction (qui est en fait la
+        genèse d'une révision) et fournit la troisième dimension,
+        l'élément de contexte indispensable pour différencier
+        <filename>/machin/bidule</filename> dans la révision 32 et le
+        même chemin dans la révision 98. La <xref
+        linkend="svn.developer.layerlib.repos.dia-2"/> présente
+        l'historique des révisions comme une dimension supplémentaire de
+        l'univers du système de fichiers Subversion.</para>

        <figure id="svn.developer.layerlib.repos.dia-2">
-        <title>Versioning time—the third dimension!</title>
+        <title>Ajouter le temps pour le suivi de versions — la
+          troisième dimension !</title>
          <graphic fileref="images/ch08dia2.png"/>

-      <para>As we mentioned earlier, the
-        <filename>libsvn_fs</filename> API looks and feels like any
-        other filesystem, except that it has this wonderful versioning
-        capability.  It was designed to be usable by any program
-        interested in a versioning filesystem.  Not coincidentally,
-        Subversion itself is interested in that functionality.  But
-        while the filesystem API should be sufficient for basic file
-        and directory versioning support, Subversion wants
-        more—and that is where <filename>libsvn_repos</filename>
-        comes in.</para>
-      <para>The Subversion repository library
-        (<filename>libsvn_repos</filename>) sits (logically speaking)
-        atop the <filename>libsvn_fs</filename> API, providing
-        additional functionality beyond that of the underlying
-        versioned filesystem logic.  It does not completely wrap each
-        and every filesystem function—only certain major steps
-        in the general cycle of filesystem activity are wrapped by the
-        repository interface.  Some of these include the creation and
-        commit of Subversion transactions and the modification of
-        revision properties.  These particular events are wrapped by
-        the repository layer because they have hooks associated with
-        them.  A repository hook system is not strictly related to
-        implementing a versioning filesystem, so it lives in the
-        repository wrapper library.</para>
-      <para>The hooks mechanism is but one of the reasons for the
-        abstraction of a separate repository library from the rest of
-        the filesystem code.  The <filename>libsvn_repos</filename>
-        API provides several other important utilities to Subversion.
-        These include the abilities to:</para>
+      <para>Comme nous l'avons déjà mentionné, l'API de
+        <filename>libsvn_fs</filename> ressemble à s'y méprendre à celle
+        de n'importe quel autre système de fichiers, sauf qu'on y a
+        ajouté la formidable capacité de suivre les versions. Elle a été
+        conçue pour être utilisable par n'importe quel programme ayant
+        besoin d'un système de fichiers suivi en versions. Et, ce n'est
+        pas un hasard, Subversion lui-même est intéressé par une telle
+        fonctionnalité. Mais, bien que cette API soit suffisante pour
+        effectuer un suivi en versions basique des fichiers et des
+        répertoires, Subversion en demande plus, et c'est là que
+        <filename>libsvn_repos</filename> entre en scène.</para>
+      <para>La bibliothèque du dépôt Subversion
+        (<filename>libsvn_repos</filename>) se situe (logiquement
+        parlant) au-dessus de l'API <filename>libsvn_fs</filename> et
+        elle fournit des fonctionnalités supplémentaires allant au-delà
+        de la logique sous-jacente du système de fichiers suivi en
+        versions. Elle ne masque pas entièrement chaque fonction du
+        système de fichiers — seules certaines étapes importantes
+        dans le cycle général de l'activité du système de fichiers sont
+        encapsulées par l'interface du dépôt. Parmi les fonctions
+        encapsulées, on peut citer la création et la propagation des
+        transactions Subversion et la modification des propriétés de
+        révisions. Ces actions particulières sont encapsulées par la
+        couche dépôt parce qu'elles ont des procédures automatiques
+        associées. Le système des procédures automatiques du dépôt n'est
+        pas strictement concomitant à l'implémentation d'un système de
+        fichiers suivi en versions, c'est pourquoi il réside dans la
+        bibliothèque d'encapsulation du dépôt.</para>
+      <para>Le mécanisme des procédures automatiques n'est pas l'unique
+        raison qui a conduit à séparer logiquement la bibliothèque du
+        dépôt du reste du code du système de fichiers. L'API de
+        <filename>libsvn_repos</filename> fournit à Subversion un
+        certain nombre d'autres possibilités intéressantes. Parmi elles,
+        on peut citer :</para>

-          <para>Create, open, destroy, and perform recovery steps on a
-            Subversion repository and the filesystem included in that
-            repository.</para>
+          <para>créer, ouvrir, détruire et effectuer des actions de
+            restauration sur un dépôt Subversion et le système de
+            fichiers inclus dans ce dépôt ;</para>
-          <para>Describe the differences between two filesystem
-            trees.</para>
+          <para>décrire les différences entre deux
+            arborescences ;</para>
-          <para>Query for the commit log messages associated with all
-            (or some) of the revisions in which a set of files was
-            modified in the filesystem.</para>
+          <para>obtenir les messages de propagation associés à toutes
+            (ou certaines) les révisions qui ont modifié un ensemble de
+            fichiers du système de fichiers ;</para>
-          <para>Generate a human-readable <quote>dump</quote> of the
-            filesystem—a complete representation of the revisions in
-            the filesystem.</para>
+          <para>générer des images (<quote>dumps</quote>) du système de
+            fichiers lisibles par l'utilisateur — ces images étant
+            des représentations complètes des révisions du système de
+            fichiers ;</para>
-          <para>Parse that dump format, loading the dumped revisions
-            into a different Subversion repository.</para>
+          <para>analyser ces images et les charger dans un autre dépôt
+            Subversion.</para>

-      <para>As Subversion continues to evolve, the repository library
-        will grow with the filesystem library to offer increased
-        functionality and configurable option support.</para>
+      <para>Comme Subversion continue à évoluer, la bibliothèque du dépôt
+      grandit avec la bibliothèque du système de fichiers pour offrir
+      davantage de fonctionnalités et des options configurables.</para>


      <!-- ===============================================================  
      <sect2 id="svn.developer.layerlib.ra">
-      <title>Repository Access Layer</title>
-      <para>If the Subversion Repository layer is at <quote>the other
-        end of the line,</quote> the Repository Access (RA) layer is
-        the line itself.  Charged with marshaling data between the
-        client libraries and the repository, this layer includes the
-        <filename>libsvn_ra</filename> module loader library, the RA
-        modules themselves (which currently includes
-        <filename>libsvn_ra_neon</filename>,
-        <filename>libsvn_ra_local</filename>,
-        <filename>libsvn_ra_serf</filename>, and
-        <filename>libsvn_ra_svn</filename>), and any additional
-        libraries needed by one or more of those RA modules (such as
-        the <filename>mod_dav_svn</filename> Apache module or
-        <filename>libsvn_ra_svn</filename>'s server,
+      <title>Couche d'accès au dépôt</title>
+      <para>Si la couche Dépôt de Subversion est <quote>à l'autre bout
+        de la ligne</quote>, la couche d'accès au dépôt (RA pour
+        <quote>repository access</quote> en anglais) est la ligne en
+        tant que telle. Chargée d'organiser les données entre les
+        bibliothèques client et le dépôt, cette couche inclut la
+        bibliothèque de chargement du module
+        <filename>libsvn_ra</filename>, les modules RA eux-mêmes (qui
+        incluent à l'heure actuelle <filename>libsvn_ra_neon</filename>,
+        <filename>libsvn_ra_local</filename>,
+        <filename>libsvn_ra_serf</filename> et
+        <filename>libsvn_ra_svn</filename>) et toute bibliothèque
+        supplémentaire requise par un ou plusieurs de ces modules RA
+        (par exemple, le module Apache <filename>mod_dav_svn</filename>
+        ou le serveur de <filename>libsvn_ra_svn</filename>,

-      <para>Since Subversion uses URLs to identify its repository
-        resources, the protocol portion of the URL scheme (usually
-        <literal>file://</literal>, <literal>http://</literal>,
-        <literal>https://</literal>, <literal>svn://</literal>, or
-        <literal>svn+ssh://</literal>) is used to determine which RA
-        module will handle the communications.  Each module registers
-        a list of the protocols it knows how to <quote>speak</quote>
-        so that the RA loader can, at runtime, determine which module
-        to use for the task at hand.  You can determine which RA
-        modules are available to the Subversion command-line client,
-        and what protocols they claim to support, by running
-        <userinput>svn --version</userinput>:</para>
+      <para>Comme Subversion utilise les URL pour identifier les dépôts
+        à contacter, la partie de l'URL qui indique le protocole
+        (habituellement <literal>file://</literal>,
+        <literal>http://</literal>,
+        <literal>https://</literal>, <literal>svn://</literal> ou
+        <literal>svn+ssh://</literal>) est utilisée pour déterminer quel
+        module RA gère les communications. Chaque module indique la
+        liste des protocoles qu'il connaît afin que le chargeur RA
+        puisse déterminer, à l'exécution, quel module utiliser pour la
+        tâche en cours. Vous pouvez obtenir la liste des modules RA
+        disponibles pour votre client Subversion en ligne de commande,
+        ainsi que les protocoles qu'ils prennent en charge, en lançant
+        la commande <userinput>svn --version</userinput> :</para>

  $ svn --version
  svn, version 1.5.0 (r31699)
-   compiled Jun 18 2008, 09:57:36
+    compilé Jun 18 2008, 09:57:36

  Copyright (C) 2000-2008 CollabNet.
-Subversion is open source software, see http://subversion.tigris.org/
-This product includes software developed by CollabNet  
-The following repository access (RA) modules are available:
-* ra_neon : Module for accessing a repository via WebDAV protocol using  
-  - handles 'http' scheme
-  - handles 'https' scheme
-* ra_svn : Module for accessing a repository using the svn network  
-  - handles 'svn' scheme
-* ra_local : Module for accessing a repository on local disk.
-  - handles 'file' scheme
-* ra_serf : Module for accessing a repository via WebDAV protocol using  
-  - handles 'http' scheme
-  - handles 'https' scheme
+Subversion est un logiciel libre, cf http://subversion.tigris.org/
+Il inclut du logiciel développé par CollabNet (http://www.Collab.Net/).
+Les modules d'accès à un dépôt (RA) suivants sont disponibles :
+* ra_neon : Module d'accès à un dépôt via le protocole WebDAV avec Neon.
+  - gère le schéma d'URL 'http'
+  - gère le schéma d'URL 'https'
+* ra_svn : Module d'accès à un dépôt avec le protocole réseau propre de  
+  - avec authentification Cyrus SASL
+  - gère le schéma d'URL 'svn'
+* ra_local : Module d'accès à un dépôt sur un disque local.
+  - gère le schéma d'URL 'file'
+* ra_serf : Module d'accès à un dépôt via le protocole WebDAV avec serf.
+  - gère le schéma d'URL 'http'
+  - gère le schéma d'URL 'https'

-      <para>The public API exported by the RA layer contains
-        functionality necessary for sending and receiving versioned
-        data to and from the repository.  And each of the available RA
-        plug-ins is able to perform that task using a specific
-        protocol—<filename>libsvn_ra_dav</filename> speaks
-        HTTP/WebDAV (optionally using SSL encryption) with an Apache
-        HTTP Server that is running the
-        <filename>mod_dav_svn</filename> Subversion server module;
-        <filename>libsvn_ra_svn</filename> speaks a custom network
-        protocol with the <command>svnserve</command> program; and so
-        on.</para>
-      <para>For those who wish to access a Subversion repository
-        using still another protocol, that is precisely why the
-        Repository Access layer is modularized!  Developers can simply
-        write a new library that implements the RA interface on one
-        side and communicates with the repository on the other.  Your
-        new library can use existing network protocols or you can
-        invent your own.  You could use interprocess communication
-        (IPC) calls, or—let's get crazy, shall we?—you
-        could even implement an email-based protocol.  Subversion
-        supplies the APIs; you supply the creativity.</para>
+      <para>L'API publique exportée par la couche RA contient les
+        fonctionnalités nécessaires pour envoyer des données suivies en
+        versions vers le dépôt et pour en recevoir. Chacun des greffons
+        RA disponibles est capable d'effectuer ces tâches en utilisant
+        un protocole particulier :<filename>libsvn_ra_dav</filename>
+        utilise le protocole HTTP/WebDAV (avec chiffrement SSL en
+        option) pour communiquer avec un serveur HTTP Apache sur lequel
+        fonctionne le module serveur Subversion
+        <filename>mod_dav_svn</filename> ;
+        <filename>libsvn_ra_svn</filename> utilise un protocole réseau
+        propre à Subversion pour communiquer avec le programme
+        <command>svnserve</command>, et ainsi de suite.</para>
+      <para>Ceux qui désirent accéder à un dépôt Subversion en utilisant
+        un autre protocole comprendront rapidement pourquoi la couche
+        d'accès au dépôt est modulaire ! Les développeurs peuvent
+        tout simplement écrire une nouvelle bibliothèque qui implémente
+        l'interface RA d'un côté et qui communique avec le dépôt de
+        l'autre. Votre nouvelle bibliothèque peut utiliser des
+        protocoles réseaux existants ou vous pouvez en inventer un
+        nouveau. Vous pourriez ainsi utiliser les communications
+        inter-processus (IPC pour <quote>interprocess
+        communication</quote> en anglais) ou même, soyons fou,
+        implémenter un protocole basé sur l'email. Subversion apporte
+        les API, à vous d'apporter la créativité.</para>


      <!-- ===============================================================  
      <sect2 id="svn.developer.layerlib.client">
-      <title>Client Layer</title>
-      <para>On the client side, the Subversion working copy is where
-        all the action takes place.  The bulk of functionality
-        implemented by the client-side libraries exists for the sole
-        purpose of managing working copies—directories full of
-        files and other subdirectories that serve as a sort of local,
-        editable <quote>reflection</quote> of one or more repository
-        locations—and propagating changes to and from the
-        Repository Access layer.</para>
-      <para>Subversion's working copy library,
-        <filename>libsvn_wc</filename>, is directly responsible for
-        managing the data in the working copies.  To accomplish this,
-        the library stores administrative information about each
-        working copy directory within a special subdirectory.  This
-        subdirectory, named <filename>.svn</filename>, is present in
-        each working copy directory and contains various other files
-        and directories that record state and provide a private
-        workspace for administrative action.  For those familiar with
-        CVS, this <filename>.svn</filename> subdirectory is similar in
-        purpose to the <filename>CVS</filename> administrative
-        directories found in CVS working copies.  For more information
-        about the <filename>.svn</filename> administrative area, see
-        <xref linkend="svn.developer.insidewc"/> later in this
-        chapter.</para>
-      <para>The Subversion client library,
-        <filename>libsvn_client</filename>, has the broadest
-        responsibility; its job is to mingle the functionality of the
-        working copy library with that of the Repository Access layer,
-        and then to provide the highest-level API to any application
-        that wishes to perform general revision control actions.  For
-        example, the function
-        <function>svn_client_checkout()</function> takes a URL as an
-        argument.  It passes this URL to the RA layer and opens an
-        authenticated session with a particular repository.  It then
-        asks the repository for a certain tree, and sends this tree
-        into the working copy library, which then writes a full
-        working copy to disk (<filename>.svn</filename> directories
-        and all).</para>
-      <para>The client library is designed to be used by any
-        application.  While the Subversion source code includes a
-        standard command-line client, it should be very easy to write
-        any number of GUI clients on top of the client library.  New
-        GUIs (or any new client, really) for Subversion need not be
-        clunky wrappers around the included command-line
-        client—they have full access via the
-        <filename>libsvn_client</filename> API to the same functionality,
-        data, and callback mechanisms that the command-line client
-        uses.  In fact, the Subversion source code tree contains a
-        small C program (which you can find at
-        <filename>tools/examples/minimal_client.c</filename>) that
-        exemplifies how to wield the Subversion API to create a simple
-        client program.</para>
+      <title>Couche client</title>
+      <para>Côté client, la copie de travail Subversion est l'endroit où
+        tout se passe. Le gros des fonctionnalités implémentées par les
+        bibliothèques client existe dans le seul but de gérer les copies
+        de travail locales — des répertoires pleins de fichiers et
+        d'autres sous-répertoires qui sont une sorte de copie locale et
+        modifiable d'un ou plusieurs dépôts — et de propager les
+        changements vers et depuis la couche d'accès au dépôt.</para>
+      <para>La bibliothèque de Subversion pour la copie de travail,
+        <filename>libsvn_wc</filename>, est directement responsable de
+        la gestion des données dans les copies de travail. Pour ce
+        faire, la bibliothèque stocke des données d'administration à
+        propos de chaque répertoire suivi en versions dans un
+        sous-répertoire spécial. Ce sous-répertoire, nommé
+        <filename>.svn</filename>, est présent dans chaque répertoire
+        d'une copie de travail ; il contient tout un tas de
+        fichiers et de répertoires qui enregistrent l'état du répertoire
+        suivi en versions et fournit un espace privé pour les actions
+        d'administration. Pour les habitués de CVS, ce sous-répertoire
+        <filename>.svn</filename> a des objectifs similaires aux
+        répertoires administratifs CVS que l'on trouve dans les copies
+        de travail CVS. Pour plus d'informations sur la zone
+        d'administration <filename>.svn</filename>, reportez-vous à
+        <xref linkend="svn.developer.insidewc"/>  plus loin dans ce
+        chapitre.</para>
+      <para>La bibliothèque client de Subversion,
+        <filename>libsvn_client</filename>, est celle qui a le plus de
+        responsabilités : son rôle est de mélanger les
+        fonctionnalités de la bibliothèque de la copie de travail avec
+        celles de la couche d'accès au dépôt (RA) afin de fournir l'API
+        de plus haut niveau, utilisable par n'importe quelle application
+        qui voudrait effectuer des actions générales de suivi de
+        versions. Par exemple, la fonction
+        <function>svn_client_checkout()</function> prend une URL en
+        argument. Elle passe cette URL à la couche RA et ouvre une
+        session authentifiée avec le dépôt concerné. Elle demande
+        ensuite au dépôt l'arborescence requise, envoie cette
+        arborescence à la bibliothèque de la copie de travail, qui
+        écrit alors une copie de travail complète sur le disque (les
+        répertoires <filename>.svn</filename> et tout).</para>
+      <para>La bibliothèque client est conçue pour être utilisée par
+        n'importe quelle application. Alors que le code source de
+        Subversion inclut un client standard en ligne de commande, le
+        but recherché est qu'il doit être très facile d'écrire un nombre
+        quelconque de clients utilisant une interface utilisateur
+        graphique (GUI en anglais) par dessus cette bibliothèque client.
+        Les nouvelles GUI (ou les nouveaux clients en fait) pour
+        Subversion n'ont aucune raison de n'être que des sur-couches au
+        client en ligne de commande : elles ont un accès total, via
+        l'API <filename>libsvn_client</filename>, aux mêmes
+        fonctionnalités, données et autres mécanismes que le client en
+        ligne de commande utilise. En fait, le code source de Subversion
+        contient un petit programme en C (que vous pouvez trouver dans
+        <filename>tools/examples/minimal_client.c</filename>) qui montre
+        comment utiliser en pratique l'API Subversion pour créer un
***The diff for this file has been truncated for email.***

More information about the svnbook-dev mailing list