path: root/common/cvs-it.xml

<!-- $Id: -->

<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.4//EN"
 "http://www.oasis-open.org/docbook/xml/4.4/docbookx.dtd" [

 <!ENTITY BOILERPLATE "This header makes editing XML easier"  >
 <!ENTITY FC          "Fedora Core"                           >
 <!ENTITY RH          "Red Hat"                               >

]>

<chapter id="ch-cvs">
  <title>CVS</title>
  <para>
    Il Concurrent Versions System (<application>CVS</application>)
    fornisce un framework dove molteplici utenti possono editare gli stessi files.
    Come puoi immaginare, se un gruppo di utenti edita i files in una singola
    directory, il caos regnerà. Usando <application>CVS</application>,
    comunque, un gruppo di persone può lavorare con sicurezza sullo stesso gruppo di files.
    <application>CVS</application> mantiene la copia master dei files,
    e registra chi ha cambiato cosa e quando in un depositorio centrale. Se
    insorgessero dei conflitti, <application>CVS</application> te lo farà sapere.
    <application>CVS</application> è spesso usato affinchè i programmatori possano
    condividere codice, ma funziona bene anche per la documentazione.
  </para>
  <indexterm>
    <primary>cvs</primary>
  </indexterm>
  <section id="sn-cvs-overview">
    <title>Come funziona CVS</title>
    <indexterm>
      <primary>cvs</primary>
      <secondary>come funziona</secondary>
    </indexterm>
    <indexterm>
      <primary>cvs</primary>
      <secondary>descrizione</secondary>
    </indexterm>
    <para>
      In molti casi, ogni gruppo di files che costituisce un pacchetto o un progetto
      è immagazzinato come <firstterm>modulo</firstterm> sul CVS server.
    </para>

    <para>
      Quando lavori con i files dal <application>CVS</application>, dovrai eseguire il
      <firstterm>checkout</firstterm> di una copia del modulo sul
      file system locale. Dopo aver modificato uno o più files, dovrai inviarli con un
      <firstterm>commit</firstterm> al repositorio centrale
      <application>CVS</application> server.
    </para>

    <para>
      Con <application>CVS</application> puoi editare un file senza
      prima ottenere il permesso o il locking del file. La parte
      <wordasword>concurrent</wordasword> del nome
      <application>CVS</application> viene dalla sua capacità di
      permettere diverse differenti persone di editare differenti parti dello stesso
      file. Siccome nessuno dei cambiamenti si sovrappone,
      <application>CVS</application> può registrare correttamente i loro cambiamenti.
      In caso di cambiamenti duplicati, questi sono marcati chiaramente nei files
      e gli autori devono risolvere il problema da soli.
    </para>

    <para>
      Quando commetti i cambiamenti, solo i cambiamenti ai files che il server sa
      sono commessi. In altre parole, se crei un file nel checkout locale
      di un modulo, il nuovo file non è automaticamente
      inviato al server. Devi prima fare un <firstterm>add</firstterm> del
      file al repositorio quindi eseguire il commit. Se rimuovi un file
      dal tuo checkout locale di un modulo, dovrai specificare che vuoi
      rimuoverlo dal repositorio sul CVS server e quindi
      eseguire il commit della rimozione del file.
    </para>

    <para>
      I comandi specifici per eseguire queste operazioni sono discussi in
      <xref linkend="sn-cvs-cvscommands"></xref>.
    </para>

    <para>
      Se qualcuno ha modificato il file nel tempo fra intercorso fra l'ultima volta
      che l'hai catturato dal CVS e quando hai provato ad eseguire il commit di un cambiamento,
      <application>CVS</application> proverà ad incollare i cambiamenti alla
      copia master sul <application>CVS</application> server. Se
      il contenuto che hai cambiato è in una locazione differente nel file
      rispetto la contenuto cambiato da qualcun'altro, l'azione del commit
      andrà avanti senza alcun <firstterm>conflitto</firstterm>.
      Se qualcuno modifica lo stesso contenuto che hai già cambiato tu
      e provi a fare un commit, vedrai un messaggio che è avvenuto
      il conflitto su un file. Così, dovrai fare l'
      <firstterm>update</firstterm> dei tuoi files di frequente. E' una buona pratica
      aggiornarli prima di iniziare a modificarli.
      Fa riferimento a <xref linkend="sn-cvs-cvscommands-conflicts"></xref> per
      le istruzioni su come risolvere i conflitti.
    </para>
  </section>
  <section id="sn-cvs-preparation">
    <title>Preparazione all'uso di CVS</title>
    <indexterm>
      <primary>cvs</primary>
      <secondary>preparazione all'uso</secondary>
    </indexterm>
    <para>
      Prima di usare <application>CVS</application>, hai bisogno di stabilire
      un account con il <application>CVS</application> server. Dopo
      aver ottenuto un account, non dovrai più fare nuovamente queste
      cose.
    </para>

    <section id="sn-cvs-rpm-check">
      <title>E' CVS installato sul tuo sitema</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>installazione RPM</secondary>
      </indexterm>
      <para>
        Devi aver installato il pacchetto <application>CVS</application>
        <abbrev>RPM</abbrev>. Verifica la sua presenza
        digitando il comando:
      </para>
