Guia do Linux/Avançado/CVS/Criando projetos para serem usados no CVS

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Criando projetos para serem usados no CVS[editar | editar código-fonte]

Esta seção descreve todos os passos necessários para colocação de um projeto para ser desenvolvido através do CVS, os comandos do cvs, considerações a respeito dos comandos e sua utilização através de exemplos didáticos.


Repositório[editar | editar código-fonte]

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 [#s-s-cvs-d Servidor de CVS - configurando métodos de acesso ao repositório, Seção 17.2] 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 [#s-s-cvs-p-import Adicionando um novo projeto, Seção 17.3.6]). 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.


Criando um repositório[editar | editar código-fonte]

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:

  • Execute o comando cvs -d /var/lib/cvs init (para criar o repositório e os arquivos administrativos que ficam armazenados dentro de CVSROOT.
  • Mude as permissões do diretório para sgid com: chmod 2775 /var/lib/cvs.
  • Mude o dono/grupo com o comando: chown root.src /var/lib/cvs
  • Opcional: caso utilize o método de acesso pserver será necessário adicionar a opção --allow-root=/var/lib/cvs na linha que inicia o servidor pserver. Este parâmetro deve ser usada para cada repositório adicionado no servidor.

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


Logando no servidor de CVS via pserver[editar | editar código-fonte]

Quando é usado o método de acesso pserver ([#s-s-cvs-d-metodos-pserver pserver (password server), Seção 17.2.4]), é 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.


Encerrando uma seção de CVS[editar | editar código-fonte]

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.


Baixando arquivos[editar | editar código-fonte]

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.


Adicionando um novo projeto[editar | editar código-fonte]

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.


Sincronizando a cópia remota com a cópia local[editar | editar código-fonte]

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 ([#s-s-cvs-p-commit Enviando as mudanças para o servidor remoto, Seção 17.3.8]) 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 ([#s-s-cvs-p-commit Enviando as mudanças para o servidor remoto, Seção 17.3.8]). Você pode fazer o update de mais arquivos usando referências globais (*, ? ou []).


Enviando as mudanças para o servidor remoto[editar | editar código-fonte]

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

Adicionando um arquivo ao módulo CVS do servidor[editar | editar código-fonte]

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

Adicionando um diretório ao módulo CVS do servidor[editar | editar código-fonte]

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 [#s-s-cvs-p-add Adicionando um arquivo ao módulo CVS do servidor, Seção 17.3.9]). 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.


Removendo um arquivo do módulo CVS remoto[editar | editar código-fonte]

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

Removendo um diretório do módulo CVS remoto[editar | editar código-fonte]

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 [#s-s-cvs-p-remove Removendo um arquivo do módulo CVS remoto, Seção 17.3.11]). 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.


Dizendo que o módulo atual não está mais em uso[editar | editar código-fonte]

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:

  • U ou P
    Existe uma versão nova do arquivo no repositório. Para corrigir isso, execute o comando "update".
    A
    O arquivo não foi adicionado ainda ao repositório remoto. Se apagar o repositório local, este arquivo não será adicionado. Para corrigir isto, executa o comando "add" do cvs.
    R
    O arquivo foi removido localmente, mas não foi removido do servidor remoto. Use os procedimentos em [#s-s-cvs-p-remove Removendo um arquivo do módulo CVS remoto, Seção 17.3.11] para corrigir a situação.
    M
    O arquivo está modificado localmente e não foi salvo ainda no servidor. Use os procedimentos em [#s-s-cvs-p-update Sincronizando a cópia remota com a cópia local, Seção 17.3.7] e [#s-s-cvs-p-commit Enviando as mudanças para o servidor remoto, Seção 17.3.8] para salvar o arquivo.
     ?
    O arquivo está em seu diretório de trabalho mas não tem referências no repositório remoto e também não está na lista de arquivos ignorados do CVS.

Visualizando diferenças entre versões de um arquivo[editar | editar código-fonte]

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:

  • cvs diff main.c
    Verifica as diferenças entre o arquivo main.c local e remoto.
    cvs diff -u -r 1.1 -r 1.2 main.c
    Mostra as diferenças em formato unificado para mostrar as diferenças entre as versões 1.1 e 1.2 do arquivo main.c.

Visualizando o status de versão de arquivos[editar | editar código-fonte]

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:

  • cvs status main.c
    Verifica o status do arquivo main.c.
    cvs status -v main.c
    Mostra o status do arquivo main.c, adicionalmente mostra também as tags existentes no arquivo (versão inicial, versão do repositório).

Outros utilitários para trabalho no repositório[editar | editar código-fonte]

Além dos comandos do cvs descritos aqui, existem comandos no pacote cvsutils 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).