Um repositório CVS é o local que armazena módulos e também os arquivos administrativos (que contém permissões, etc) são armazenados em um subdiretório chamado CVSROOT.

O acesso a um repositório é feito através de parâmetros especificados na variável CVSROOT ou pela opção -d repositório do cvs. Veja “Servidor de CVS - configurando métodos de acesso ao repositório” para ver exemplos de métodos de acesso.

O Repositório pode conter um ou mais módulos, cada módulo representa um projeto no servidor, criado após o uso do comando import. Segue um exemplo da estrutura de um repositório CVS:

var/lib
     |
     +- cvs
         |- CVSROOT
         |- projeto1
         +- projeto2

O subdiretório cvs é o repositório (veja o subdiretório CVSROOT dentro dele) e os diretórios dentro dele projeto1 e projeto2 são os módulos criados através do comando cvs import ...(veja “Adicionando um novo projeto”).

Para acessar o projeto do CVS, então é definido o repositório que tem permissões de acesso na variável CVSROOT e então é executado um comando (checkout, update, commit, etc) no módulo que desejamos utilizar:

export CVSROOT=:ext:anonymous@servidor.org.br:/var/lib/cvs (<- Repositório "cvs")
cvs checkout projeto1 (<- módulo que desejamos pegar do servidor)

Nas seções seguintes serão explicados cada um dos comandos usados para trabalhar com um projeto no cvs.

Para adicionar um novo repositório no sistema, edite o arquivo /etc/cvs-pserver.conf e defina o nome de cada repositório na variável CVS_PSERV_REPOS separados por ":" (exemplo: CVS_PSERV_REPOS="/var/lib/cvs:/var/lib/cvs2").

Feito isso execute o comando cvs-makerepos para que os diretórios especificados no arquivo /etc/cvs-pserver.conf sejam criados com as devidas permissões.

Para adicionar manualmente um repositório (/var/lib/cvs), execute os seguintes passos:

A partir de agora, seu repositório já está pronto para ser utilizado.

Quando é usado o método de acesso pserver (“pserver (password server)”), é necessário fazer para ter acesso ao repositório. Por exemplo, para acessar o repositório /var/lib/cvs no servidor servidor.org.br:

export CVSROOT=:pserver:anonymous@servidor.org.br:/var/lib/cvs
cvs login

ou 

cvs -d :pserver:anonymous@servidor.org.br:/var/lib/cvs login

Então será solicitada a senha para ter acesso ao sistema. Note que toda a seção de cvs ocorre por comandos interativos que logo após concluídos retornam para o interpretador de comandos. O restante desta seção descreverá estes comandos e como utiliza-los de maneira eficiente.

OBS: O uso da variável CVSROOT torna a utilização bastante prática, assim não precisamos especificar o repositório, método de acesso, etc. toda vez que usar um comando do cvs.

Embora que não seja necessário, após o uso do cvs é recomendável executar o logout do servidor para encerrar sua conexão com a máquina remota.

# (assumindo que a variável CVSROOT está definida)
cvs logout

ou 

cvs -d :pserver:anonymous@servidor.org.br:/var/lib/cvs logout

OBS: Para os paranóicos é importante encerrar uma seção de CVS, pois ele possui alguns bugs e um spoofing pode tornar possível o uso de uma seção deixada aberta.

O comando checkout (ou "co") é usado para fazer isto. Para utilizá-lo seguindo os exemplos anteriores:

mkdir /tmp/cvs
cd /tmp/cvs
cvs checkout modulo
cvs -d :pserver:anonymous@servidor.org.br:/var/lib/cvs

Será criado um subdiretório chamado modulo que contém todos os arquivos do servidor de CVS remoto. É necessário apenas que tenha acesso de leitura ao servidor de CVS para executar este comando. Você pode usar a opção -z [num] para ativar a compactação na transferência dos arquivos, isso acelera bastante a transferência em conexões lentas: cvs -z 3 checkout modulo.

Também é possível especificar apenas subdiretórios de um módulo para baixa-lo via CVS e a estrutura de diretórios criada localmente será idêntica ao do servidor remoto.

Use o comando cvs import para adicionar um novo projeto ao CVS. As entradas nos arquivos administrativos serão criadas e o projeto estará disponível para utilização dos usuários. A sintaxe básica do comando import é a seguinte:

cvs import [opções] [dir_modulo] [tag] start

Para adicionar o projeto focalinux que reside em /usr/src/focalinux ao cvs:

# Primeiro exportamos o CVSROOT para dizer onde e qual repositório acessar
export CVSROOT=:ext:usuario@servidor.com.br:2401/var/lib/cvs

cd /usr/src/focalinux
cvs import documentos/focalinux tag_modulo start

Por padrão o import sempre utiliza a máscara * para fazer a importação dos arquivos do diretório atual. O projeto focalinux será acessado através de $CVSROOT/documentos/focalinux (cvs checkout documentos/focalinux), ou seja, /var/lib/cvs/documentos/focalinux no servidor CVS terá a cópia do focalinux. tag_modulo define o nome que será usado como identificador nas operações com os arquivos do CVS (pode ser usado "focalinux" em nosso exemplo). O parâmetro "start" diz para criar o módulo.