<screen><prompt>$ </prompt><command>rpm -q cvs</command></screen>
      <para>
        e vedi un output simile a
        <computeroutput>cvs-1.11.19-1</computeroutput>, allora il pacchetto
        è installato. Un messaggio simile a <computeroutput>package cvs
        is not installed</computeroutput> vuol dire che devi installare il
        pacchetto <application>cvs</application> prima di continuare. Se
        non sai come fare, consulta il tuo amministratore di sistema
        che potrà installarlo per te.
      </para>
    </section>

    <section id="sn-cvs-generate-keys">
      <title>Generazione dell chiavi SSH</title>
      <indexterm>
        <primary>OpenSSH</primary>
        <secondary>chiavi di autorizzazione</secondary>
      </indexterm>
      <para>
        Il <application>CVS</application> server usa chiavi
        <application>SSH</application> Protocol 2 per autenticare
        gli utenti. Così, devi generare un paio di chiavi prima di richiedere
        un account <application>CVS</application>. Se hai già
        una chiave <application>SSH</application> <abbrev>DSA</abbrev>,
        puoi saltare questo passaggio.
      </para>
      <tip>
        <title>Tip</title>
        <para>
          Hai già una chiave <abbrev>DSA</abbrev> se hai il
          file <filename>~/.ssh/id_dsa.pub</filename> sul sistema.
        </para>
        <para>
          Se la tua chiave <abbrev>DSA</abbrev> esistente non richiede una
          <wordasword>passphrase</wordasword>, sei fortemente incoraggiato a
          generarne una che richieda una passphrase.
        </para>
      </tip>
      <para>
        Usa i seguenti passi per generare una chiave <abbrev>DSA</abbrev>
        usata da <application>SSH</application> Protocol 2. E'
	necessaria per un account <application>CVS</application> su
        <computeroutput>cvs.fedoraproject.org</computeroutput>.
      </para>
      <orderedlist>
        <indexterm>
          <primary>OpenSSH</primary>
          <secondary><command>ssh-keygen</command>
          </secondary>
        </indexterm>
        <indexterm>
          <primary><command>ssh-keygen</command>
          </primary>
        </indexterm>
        <listitem>
          <para>
            Per generare una chiave
            <acronym>DSA</acronym>
            per funzionare con il protocollo versione 2.0, allo shell prompt,
            digita il comando:
          </para>
<screen><prompt>$ </prompt><command>ssh-keygen -t dsa</command></screen>
          <para>
            Accetta la posizione predefinita per la locazione del file
            <filename>~/.ssh/id_dsa</filename>. Sei fortemente incoraggiato all'urgenza
            di definire ed usare una <firstterm>passphrase</firstterm> per
            aumentare la sicurezza della tua chiave. Immetti una passphrase
            differente dalla password del tuo password e confermala
            reinserendola nuovamente.
          </para>
        </listitem>
        <listitem>
          <para>
            Copia la nuova chiave nel file corretto digitando i
            seguenti comandi allo shell prompt.
          </para>
<screen><prompt>$ </prompt><command>cat ~/.ssh/id_dsa.pub&gt;&gt;~/.ssh/authorized_keys</command></screen>
          <note>
            <para>
              Controlla con attenzione questo comando prima di premere il tasto
              <guibutton>ENTER</guibutton>.
              Se <filename>~/.ssh/authorized_keys</filename>
              esiste già, i contenuti di
              <filename>~/.ssh/id_dsa.pub</filename> verranno appesi alla
              fine del file <filename>~/.ssh/authorized_keys</filename>.
            </para>
          </note>
        </listitem>
        <listitem>
          <para>
            Cambia i permessi della tua directory <filename>~/.ssh</filename>
            e delle tue chiavi con i comandi:
          </para>
