[svnbook-pt-br commit] r69 - trunk/book

codesite-noreply at google.com codesite-noreply at google.com
Fri Mar 21 14:44:32 CDT 2008


Author: camponez
Date: Fri Mar 21 12:43:34 2008
New Revision: 69

Modified:
   trunk/book/ch08-embedding-svn.xml

Log:
issue 61
Tradução da seção "Layered Library Design" e suas subseções:

  * Camada de respositório
  * Camade de Acesso ao Repositório
  * Camada Cliente


Modified: trunk/book/ch08-embedding-svn.xml
==============================================================================
--- trunk/book/ch08-embedding-svn.xml	(original)
+++ trunk/book/ch08-embedding-svn.xml	Fri Mar 21 12:43:34 2008
@@ -175,248 +175,256 @@
 	  e é, da perspectiva do usuário Subversion, a coisa do 
 	  <quote>outro lado da linha</quote></para> 
 
-      <para>The Subversion Filesystem is not a kernel-level filesystem
-        that one would install in an operating system (like the Linux
-        ext2 or NTFS), but a virtual filesystem.  Rather than storing
-        <quote>files</quote> and <quote>directories</quote> as real
-        files and directories (as in, 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 back-ends, 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
-        back-end 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 plugin which used their ultra-scalable
-        Bigtable database for its storage.</para>
-
-      <para>The filesystem API exported by libsvn_fs 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>
+      <para>O Sistema de Arquivos não é um sistema de arquivos no nível
+	  do kernel que se pode instalar em um sistema operacional (como
+	  o ext2 do Linux ou NTFS), mas um sistema de arquivos virtual.
+	  Além de guardar arquivos e diretórios (como os que você navega
+	  usando seu programa shell favorito), ele usa um dos dois 
+	  --FIXEME-- available abstract storage backends—mesmo o
+	  ambiente de banco de dados Berkeley DB, uma representação 
+	  plana de um arquivo. (Para aprender mais sobre os dois 
+	 --FIXEME-- respository back-end, veja  <xref
+	     linkend="svn.reposadmin.basics.backends"/>.) Sempre houve um
+	 considerável interesse pela comunidade de desenvolvimento 
+	 em dar a futuros releases do Subversion a habilidade de usar
+	 --FIXEME-- back-end database systems, talvez através de um
+	 mecanismo como um ODBC (Open Database Connectivity). De fato, 
+	 Google fez algo similar a isso antes de lançar o serviço Google para
+	 Host e Projetos: eles anunciaram em meados de 2006 que os membros
+	 do time Open Source teria escrito um novo plugin de sistema de arquivos 
+	 proprietário para o Subversion que seria usaria um banco de dados
+	 de Grande tabela ultra escalonável para armazenamento.</para> 
+
+     <para>A API do sistema de arquivos exportado pelo libsvn_fs contém
+	 funcionalidades que você esperaria de uma API de sistema de
+	 arquivos—você pode criar e remover arquivos e
+	 diretórios, copiar e move-los, modificar seus conteudos, 
+	 e assim por diante. Ela também tem funcionalidades que não são
+	 muito comuns, como a habilidade de adicionar, modificar, e 
+	 remover metadata (<quote>propriedades</quote>) em cada arquivo
+	 ou diretório. Além do mais, o sistema de arquivos Subversion 
+	 é um sistema versionado, o que significa que assim que você faz 
+	 mudanças na sua árvore de diretórios, Subversion lembra como sua
+	 árvore estava quando as mudanças foram feitas. E as mudanças anteriores.
+	 E as anteriores a essas. E assim por diante, todas as mudanças até
+	 durante o tempo de versionamento até (e no máximo) o primeiro momento
+	 que as coisas foram adicionadas ao sistema de arquivos.</para>
+
+     <para>Todas as modificações que você fez a sua árvore são feitas
+	 dentro do contexto de uma transação de commit do Subversion.
+	 A seguir veremos uma rotina simplificada e genérica de 
+	 modificação do seu sistema de arquivos:</para>
 
       <orderedlist>
         <listitem>
-          <para>Begin a Subversion commit transaction.</para>
+          <para>Iniciar uma transação de commit do Subversion.</para>
         </listitem>
         <listitem>
-          <para>Make your changes (adds, deletes, property
-            modifications, etc.).</para>
+          <para>Fazendo modificações (adicionar, apagar, modificações
+            de propriedades, etc.).</para>
         </listitem>
         <listitem>
-          <para>Commit your transaction.</para>
+          <para>Commit as sua transação.</para>
         </listitem>
       </orderedlist>
 
-      <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>Uma vez que você commitou sua transação, as modificações
+	  do seu sistema de arquivo é permanentemente armazenado
+	  como um histórico. Cada um desses ciclos gerá um única
+	  nova revisão da sua árvore, e cada revisão é para sempre
+	  acessível como uma imutável foto de <quote>como as coisas
+	  estavam</quote></para>
 
       <sidebar>
-        <title>The Transaction Distraction</title>
+        <title>--FIXME--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
-          libsvn_fs_base.  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 if
-          <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 like making
-          modifications to a set of files and directories which 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 Subversion transaction fails, the database will
-          look as if 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>
+	<para>A noção de transação no Subversion pode facilmente
+	    ser confundida com as transações suportadas providas
+	    pelo próprio banco de dados, especialmente pelo código 
+	    do libsvn_fs_base se aproximar ao código do baco de dados
+	    Berkeley DB. Os 2 tipos de transação existem para prover
+	    atomicidade e isolamento. Em outra palavras, transações
+	    dão a você a habilidade de fazer um conjunto de ações
+	    no modo tudo ou nada—ou todas as ações são completadas
+	    com sucesso, ou todas são tratadas como se 
+	    <emphasis>nenhuma</emphasis> tivesse ocorrido—e 
+	    de um certo modo que não há interefência nos outros
+	    processos que estão agindo nos dados.</para> 
+
+	<para>Transações de banco de dados geralmente contém
+	    pequenas operações relacionadas com a modificações
+	    de dados no banco de dados (como modificações em dados
+	    de uma linha de uma tabela). Transações do Subversion
+	    são grandes em escopo, com operações de alto nível 
+	    como fazer modificações de um conjunto de arquivos
+	    e diretórios os quais serão guardados como a próxima
+	    revisão da árvore de sistema de arquivos. Como se já
+	    não fosse confuso o suficiente, considerar o fato que
+	    o Subversion criam usa uma transação durante a criação
+	    de uma transação Subversion ( então se a criação
+	    da transação do Subversion falhar, o banco de dados
+	    irá travar como se nenhum tentativa de criação tivesse
+	    ocorrido em primeiro lugar)!</para>
+
+	<para>Felizmente para os usuários da API do sistema de arquivos,
+	    o suporte à transação provido pelo sistema de banco de dados
+	    é encondido quase totalmente de vista (como é esperado
+	    de um esquema de bibliotecas modularizadas). Apenas
+	    quando você começa a procurar dentro da implementação do 
+	    sistema de arquivos que essas coisas começam a ficar 
+	   visível (ou interessante). 
 
       </sidebar>
 
-      <para>Most of the functionality provided by the filesystem
-        interface deals with actions that occur on individual
-        filesystem paths.  That is, from outside of the filesystem, the
-        primary mechanism for describing and accessing the individual
-        revisions of files and directories comes through the use of
-        path strings like <filename>/foo/bar</filename>, just as if
-        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 descending into subdirectories a
-        downward motion.  <xref
-        linkend="svn.developer.layerlib.repos.dia-1"/> shows a typical
-        representation of a tree as exactly that.</para>
+      <para>A maioria das funcionalidades providas pela interface 
+	  dos sitema de arquivos lida com ações que ocorrem em 
+	  caminhos de sistema de arquivos individuais. Isto é,
+	  de fora do sistema de arquivos, o mecanismo primário
+	  para descrever e acessar as revisões individuais de 
+	  arquivos e diretórios que veem do uso de string de 
+	  caminhos como <filename>/foo/bar</filename>, como se
+	  você estivesse endereçando arquivos e diretórios através
+	  do seu programa shell favorito. Você adiciona novos
+	  arquivos e diretórios passando o futuro caminho 
+	  para as funções certas da API. Você requisita uma informação
+	  sobre eles pelo menos mecanismo.</para>
+
+      <para>Ao contrário de muitos sistemas de arquivos, entrentanto, 
+	  um cmainho sozinho não é informação suficiente para identificar
+	  um arquivo ou diretório no Subversion. Pense na árvore de 
+	  diretório como uma sistema de duas dimensões, onde um 
+	  nodo irmão representa um conjunto de movimentos direita-esquerda,
+	  e descendendo nos sub-diretórios em um movimento de descida.<xref
+	      linkend="svn.developer.layerlib.repos.dia-1"/> mostrando uma
+	  típica representação de uma árvore exatemente assim.</para>
 
       <figure id="svn.developer.layerlib.repos.dia-1">
-        <title>Files and directories in two dimensions</title>
+        <title>Arquivos e diretórios em duas dimensões</title>
         <graphic fileref="images/ch08dia1.png"/>
       </figure>
 
-      <para>The difference here is that the Subversion filesystem has a
-        nifty third dimension that most filesystems do not
-        have—Time!
+      <para>A diferença aqui é que o sistema de arquivos Subversion tem
+	  uma brilhante terceira dimensão que muitos sistemas de aquivo
+	  não tem—Tempo!
         <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>
+	    <para>Nós entendemos que isso é um shock para fans de ficção
+		científica que tem a impressão que tempo é na verdade
+		a <emphasis>quarta</emphasis> dimensão, e nos desculpamos
+		pelo trauma emocional causado pela nossa declaração
+		de uma teoria diferente.</para>
         </footnote>
-        In the filesystem interface, nearly every function that has a
-        <parameter>path</parameter> argument also expects a
-        <parameter>root</parameter> argument.  This
-        <structname>svn_fs_root_t</structname> argument describes
-        either a revision or a Subversion transaction (which is simply
-        a revision-in-the-making), and provides that third-dimensional
-        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>
+	Numa interface de sistema de arquivos, quase toda função que tem
+	um <parameter>caminho</parameter> como argumento também espera uma
+	<parameter>raíz</parameter> como arguemnto. Este argumento
+	<structname>svn_fs_root_t</structname> descreve tanto
+	a revisão ou a transação Subversion (que é simplesmente uma
+	--FIXME-- revision-in-the-making), e provê essa terceira 
+	dimensão necessário para entender a diferença entre 
+	<filename>/foot/bar</filename> na revisão 32, e o mesmo 
+	caminho como ele existe na revisão 98.<xref
+	    linkend="svn.developer.layerlib.repos.dia-2"/> mostra
+	o histórico de revisão como uma dimensão adicional ao 
+	universo do sistema de arquivos Subversion.
 
       <figure id="svn.developer.layerlib.repos.dia-2">
         <title>Versioning time—the third dimension!</title>
         <graphic fileref="images/ch08dia2.png"/>
       </figure>
 
-      <para>As we mentioned earlier, the libsvn_fs 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 libsvn_repos
-        comes in.</para>
-
-      <para>The Subversion repository library (libsvn_repos) sits
-        (logically speaking) atop the libsvn_fs 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>Como mencionado anteriormente, a API libsvn_fs parece 
+	  qualquer outro sistema de arquivos, exceto que ele tem 
+	  essa maravilhosa capacidade de versionamento. Ele foi desenhado
+	  para ser usável por qualquer programa interessado em 
+	  versionar arquivos. Não coincidentemente, o próprio
+	  Subversion tem interesse nessa funcionalidade. Mas
+	  enquanto a API do sistema de arquivos deveria ser 
+	  suficiente para suporte básico de arquivos e diretórios,
+	  Subversion quer mais—e é aí que entra a libsvn_repos.</para>
+
+      <para>A biblioteca de respositório Subversion (libsvn_repos)
+	  está sentada (logicamente falando) no topo da API
+	  libsvn_fs, provendo funcionalidades adicionais além 
+	  das frisadas pelo versionamenteo logico do sistema de
+	  arquivos. Não contém completamente cada uma de todas
+	  as funções de um sistema de arquivos—apenas
+	  alguns grades passos no ciclo geral da atividade 
+	  de um sistema de arquivos é contida pela interface
+	  do respositório. Algumas dessas incluem a criação
+	  e commit de transações Subversion, e as modificações
+	  de propriedades de revisão. Esses eventos particulares
+	  estão contidos na camada de repositório porque eles tem
+	  --FIXME-- hooks associados a eles. Um --FIXME-- respository
+	  hook system não está restritamente relacionado a implemnentação
+	  de um sistema de arquivos relacionados, então ele fica 
+	  contido na biblioteca de repositório</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 libsvn_repos API provides several
-        other important utilities to Subversion.  These include the
-        abilities to:</para>
+      <para>--FIXME--The hooks mechanism é uma das razões para a 
+	  abstração da separação da biblioteca de respositório
+	  do resto do código do sistema de arquivo. A API libsvn_repos
+	  provê muitas utilidades importantes para o Subversion. Isso 
+	  inclui habilidades para:</para>
 
       <itemizedlist>
         <listitem>
-          <para>create, open, destroy, and perform recovery steps on a
-            Subversion repository and the filesystem included in that
-            repository.</para>
+	    <para>criar, abrir, destruir, e recuperar passos no 
+		respositório Subversion e o sistema de arquivos 
+		incluido nesse respositório.</para>
         </listitem>
         <listitem>
-          <para>describe the differences between two filesystem
-            trees.</para>
+	    <para>descrever a diferença entre duas árovres de 
+		sistema de arquivos.</para>
         </listitem>
         <listitem>
-          <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>requisitar ao log de messagens do commit associados
+		a todas (ou algumas) das revisões nas quais um conjunto
+		de arquivos foi modificado no sistema de arquivos.</para>
         </listitem>
         <listitem>
-          <para>generate a human-readable <quote>dump</quote> of the
-            filesystem, a complete representation of the revisions in
-            the filesystem.</para>
+	    <para>gerar um <quote>dump</quote> compreensível ao ser humano
+		do sistema de arquivos, uma completa representação da
+		revisão do sitema de arquivos.</para>
         </listitem>
         <listitem>
-          <para>parse that dump format, loading the dumped revisions
-            into a different Subversion repository.</para>
+	    <para>--FIXME--parse that dump, carregando a revisão dumped
+		no repositório Subversion diferente.</para>
         </listitem>
       </itemizedlist>
 
-      <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>Como o Subversion coninua a evoluir, a biblioteca de 
+	  repositório irá crescer com a biblioteca de sistema de 
+	  arquivos para oferecer um número crescente de funcionalidades
+	  e opções de configuração.</para>
 
     </sect2>
 
     <!-- =============================================================== -->
     <sect2 id="svn.developer.layerlib.ra">
-      <title>Repository Access Layer</title>
+      <title>Camada de Acesso ao Repositório</title>
+
+      <para>Se a Camada de Repositório do Subversion está <quote>
+      do outro lado da linha</quote>, a Camada de Accesso (RA)
+      está na linha. Carregado com dados--FIXME--marshaling entre as bibliotecas
+      de clientes e o respositório, esta camada inclue o módulo 
+      carregamento de bibliotecas libsvn_ra, os módulos RA mesmos 
+      (que normalmente incluem libsvn_ra_dav, libsvn_ra_local, 
+      libsvn_ra_serf, e libsvn_ra_svn), e qualquer biblioteca
+      adicional necessária por um ou mais dos módulos RA (assim como
+      o  módulo Apache mod_dav_svn ou servidor do libsvn_ra_svn, 
+      <command>svnserv</command>).</para>  
+
+  <para>Já que Subversion usa URLs para identificar seus respositórios,
+      o porção de protocolo do esquema URL (normalmente
+      <literal>file://</literal>, <literal>http://<literal>,
+      <literal>https://</literal>, <literal>svn://</literal>,
+      ou <literal>svn+ssh://</literal>) é usado para determinar 
+      que módulo RA irá dar conta das comunicações. Cada módulo
+      possui uma lista de protocolos que sabem como <quote>falar</quote>
+      para que o carregador RA possa, em tempo de execução, determinar
+      que módulo usar para faze a tarefa. Você pode saber que 
+      módulo RA está disponível para o cliente de linha de comando
+      do Subversion e que protocolos ele suporta, apenas com o comando
+      <command>svn --version</command>:</para>
 
-      <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
-        libsvn_ra module loader library, the RA modules themselves
-        (which currently includes libsvn_ra_dav, libsvn_ra_local,
-        libsvn_ra_serf, and libsvn_ra_svn), and any additional
-        libraries needed by one or more of those RA modules (such as
-        the mod_dav_svn Apache module or libsvn_ra_svn's server,
-        <command>svnserve</command>).</para>
-
-      <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
-        <command>svn --version</command>:</para>
-     
       <screen>
 $ svn --version
 svn, version 1.4.3 (r23084)
@@ -439,123 +447,129 @@
 $
 </screen>
 
-      <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
-        plugins is able to perform that task using a specific
-        protocol—libsvn_ra_dav speaks HTTP/WebDAV (optionally
-        using SSL encryption) with an Apache HTTP Server that is
-        running the mod_dav_svn Subversion server module;
-        libsvn_ra_svn speaks a custom network protocol with the
-        <command>svnserve</command> program; and so on.</para>
-
-      <para>And 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 inter-process 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>A API pública exportada pela Camada RA contém 
+	funcionalidades necessárias por enviar e receber dados
+	versionados para e do resposítorio. Cada um dos plugins
+	RA estão disponíveis para fazer a tarefa de usar protocolos
+	específicos—libsvn_ra_dav fala HTTP/WebDAV (opcionalmente
+	usando SSL encryption) com um servidor Apache HTTP que estiver
+	rodando o módulo servidor mod_dav_svn; libsvn_ra_svn fala um
+	protocolo customizável de rede com o programa <command>svnserve</command>;
+	e assim por diante.</para>
+
+      <para>E para aqueles que desejam acessar um respositório Subversion
+	  usando outro protocolo, isso é exatamente por isso que a
+	  Camada de Acesso ao Respositório é modularazada! Desenvolvedores
+	  podem simplesmente escrever uma nova biblioteca que implementa
+	  a interface RA em um dos lados e comunicar com o respositório
+	  do outro lado. Sua biblioteca pode usar protocolos já existentes,
+	  ou você pode inventar o seu próprio. Você pode usar processos
+	  de comunicação (IPC), ou—vamos ficar loucos, podemos?—
+	  você pode até implementar um protocolo baseado em email. 
+	  Subversion provê a API; você vem com a criatividade.</para>
 
     </sect2>
 
     <!-- =============================================================== -->
     <sect2 id="svn.developer.layerlib.client">
-      <title>Client Layer</title>
+      <title>Camada Cliente</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 which 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, libsvn_wc, 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
-        which 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
+      <para>No lado do cliente, a cópia de trabalho do Subversion é 
+	  onde todas as ações tomam lugar. O conjunto de funcionalidades
+	  implementadas pelas bibliotecas cliente existem pelo único
+	  propósito de gerenciar as cópias de trabalho—
+	  diretórios cheios de arquivos e outros sub-diretórios
+	  que servem como um tipo de local, editáveis <quote>reflexos</quote>
+	  de um ou mais locais de repositórios—e propagando mudanças
+	  para e da Camada de Acesso ao Respositório.</para>
+
+      <para>Cópia de trabalho Subversion, libsvn_wc, é diretamente
+	  responsável por gerenciar os dados nas cópias de trablho.
+	  Para conseguir isso, a biblioteca guarda informações 
+	  administrativas sobre cada diretório da cópia de trabalho
+	  com em um sub-diretório especial. Este sub-diretório, chama-se
+	  <filename>.svn</filename>, está presente em cada cópia de 
+	  trabalho e contém vários outros arquivos e diretórios
+	  com o estado das informações e provê um espaço privado 
+	  para ações de administração. Para os familiares com o CVS, 
+	  este sub-diretório <filename>.svn</filename> é similar em
+	  objetivo ao diretório administrativo <filenam>CVS</filename>
+	  encontrado nas cópias de trabalho CVS. Para mais informação
+	  sobre a área administrativa <filename>.svn</filename>, 
+	  veja<xref
         linkend="svn.developer.insidewc"/>in this chapter.</para>
 
-      <para>The Subversion client library, libsvn_client, 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 libsvn_client API
-        to 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 can be found at
-        <filename>tools/examples/minimal_client.c</filename> that
-        exemplifies how to wield the Subversion API to create a simple
-        client program</para>
-
+      <para>A biblioteca do cliente Subversion, libsvn_client, 
+	  tem uma responsabilidade mais abrangente. o seu trabalho
+	  é unir as funcionalidades da biblioteca da cópia de trabalho
+	  com as da Camada de Acesso ao Respositório, e então prover uma
+	  API de alto nível para qualquer aplicação que desejar fazer
+	  controle geral de ações de revisão. Por exemplo, a função
+	  <function>svn_client_checkout()</function> pega um URL 
+	  como argumento. E passa a URL para a camada de RA e abre 
+	  uma sessão com um repositório. Ele então pede ao respositório
+	  pora uma certa árvore, e envia está árvore para a biblioteca
+	  da cópia de trabalho, que então esrever toda a cópia de trabalho
+	  no disco (o diretório <filename>.svn</filename> e tudo mais). 
+
+	  <para>A biblioteca cliente foi desenhada para ser usada
+	      por qualquer aplicacação. Enquanto o código fonte
+	      inclui um cliente de linha de comando padrão, deveria
+	      ser muito fácil escrever qualquer número de clientes
+	      gráficos no topo dessa biblioteca cliente. Novas 
+	      interfaces gráficas (ou qualquer novo cliente) para
+	      não precisa ser algo em volta do cliente de linha 
+	      de comando&mdahs;eles tem total acesso via
+	      API libsvn_client às mesmas funcionalidades, dados
+	      e mecanimos de resposta que o cliente de linha
+	      de comando usa. De fato, a ávore do código fonte
+	      do Subversion contém um pequeno programa em C (
+	      que pode ser encontrado em 
+	      <filename>tools/examples/minimal_client.c</filename>
+	      que exemplifica como usar a API do Subversion para
+	      criar um programa cliente simples</para>
+	      
       <sidebar>
-        <title>Binding Directly—A Word About Correctness</title>
+        <title>Fazendo binding diretamente—Uma palavra sobre o que é certo</title>
 
-        <para>Why should your GUI program bind directly with a
-          libsvn_client instead of acting as a wrapper around a
-          command-line program?  Besides simply being more efficient,
-          it can be more correct as well.  A
-          command-line program (like the one supplied with Subversion)
-          that binds to the client library needs to effectively
-          translate feedback and requested data bits from C types to
-          some form of human-readable output.  This type of
-          translation can be lossy.  That is, the program may not
-          display all of the information harvested from the API, or
-          may combine bits of information for compact representation.</para>
-
-        <para>If you wrap such a command-line program with yet another
-          program, the second program has access only to
-          already-interpreted (and as we mentioned, likely incomplete)
-          information, which it must <emphasis>again</emphasis>
-          translate into <emphasis>its</emphasis> representation
-          format.  With each layer of wrapping, the integrity of the
-          original data is potentially tainted more and more, much
-          like the result of making a copy of a copy (of a copy …)
-          of a favorite audio or video cassette.</para>
- 
-        <para>But the most compelling argument for binding directly to
-          the APIs instead of wrapping other programs is that the
-          Subversion project makes compatibility promises regarding
-          its APIs.  Across minor versions of those APIs (such as
-          between 1.3 and 1.4), no function's prototype will change.
-          In other words, you aren't forced to update your program's
-          source code simply because you've upgraded to a new version
-          of Subversion.  Certain functions might be deprecated, but
-          they still work, and this gives you a buffer of time to
-          eventually embrace the newer APIs.  These kinds of
-          compatibility promises do not exist for Subversion
-          command-line program output, which is subject to change from
-          release to release.</para>
+	<para>Porque seu programa de interface deveria
+	    fazer o bind diretamente com o libsvn_client ao 
+	    invés ser um programa em volta do cliente em linha 
+	    de comando? Além do fato de ser mais eficiente,
+	    é mais correto também. Um programa de linha de comando
+	    (como o que o Subversion fornece) que faz o bind
+	    para a biblioteca do cliente precisa traduzir
+	    eficientemente as respostas e requisões de bits
+	    de dados de tipos C para tipo em forma entendidas
+	    pelo ser humano. Esse tipo de tradução pode ser
+	    despendioso. Sendo assim, o programa pode não
+	    mostrar todas as informações colhidas pela API, ou
+	    pode combinar pedaços de informações para uma
+	    apresentação compacta.</para>
+
+	<para>Se você puser o programa de linha de comando com outro 
+	    programa, o segundo programa terá acesso apenas 
+	    às informações já interpretadas (e como mencionado, 
+	    possivelemente incompletas), o que é <emphasis>novamente</emphasis>
+	    uma tradução do <emphasis>seu próprio</emphasis> formato
+	    de apresentação. Com cada camada de encapsulamento, 
+	    a integridade do dado original é um pouco mudado mais e mais,
+	    parecido com o resultado de fazer uma copia da copia (da cópia …)
+	    do seu audio ou vídeo cassete favorito.</para>
+
+	<para>Mas o argumento mais contudente para fazer o bind 
+	    diretamente para as APIs ao invés de usar outrs programas
+	    é que o projeto Subversion fez promessas de compatibilidades
+	    entre suas APIs. Através de versões menores dessas APIs
+	    (como entre 1.3 e 1.4), nenhum protótipo de função irá mudar.
+	    Em outras palavras, você não será forçado a atualizar
+	    seu código fonte semplesmente porque você atualizou para
+	    uma nova versão do Subversion. Algumas funções podem ficar
+	    defazadas, msa ainda assim irão funcionar, e isso te dá um
+	    intervaldo de tempo para começar a usar as novas APIs.
+	    Esse tipo de compatibilidade não é prometido para as 
+	    mensagens de saída do cliente de linha de comando do 
+	   Subversion, o que é objeto de mudança de versão para versão. 
 
       </sidebar>
 




More information about the svn-pt_br mailing list