OBS: Por segurança, o diretório que contém os arquivos deverá ser sempre um caminho relativo na estrutura de diretórios, ou seja, você precisará entrar no diretório pai (como /usr/src/projeto) para executar o cvs import. Não é permitido usar / ou .., isto proíbe a descida em diretórios de nível mais altos e sérios incidentes de segurança em servidores CVS mal configurados pelo Administrador.

Este comando sincroniza a cópia remota do CVS (ou arquivo) com a cópia local que está trabalhando em sua máquina. Quando se trabalha nativamente no CVS em equipe é recomendado a utilização deste comando pois alguém pode ter modificado o arquivo antes de você, então uma incompatibilidade entre sua versão e a nova poderia causar problemas.

Supondo que tenha acabado de modificar o arquivo main.c do módulo cvsproj, então antes de fazer o commit (“Enviando as mudanças para o servidor remoto”) use o update:

cvs update main.c

ou 

cvs -d :ext:usuario@servidor.com.br:2401/var/lib/cvs update main.c

Após alguns segundos, sua cópia local ficará sincronizada com a cópia remota. Caso ele mostre alguma mensagem de saída, verifique o arquivo para solucionar qualquer conflito e então envie o arquivo para o servidor remoto (“Enviando as mudanças para o servidor remoto”).

Você pode fazer o update de mais arquivos usando referências globais (*, ? ou []).

O comando "commit" (ou "ci"), envia as mudanças feitas nos arquivos locais para o servidor remoto. Um exemplo de commit no arquivo main.c:

cvs commit main.c

cvs commit main.?

cvs commit *

O editor padrão do sistema será aberto e pedirá uma descrição das modificações para o commit. Esta descrição será usada como referência sobre as atualizações feitas em cada etapa do desenvolvimento. A mensagem também pode ser especificada usando a opção "-m mensagem", principalmente quando o texto explicando as alterações é pequeno.

Para mudar o editor de texto padrão que será usado pelo cvs, altere a variável de ambiente EDITOR ou especifique o editor que deseja usar na linha de comando com a opção "-e editor":

cvs commit -e vi main.c

Após criar/copiar o arquivo para seu diretório de trabalho, use o comando add para fazer isto. O arquivo será enviado ao servidor, bastando apenas executa o commit para salvar o arquivo:

cvs add main.h
cvs commit main.h

O método para adicionar um diretório com arquivos é semelhante ao de adicionar apenas arquivos ao cvs. O único ponto que deve se seguido é que primeiro deve ser adicionado o diretório (com o "cvs add") salvar no servidor remoto ("cvs commit") e depois adicionar os arquivos existentes dentro dele (assim como descrito em “Adicionando um arquivo ao módulo CVS do servidor”). Para adicionar o diretório teste e seus arquivos no servidor cvs remoto:

cvs add teste
cvs commit -m "Adicionado" teste
cvs add teste/*
cd teste
cvs commit -m "Adicionados" .

Os dois primeiros comandos agendam o diretório teste e fazem o commit no diretório remoto. Os dois últimos, enviam os arquivos existentes dentro deste diretório para o servidor remoto.

O comando para fazer isto é o "remove". Primeiro use o rm para remover o arquivo/diretório de sua cópia local, depois execute o remove seguido de commit para confirmar a remoção do arquivo:

cvs remove main.h
cvs commit main.h

Para remover um diretório, primeiro remova todos os arquivos existentes dentro dele com o comando rm e salve para o servidor (seguindo os métodos descritos em “Removendo um arquivo do módulo CVS remoto”). O CVS não remove diretamente diretórios vazios, uma maneira de contornar isto é usar o update ou commit seguido da opção -P para ignorar diretórios vazios. Então a cópia remota do diretório será removida do servidor:

rm -f teste/*
cvs remove teste/.
cvs commit teste/.
cd ..
cvs checkout modulo

Depois do checkout, o subdiretório teste terá sido removido.

O comando "release" faz esta função. Ele não é requerido, mas caso você tenha feito modificações que ainda não foram salvas no servidor de cvs (commit), ele alertará de arquivos modificados e perguntará se deseja continuar. Registrando também o abandono das modificações no histórico do cvs. O comando pode ser acompanhado de "-d" para remover o módulo anteriormente baixado com o "commit":

cvs release modulo

cvs release -d modulo

O release retorna os seguintes códigos quando verifica que as duas cópias (local e remota) não estão sincronizadas:

Com o comando "diff" é possível visualizar que diferenças o arquivo que está sendo editado possui em relação ao arquivo do repositório remoto. Outra funcionalidade útil do "diff" é comparar 2 versões de arquivos do mesmo repositório CVS. Exemplos:

O comando "status" permite verificar que versões do arquivo especificado está disponível localmente, remotamente, qual a versão inicial do arquivo no repositório, sticky tag. Exemplos:

Além dos comandos do cvs descritos aqui, existem comandos no pacote que auxiliam desde quem está aprendendo a utilizar o CVS (com o comando cvsdo para simular algumas operações de adição/remoção de arquivos) até profissionais que usam o programa no dia a dia (cvsu, cvsco, cvschroot).