<screen><prompt>$ </prompt><command>chmod 700 ~/.ssh</command>
<prompt>$ </prompt><command>chmod 644 ~/.ssh/authorized_keys</command></screen>
        </listitem>
      </orderedlist>
      <tip>
        <title>Tip</title>
        <para>
          Puoi far si che il sistema ricordi la passphrase così da
          non doverla digitare ogni volta che accedi al
          <application>CVS</application> server. Fa riferimento alla
          documentazione del programma <application>ssh-add</application>.
        </para>
      </tip>
    </section>
  </section>
  <section id="sn-cvs-config">
    <title>Configurazione per l'accesso CVS</title>
    <indexterm>
      <primary>cvs</primary>
      <secondary>configurazione per l'accesso</secondary>
    </indexterm>
    <indexterm>
      <primary>cvs</primary>
      <secondary>CVSROOT</secondary>
    </indexterm>
    <indexterm>
      <primary>cvs</primary>
      <secondary>CVS_RSH</secondary>
    </indexterm>
    <indexterm>
      <primary>CVSROOT</primary>
    </indexterm>
    <indexterm>
      <primary>CVS_RSH</primary>
    </indexterm>
    <indexterm>
      <primary>cvs</primary>
      <secondary><filename>.cvsrc</filename>
      </secondary>
    </indexterm>
    <indexterm>
      <primary><filename>.cvsrc</filename>
      </primary>
    </indexterm>
    <section id="sn-cvs-config-cvsrc">
      <title>Evitare digitazioni ripetitive</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>evitare digitazioni ripetitive</secondary>
      </indexterm>
      <para>
        Molti comandi <application>CVS</application> hanno bisogno di
        certe opzioni per operare in modo consistente. Invece di
        digitarle ogni volta che il comando è usato, puoi salvare gli
        switches in un file che <application>CVS</application> leggerà
        prima di eseguire la linea di comando.
      </para>

      <para>
        Crea un file chiamato <filename>~/.cvsrc</filename> nella tua home
        directory. Dovrà contenere i seguenti comandi, uno per
        riga:
<screen><computeroutput>cvs -z3
diff -uNp
rdiff -uNp
update -dP</computeroutput></screen>
      </para>
    </section>

    <section id="sn-cvs-config-anon">
      <title>Configurare un accesso CVS Read-Only</title>
      <indexterm>
        <primary>cvs</primary>
	<secondary>configurare un accesso Read-Only</secondary>
      </indexterm>
      <indexterm>
        <primary>cvs</primary>
        <secondary>accesso anonimo</secondary>
      </indexterm>
      <para>
        Se il tuo obbiettivo è scaricare i vari documenti &FC; e
        renderizzarli sul tuo sistema, hai bisogno solo di un accesso read-only
        al depositorio <application>CVS</application>. Segui le
        istruzioni in questa sezione quindi salta direttamente a
        <xref linkend="sn-cvs-cvscommands-co"/>.
      </para>

      <para>
        Cambia directories dove vuoi che vengano collocati i files dal
        <application>CVS</application>, ed esegui i
	seguenti comandi:
      </para>
<screen><prompt>$ </prompt><command>export CVSROOT=:pserver:anonymous@cvs.fedoraproject.org:/cvs/docs</command>
<prompt>$ </prompt><command>cvs login</command>
<prompt>$ </prompt><command>cvs checkout docs-common</command> <replaceable>module-name</replaceable>
<prompt>$ </prompt><command>cvs checkout</command> <replaceable>module-name</replaceable>
<prompt>$ </prompt><command>cd</command> <replaceable>module-name</replaceable></screen>
      <para>
        Una volta eseguito il check-out del modulo, non importa quale
        <envar>CVSROOT</envar>
        è impostata perchè è registrata nel file
        <filename>CVS/Root</filename> per ogni directory nel tuo depositorio
	locale. Finchè la tua directory di lavoro ha una directory
        <filename>CVS/</filename>, il programma
        <application>CVS</application> localizzerà automaticamente
        il repositorio &FC;.
      </para>
    </section>

    <section id="sn-cvs-config-author">
      <title>Configurazione accesso CVS Read/Write</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>configurazione accesso read/write</secondary>
      </indexterm>
      <indexterm>
        <primary>cvs</primary>
        <secondary>configurare gli accessi per gli autori</secondary>
      </indexterm>
      <para>
        Per scrivere un nuovo documento o modificarne uno esistente, devi
        ottenere  pieno accesso read/write al repositorio
	<application>CVS</application> della Documentazione di  &FC;.
	Per i dettagli completi su questo procedimento, fa riferimento al
	sito web
        <ulink url="http://fedoraproject.org/wiki/DocsProject/NewWriters"><filename>http://fedoraproject.org/wiki/DocsProject/NewWriters</filename>
        </ulink>. Segue un sommario:
      </para>

      <itemizedlist>
        <listitem>
          <para>
            Sottoscriviti alla
            <ulink url="https://listman.redhat.com/mailman/listinfo/fedora-docs-list"><filename>fedora-docs-list</filename>
            </ulink>, che è il forum principale del progetto.
          </para>
        </listitem>
        <listitem>
          <para>
            Genera una chiave GNU Privacy Guard (<abbrev>GPG</abbrev>) per
            identificarti nel progetto.
          </para>
        </listitem>
        <listitem>
          <para>
            Registrati per un account in
            <ulink url="http://bugzilla.redhat.com/"><filename>Bugzilla</filename>
            </ulink>, se non ne hai già uno.
            <filename>Bugzilla</filename> è il modo con cui teniamo traccia degli errori,
            cambiamenti e progetti.
          </para>
        </listitem>
        <listitem>
          <para>
            Posta un
            <ulink url="http://fedoraproject.org/wiki/DocsProject_2fSelfIntroduction">auto
            introduzione</ulink> alla lista.
          </para>
        </listitem>
      </itemizedlist>

      <para>
        Dopo che la tua
        <ulink url="http://fedoraproject.org/wiki/DocsProject_2fSelfIntroduction">auto
        introduzione</ulink> è stata approvata il tuo accesso
        <application>CVS</application> verrà garantito.
      </para>

      <para>
        Ogni autore, e questo ti include una volta che la tua auto introduzione
        è stat ricevuta, ha un unico
        <envar>$CVSROOT</envar>
        per accedere al repositorio <application>CVS</application>:
      </para>
<screen><prompt>$ </prompt><command>export CVSROOT=:ext:</command><replaceable>yourname</replaceable><command>@cvs.fedoraproject.org:/cvs/docs</command>
<prompt>$ </prompt><command>export CVS_RSH=/usr/bin/ssh</command></screen>
      <para>
        Con le variabili ambiente
        <envar>$CVSROOT</envar>
        e
        <envar>$CVS_RSH</envar>
        impostate, puoi accedere al repositorio:
      </para>
<screen><prompt>$ </prompt><command>cvs co -c</command></screen>
      <para>
        Ti verrà richiesta la passphrase per la tua chiave
        <application>SSH</application>. Premi
        <guibutton>ENTER</guibutton>
        e riceverai la lista dei moduli presenti nel
        repositorio.
      </para>
    </section>
  </section>
  <section id="sn-cvs-cvscommands">
    <title>Comandi CVS di base</title>
    <indexterm>
      <primary>cvs</primary>
      <secondary>comandi</secondary>
    </indexterm>
    <para>
      Dopo aver configurato il sistema per funzionare con CVS, esegui il checkout
      dei moduli su cui lavorerai.
    </para>
    <tip>
      <title>Tip</title>
      <para>
        Per vedere se hai impostato correttamente la variabile
        <envar>$CVSROOT</envar>,
        o lo switch della linea di comando <option>-m </option>
        <replaceable>repository</replaceable>, vedi
        se hai una subdirectory <filename>CVS/</filename> nella tua
        directory di lavoro.
      </para>
      <para>
        Se hai una directory <filename>CVS/</filename>,
        <application>CVS</application> ignorerà qualsiasi
        <envar>$CVSROOT</envar>
        o switch della linea di comando <option>-m</option>.
      </para>
    </tip>
    <section id="sn-cvs-cvscommands-co">
      <title>Fare il checkout dei moduli</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>eseguire il checkout dei moduli</secondary>
      </indexterm>
      <para>
        Devi fare il checkout di un modulo una volta. Dopo che la copia del
        modulo è sul tuo sistema, è sul tuo sistema.
      </para>

      <para>
        Per fare il checkout di un modulo, usa il seguente comando:
      </para>
<screen><prompt>$ </prompt><command>cvs co</command>  <replaceable>&lt;module-name&gt;</replaceable></screen>
      <para>
        Per esempio, per fare il checkout del modulo
        <computeroutput>example-tutorial</computeroutput>, cambia
        la tua directory di lavoro, ed esegui il seguente comando:
      </para>
<screen><prompt>$ </prompt><command>cvs co example-tutorial</command></screen>
      <para>
        Verrà creata una directory chiamata <filename>example-tutorial/</filename>
        nella directory corrente.
      </para>

      <para>
        Se non viene specificato un nome del ramo durante il checking del modulo,
        verrà riferito al <firstterm>HEAD</firstterm> del modulo
        <application>CVS</application>.
      </para>

      <section id="sn-cvs-cvscommands-co-branch">
        <title>Fare il checkout dei rami dei moduli</title>
        <indexterm>
          <primary>cvs</primary>
          <secondary>eseguire il checkout dei moduli</secondary>
          <tertiary>eseguire il checkout dei rami</tertiary>
        </indexterm>
        <para>
          Pensa ad un ramo <application>CVS</application> come una versione
          dei files per una particolare versione del pacchetto o manuale.
        </para>

        <para>
          Per fare il checkout di un ramo di un modulo, usa il seguente comando:
        </para>
<screen><prompt>$ </prompt><command>cvs co</command> <option>-d</option>  <replaceable>&lt;directory&gt;</replaceable> <option>-r</option>  <replaceable>&lt;branchname&gt;</replaceable> <replaceable>&lt;module-name&gt;</replaceable></screen>
        <para>
          Una directory chiamata <replaceable>&lt;directory&gt;</replaceable>
          viene creata, ed i files per il ramo
          <replaceable>&lt;branchname&gt;</replaceable> del modulo
          <replaceable>&lt;module-name&gt;</replaceable> sono
          copiati nella directory.
        </para>

        <para>
          Per esempio, per fare il checkout di un ramo denominato BRANCH-VERSION-1.2
          dal modulo <computeroutput>mymodule</computeroutput>, usa
          il comando:
        </para>
<screen><prompt>$ </prompt><command>cvs co -d mymodule-1.2 -r BRANCH-VERSION-1.2 mymodule</command></screen>
        <para>
          Verrà eseguito il checkout del ramo BRANCH-VERSION-1.2 del modulo nella
          directory <filename>mymodule-1.2</filename> sul tuo
          sistema.
        </para>

        <para>
          Per determinare quale ramo e tags esiste per un file, usa il
          comando:
        </para>
<screen><prompt>$ </prompt><command>cvs status</command> <option>-v</option> <replaceable>&lt;filename&gt;</replaceable></screen>
        <para>
          Per esempio, lo status del file
          <filename>foo.sgml</filename> è il seguente:
        </para>
<screen>
<computeroutput>
===================================================================
File: foo.sgml    Status: Up-to-date

   Working revision:    1.47
   Repository revision: 1.47    /cvs/docs/custom-guide/rhl-cg-en.sgml,v
   Sticky Tag:          (none)
   Sticky Date:         (none)
   Sticky Options:      (none)

   Existing Tags:
        BRANCH-VERSION-1.2              (branch: 1.25.2)
</computeroutput>
</screen>
        <para>
          Solo dei tags marcati come rami nella seconda colonna sotto la
	  sezione <computeroutput>Existing Tags</computeroutput> si può eseguire
          il checkout come ramo.
        </para>
      </section>
    </section>

    <section id="sn-cvs-cvscommands-up">
      <title>Aggiornare i files</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>aggiornare i files</secondary>
      </indexterm>
      <para>
        Per ricevere l'ultima versione di un file in un modulo, cambia
        nella directory che contiene i files per il modulo ed
        esegui il comando:
      </para>
<screen><command>cvs update</command></screen>
      <para>
        Le ultime versioni di tutti i files ne modulo sono
        scaricate nella tua copia locale. Se noti un conflitto di file,
        fa riferimento a <xref linkend="sn-cvs-cvscommands-conflicts"></xref>.
      </para>
    </section>

    <section id="sn-cvs-cvscommands-commit">
      <title>Eseguire il commit dei files</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>eseguire il commit dei files</secondary>
      </indexterm>
      <para>
        Dopo aver modificato i files nella tua versione locale di un modulo, esegui il commit
        per salvare i cambiamenti sul <application>CVS</application>
        server:
      </para>
<screen><prompt>$ </prompt><command>cvs commit</command> <option>-m</option> &quot;<replaceable>alcuni messaggi di log</replaceable>&quot; <replaceable>filename</replaceable></screen>
      <note>
        <para>
          Se preferisci scrivere il tuo messaggio di log con il tuo editor
          di testo preferito, come definito dalla variabile ambiente $VISUAL o
	  $EDITOR, ometti semplicemente la <userinput>-m &quot;alcuni
          messaggi di log&quot;</userinput>. Il buffer conterrà già
          alcuni commenti che descrivono i cambiamenti; non è necessario cancellarli
          quando inserirai il tuo testo.
        </para>
      </note>

      <para>
        I messaggi di log dovranno essere più descrittivi possibile affinchè
        chiunque altro lavori al modulo capisca cos'è stato cambiato.
        Usare un messaggio di log tipo <userinput>aggiornati alcuni
        files</userinput> non descrive accuratamente cosa è stato cambiato
        e non ti aiuterà in futuro. Se hai corretto un
        errore, fa riferimento a <application>Bugzilla</application>.
      </para>

      <para>
        Il <replaceable>&lt;filename&gt;</replaceable> può essere un
        filename, una serie di filenames separati da spazi, o un gruppo
        di filenames specificati usando una wildcards tipo
        <filename>*.png</filename> o <filename>foo-*.sgml</filename>.
      </para>

      <para>
        Se nessun filename o gruppo di filenames è specificato nel
	comando <command>commit</command>, tutti i cambiamenti eccezionali
	di qualsiasi tipo sono commessi al server. Il comando è recursivo
        ed includerà i cambiamenti in ogni subdirectories del modulo.
        Usa cautela quando esegui il comando <command>commit</command>
	senza nessun filenames poichè potresti non ricordare esattamente
        quali files sono cambiano.
      </para>

      <para>
        Se noti un conflitto di file, fa riferimento a
        <xref linkend="sn-cvs-cvscommands-conflicts"></xref>.
      </para>
    </section>

    <section id="sn-cvs-cvscommands-add">
      <title>Aggiungere files</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>aggiungere files</secondary>
      </indexterm>
      <para>
        Per aggiungere un file ad un modulo, crea il file sulla tua copia locale
        quindi esegui il seguente comando:
      </para>
<screen><prompt>$ </prompt><command>cvs add</command>  <replaceable>file-to-add</replaceable></screen>
      <para>
        Dopo aver aggiunto il file, devi eseguire un <command>commit</command>
        dell'<command>add</command> per copiarlo sul server:
      </para>
<screen><prompt>$ </prompt><command>cvs commit</command> <option>-m</option> &quot;<replaceable>qualche messaggio di log</replaceable>&quot; <replaceable>file-da-aggiungere</replaceable></screen>
    </section>

    <section id="sn-cvs-cvscommands-admin">
      <title>Amministrare i files binari</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>files binari</secondary>
      </indexterm>
      <para>
        I files comunemente più archiviati sono di semplice testo ma
        qualche volta sono archiviati anche files binari. Il programma
        <application>cvs</application> determina le estensioni dei
	files più comuni tipo <filename>.png</filename> o
        <filename>.jpg</filename>, così di solito <application>cvs</application>
        &quot;fa la cosa giusta&quot;.
      </para>

      <para>
        Quando si esegue il checkout della copia di un file del repositorio,
        il <application>cvs</application> lo scansisce per parole chiavi speciali,
        tipo &quot;<computeroutput>$id:$</computeroutput>&quot; e
        sostituisce le stringhe con un valore generato, tipo il numero di versione
	del file.
      </para>

      <para>
        Questa sostituzione di keyword di solito corrompe i files binari, così
        deve essere disattivata se <application>cvs</application> non
        riconosce i tuoi files come binari. Per marcare il tuo file come
        binario, e quindi disattivare l'espansione delle keyword, usa
        il comando:
      </para>
<screen width="60"><prompt>$ </prompt><command>cvs</command> <option>admin</option> <option>-kk</option> <replaceable>filename</replaceable></screen>
      <para>
        Nota che il file deve già essere nel repositorio
        <abbrev>CVS</abbrev> prima di poter usare il comando
        <option>admin</option>. Questo è OK, fino a che
        l'espansione delle keyword è fatta appena il file viene sottoposto a checkout e
        copiato nella directory locale, non quando il file viene commesso al
        repositorio.
      </para>
      <tip>
        <title>Ripristinare un file binario</title>
        <para>
          Se esegui il check di un file binario nel repositorio e trovi
          che sia corrotto durante il checkout, non aver paura. Usa semplicemente
          il comando <option>admin</option> come descritto sopra, cancella
          la tua copia locale del file, ed esegui nuovamente il checkout.
        </para>
      </tip>
    </section>

    <section id="sn-cvs-cvscommands-rm">
      <title>Rimuovere i files</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>rimuovere i files</secondary>
      </indexterm>
      <para>
        Se un file non è più necessario nel modulo, usa il
        comando <command>remove</command> per rimuoverlo dalla tua copia
        locale poi esegui il <command>commit</command> per rimuoverlo dal
        server. Anche se il file è rimosso dalla versione corrente del
        modulo, una copia archiviata è ancora lasciata sul server e può
        essere recuperato in qualsiasi momento con il comando <command>add</command>.
      </para>
<screen><prompt>$ </prompt><command>cvs rm -f</command>  <replaceable>file-to-remove</replaceable></screen>
      <para>
        Dopo la rimozione del file, devi eseguire il <command>commit</command> della
        rimozione:
      </para>
<screen><prompt>$ </prompt><command>cvs commit</command> <option>-m</option>&quot;<replaceable>qualche messaggio di log</replaceable>&quot; <replaceable>file-da-rimuovere</replaceable></screen>
      <para>
        Non puoi usare wildcards nel eseguire il <command>commit</command>
        per identificare files rimossi. Essi devono essere specificati con il nome
	di file esatto.
      </para>

      <para>
        Se necessiti di rinominare un file, è meglio rinominarlo sul
        <application>CVS</application> server affinchè la storia del
        file possa essere preservata. Se hai bisogno di rinominare un file, manda un
        email a
        <ulink url="mailto:cvsdocs-administrator@fedoraproject.org"><filename>cvsdocs-administrator@fedoraproject.org</filename>
        </ulink> chiedendo di voler rinominare un file.
      </para>
    </section>

    <section id="sn-cvs-cvscommands-status">
      <title>Status dei files</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>status dei files</secondary>
      </indexterm>
      <para>
        Qualche volta è necessario vedere lo
        <firstterm>status</firstterm> di un file in un
        modulo <application>CVS</application>. Per vedere lo status di un
        file, usa il comando:
      </para>
<screen><prompt>$ </prompt><command>cvs status</command>  <replaceable>filename</replaceable></screen>
      <para>
        Il rapporto dello status di un file nel repositorio è come segue:
      </para>

      <variablelist>
        <varlistentry>
          <term><computeroutput>Up-to-date</computeroutput></term>
          <listitem>
            <para>
              La tua revisione del file è identica all'ultima
              revisione sul <application>CVS</application> server.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>Locally Modified</computeroutput></term>
          <listitem>
            <para>
              Hai aggiornato il file all'ultima versione dal server,
              ma poi hai modificato il file sul tuo sistema.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>Locally Added</computeroutput></term>
          <listitem>
            <para>
              Hai aggiunto il file con il comando <command>cvs add</command>
              ma non hai ancora eseguito il commit per l'aggiunta del
              file.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>Locally Removed</computeroutput></term>
          <listitem>
            <para>
              Hai rimosso il file con il comando <command>cvs
              remove</command> ma non hai ancora eseguito il commit per la
              rimozione.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>Needs Checkout</computeroutput></term>
          <listitem>
            <para>
              Sul server c'è una nuova versione del file ed necessita di
              essere recuperata. Anche se lo status include la parola
              checkout, vuol dire che hai bisogno di aggiornare
              i files con il comando <command>cvs update</command>.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>Needs Patch</computeroutput></term>
          <listitem>
            <para>
              La revisione del tuo checkout locale necessita di una patch per
              essere l'ultima versione dal server. Esegui il
              comando <command>cvs update</command> per risolvere.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>Needs Merge</computeroutput></term>
          <listitem>
            <para>
              Esiste una nuova revisione sul server e la tua versione di copia
              locale contiene modifiche di cui non hai fatto ancora il commit. Questo
              status di solito avviene se non hai l'ultima revisione
              del file ed lo editi lo stesso.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>File had conflicts on merge</computeroutput></term>
          <listitem>
            <para>
              Simile a <computeroutput>Needs Merge</computeroutput>,
              eccetto che quando hai provato ad eseguire il comando <command>cvs
              update</command>, le differenze non potevano essere
              risolte automaticamente. Fa riferimento a
              <xref linkend="sn-cvs-cvscommands-conflicts"></xref> per
              maggiori informazioni sulla risoluzione dei conflitti.
            </para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><computeroutput>Unknown</computeroutput></term>
          <listitem>
            <para>
              Il <application>CVS</application> server non sa nulla
	      su questo file. Il file non è stato aggiunto ne
              rimosso localmente e non è mai stato commesso al
              server. Questo status di solito sussiste per i files che di cui non
              vorresti fare il commit al <application>CVS</application> tipo
              i <filename>generated-index.sgml</filename> o per quei files
              che vorresti aggiungere al repositorio ma dei quali non hai
              ancora impartito il comando <command>cvs add</command>.
            </para>
          </listitem>
        </varlistentry>
      </variablelist>
    </section>

    <section id="sn-cvs-cvscommands-conflicts">
      <title>Risoluzione dei conflitti</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>risoluzione dei conflitti</secondary>
      </indexterm>
      <para>
        Se modifichi un file e la stessa regione è modificata da qualcun'altro
        che esegue il commit prima di te, probabilmente vedrai un messaggio
	simile al seguente quando eseguirai il commit o l'aggiornamento
        della tua copia locale del modulo:
      </para>
<screen>
<computeroutput>
RCS file: /cvs/docs/module-name/filename.sgml,v
retrieving revision 1.12
retrieving revision 1.13
Merging differences between 1.12 and 1.13 into filename.sgml
rcsmerge: warning: conflicts during merge
cvs server: conflicts found in filename.sgml
C filename.sgml
</computeroutput>
</screen>
      <para>
        Per risolvere il conflitto, apri il file, cerca
        <computeroutput>&lt;&lt;&lt;&lt;&lt;&lt;&lt;</computeroutput>
        e determina quale versione del contenuto è corretta. Per
        esempio:
      </para>
<screen>
<computeroutput>
&lt;para&gt;
Some sentence.
&lt;&lt;&lt;&lt;&lt;&lt;&lt; filename.sgml
A sentence that was changed in the working copy.
=======
A same sentence that was changed differently and committed.
&gt;&gt;&gt;&gt;&gt;&gt;&gt; 1.13
&lt;/para&gt;
</computeroutput>
</screen>
      <para>
        Il contenuto fra le
        <computeroutput>&lt;&lt;&lt;&lt;&lt;&lt;&lt;</computeroutput>,
         e le <computeroutput>=======</computeroutput> è il contenuto
        della tua copia di lavoro. Il contenuto fra le
        <computeroutput>=======</computeroutput> e le
        <computeroutput>&gt;&gt;&gt;&gt;&gt;&gt;&gt;</computeroutput> è
        il contenuto dal server.
      </para>

      <para>
        Risolvi il conflitto editando la tua copia, ed esegui il commit del file.
      </para>
    </section>

    <section id="sn-cvs-cvscommands-summary">
      <title>Sommario</title>
      <indexterm>
        <primary>cvs</primary>
        <secondary>comandi</secondary>
        <tertiary>sommario di</tertiary>
      </indexterm>
      <para>
        Tutti i comandi assumono che tu sia nella directory appropriata per
        il modulo <application>CVS</application>.
      </para>
      <table frame="all" id="tb-cvs-basic-commands">
        <title>Comandi CVS di base</title>
        <tgroup cols="2">
          <colspec colnum="1" colname="shortcut" colwidth="30"/>
          <colspec colnum="2" colname="description" colwidth="60"/>
          <thead>
            <row>
              <entry>Commando</entry>
              <entry>Descrizione</entry>
            </row>
          </thead>
          <tbody>
            <row>
              <entry><command>cvs checkout
        <replaceable>&lt;module-name&gt;</replaceable></command>
      or <command>cvs co <replaceable>&lt;module-name&gt;</replaceable></command>
              </entry>
              <entry>Crea una directory chiamata
      <replaceable>&lt;module-name&gt;</replaceable> con il contenuto del
      modulo nella directory</entry>
            </row>
            <row>
              <entry><command>cvs co -d <replaceable>&lt;directory&gt;</replaceable> -r <replaceable>&lt;branchname&gt;</replaceable><replaceable>&lt;module-name&gt;</replaceable></command>
              </entry>
              <entry>Crea la directory <replaceable>&lt;directory&gt;</replaceable>
      con i contenuti del ramo <replaceable>&lt;branchname&gt;</replaceable>
      del modulo <replaceable>&lt;module-name&gt;</replaceable></entry>
            </row>
            <row>
              <entry><command>cvs update</command> or <command>cvs up</command>
              </entry>
              <entry>Aggiorna i tuoi files con gli ultimi files dal CVS server</entry>
            </row>
            <row>
              <entry><command>cvs add <replaceable>&lt;filename&gt;</replaceable></command>
              </entry>
              <entry>Aggiunge un nuovo file "filename" al CVS server</entry>
            </row>
            <row>
              <entry><command>cvs commit -m "My message"
        <replaceable>&lt;filename&gt;</replaceable></command>
              </entry>
              <entry>Aggiorna il file <replaceable>&lt;filename&gt;</replaceable> con
      l'ultima copia proveniente dal tuo computer</entry>
            </row>
            <row>
              <entry><command>cvs log <replaceable>&lt;filename&gt;</replaceable></command>
              </entry>
              <entry>Mostra i messaggi di commit per il file <replaceable>&lt;filename&gt;</replaceable>
              </entry>
            </row>
            <row>
              <entry><command>cvs status <replaceable>&lt;filename&gt;</replaceable></command>
              </entry>
              <entry>Mostra lo status del file, tipo <computeroutput>Locally
        Modified</computeroutput>
              </entry>
            </row>
            <row>
              <entry><command>cvs status -v <replaceable>&lt;filename&gt;</replaceable></command>
              </entry>
              <entry>Mostra i tags esistenti ed i rami per il file</entry>
            </row>
            <row>
              <entry><command>cvs diff <replaceable>&lt;filename&gt;</replaceable></command>
              </entry>
              <entry>Mostra la differenza della copia di lavoro del file e l'ultima
      versione del file per il ramo</entry>
            </row>
            <row>
              <entry><command>cvs diff -r1.1 -r1.2 <replaceable>&lt;filename&gt;</replaceable></command>
              </entry>
              <entry>Mostra la differenza fra le versioni 1.1 e 1.2 per il file</entry>
            </row>
          </tbody>
        </tgroup>
      </table>
      <para>
        Per maggiori informazioni, leggi il manuale CVS disponibile sul tuo
	sistema in
        <filename>/usr/share/doc/cvs-<replaceable>&lt;version-number&gt;</replaceable>/cvs.ps</filename>
        (la versione CVS può cambiare) e visita la pagina web di CVS disponibile
        su
        <ulink url="http://www.cvshome.org/">http://www.cvshome.org/</ulink>.
      </para>
      <tip>
        <title>Tip</title>
        <para>
          Poichè <application>CVS</application> usa
          <application>ssh</application> per connettersi al
          <application>CVS</application> server, ti verrà richiesta
          la password prima di eseguire una richiesta
          <application>CVS</application>. Se vuoi configurare
          la tua macchina affinchè tu non abbia più bisogno di
          inserire la password, fa riferimento a
          <ulink url="http://redhat.com/docs/manuals/linux/RHL-9-Manual/custom-guide/s1-openssh-client-config.html"><citetitle>&RH;
          Linux 9 Customization Guide</citetitle> </ulink> per i dettagli
          sull'uso di <command>ssh-agent</command>.
        </para>
      </tip>
    </section>
  </section>
</chapter>