Introdução ao CVS
O CVS (Concurrent Version Software) permite que se organizem grupos de trabalho para
desenvolvimento de projetos colaborativos. Um projeto pode ser desde um programa em C,
documentação em equipe, etc. O uso do CVS é recomendado para qualquer desenvolvimento de
projeto que tenha vários envolvidos trabalhando ao mesmo tempo.
Para cada mudança feita no programa, é pedido uma descrição dos trabalhos realizados e o sistema
registra todas as modificações realizadas ao longo do desenvolvimento, permitindo voltar a uma
versão anterior ou ver as mudanças entre elas facilmente.
Imagine uma situação onde você está desenvolvendo um programa de computador e após a última
modificação ele para de funcionar. Com o CVS é possível ver o que foi modificado e voltar até a
versão que estava funcionando para consertar o problema. No desenvolvimento de documentação e
tradução o CVS também desempenha um papel importante, pois com ele o tradutor pode ver o que
foi modificado entre a versão do documento original que ele usou para tradução e uma versão
recente, traduzindo apenas as diferenças.
Uma seção de cvs é feita de modo interativo através do comando cvs. Por exemplo:
• logar no sistema – cvs login
• baixar um projeto – cvs checkout projeto
Cada comando do cvs será explicado em detalhes no decorrer deste capítulo.
17.1.1 Versão
A versão do CVS documentada no guia é a 1.11.1. As explicações aqui certamente serão
compatíveis com versões posteriores deste programa.
17.1.2 História
O CVS é uma substituição do sistema RCS (Revision Control System) ele possui mais recursos e foi
criado sendo compatível com o RCS.
A história do CVS (extraída de sua info page) é que ele foi iniciado a partir de um conjunto de
scripts shell escritos por Dick Grune que foram postados ao grupo de notícias
comp.sources.unix no volume 6 de Dezembro de 1986. Na versão atual não estão mais
presentes shell scripts porque muitos dos conflitos de resolução de algorítmos vem deles.
Em Abril de 1989, Brian Berliner fez o design e programou o CVS. Mais tarde, Jeff Polk ajudou
Brian com o design do módulo CVS.
17.1.3 Contribuindo com o CVS
Através da lista de discussão info-cvs. Para se inscrever envie uma mensagem com o subject
“subscribe” para [email protected]. Outra alternativa é através do grupo de
noticias (newsgroup) da Usenet comp.software.config-mgm.
17.1.4 Características
Abaixo uma lista de características que tornam o CVS útil no gerenciamento de trabalhos em grupo:
• Gerenciamento de projeto em equipe
• Log de todas as alterações realizadas
• Lock de arquivos, permitindo que somente uma determinada pessoa modifique o arquivo
durante o desenvolvimento do projeto.
• Histórico de todas as mudanças feitas, isto permite voltar a uma versão anterior em caso de
problemas, e ver o que houve de errado com o código.
• Os projetos podem ser hospedados em repositórios.
• Podem ser criados diversas equipes de trabalho para cada repositórios, e definidos quem terá
ou não acesso ao repositório individualmente. O desenvolvedor gleydson, por exemplo,
podem ter acesso ao projeto x_beta e não ter acesso a projeto secret_y.
• Permissões de acesso individuais de leitura/gravação.
• É possível criar um usuário com acesso anônimo sem dar uma conta no sistema.
• Pode tanto utilizar o banco de dados de contas/senhas do sistema como um banco de dados
de autenticação do próprio CVS.
• Permite utilizar diversos “métodos” de acesso ao servidor: local, pserver, ext, etc. Cada um
destes métodos será descrito a seguir.
• Permite o acesso via ssh para usuários que já possuam conta na máquina servidora. Este
método garante segurança no envio da senha criptografada (veja Sniffer, Seção 20.2 para
detalhes).
• Permite visualizar facilmente o que foi modificado entre duas versões de um arquivo.
OBS: O CVS possui algumas limitações e falhas, uma delas que mais me faz falta é um suporte a
protocolo pserver via ssh que resolveria o problema de tráfego em texto plano e gerenciamento de
grupos com permissões diferenciadas.
17.1.5 Ficha técnica
Pacote: cvs
Utilitários:
• cvs – Servidor/ferramenta cliente.
• cvsbug – Envia um bug sobre o CVS para a equipe de suporte.
• rcs2log – Converte arquivos de log do formato usado pelo RCS para o CVS. Utilizado na
migração desta ferramenta para o CVS.
• cvsconfig – Usado pela Debian para ativar/desativar o servidor pserver. Pode
também ser usado o dpkg-reconfigure cvs para desativar o servidor pserver e
suas características.
• cvs-makerepos – Script da Debian que lê a lista de repositórios de /etc/cvspserver.
conf, cria os repositórios no local apropriado, corrige as permissões do
diretório e adiciona os repositórios no servidor pserver.
• cvs-pserver – Script da Debian responsável por fazer uma inicialização mais
inteligente do servidor de CVS via pserver, leitura e processamento de repositórios, etc.
Normalmente ele é chamado a partir do arquivo /etc/inetd.conf.
17.1.6 Requerimentos de Hardware
Para executar o CVS é requerido pelo menos 3 vezes mais memória que o tamanho do maior
arquivo usado pelo projeto (para realização de diffs entre as atualizações) e uma boa quantidade de
espaço em disco.
Na realidade os requerimentos sobre o CVS dependem muito da aplicação que será desenvolvida. É
recomendável que a máquina tenha memória suficiente para evitar o uso de swap, que degrada
bastante a performance do sistema.
17.1.7 Arquivos de log criados pelo CVS
Problemas na inicialização do CVS são registrados no arquivo /var/log/daemon.log. Os logs
de modificações feitas nos arquivos de um projeto no CVS são armazenadas no formato
arquivo.extensão,v (é adicionado o “,v” ao final do arquivo para indicar que é um arquivo
de controle de modificações do CVS).
17.1.8 Instalação
O CVS pode ser baixado de http://www.cvshome.org/.
Para pacotes Debian basta apenas executar o comando: apt-get install cvs e seguir as
telas de configuração para ter o pacote CVS instalado e (opcionalmente) com o servidor sendo
executado. Você poderá a qualquer momento reconfigurar o CVS executando: dpkgreconfigure
cvs.
Uma boa documentação de referência é encontrada no pacote cvs-doc.
17.1.9 Iniciando o servidor/reiniciando/recarregando a configuração
A única configuração requerida é quando o CVS é executado via pserver. Para isto, é necessária
a seguinte linha no arquivo /etc/inetd.conf
cvspserver stream tcp nowait.200 root /usr/sbin/tcpd
/usr/sbin/cvs-pserver
Note que o parâmetro “200” indica quantas vezes o processo CVS poderá ser executado por minuto
no sistema. Caso esse número seja excedido, o serviço será desabilitado e será necessário reiniciar o
servidor inetd com o comando killall -HUP inetd para reativar o servidor CVS pserver
(veja /etc/inetd.conf, Seção 4.7.2.1 capítulo do inetd para detalhes). Ajuste este valor de forma
adequada ao seu servidor!
Veja o script cvs-pserver sendo executado no final da linha. Ele foi desenvolvido para lidar de
forma mais inteligente com a configuração do servidor CVS pserver.
17.1.10 Opções de linha de comando
As seguintes opções são aceitas pelo CVS.
-z [num]
Utiliza o gzip para fazer a transferência compactada dos arquivos. O valor especificado pode
ser de 0 a 9, quanto maior o número maior o nível de compactação e uso da CPU.
Exemplo: cvs -z 3 checkout teste
-q
Oculta mensagens sobre recursão de diretório durante os comandos do CVS.
-d [repositório]
Permite especificar o repositório através da linha de comando.
-e [editor]
Define qual é o editor de textos usado para registrar o texto de commits.
-n
Executa o cvs em modo “simulação” não modificando qualquer arquivo do repositório.
-t
Mostra mensagens mostrando o processo de execução de comandos do CVS. É bastante útil
para aprendizado do cvs usado junto com a opção -n.
-r
Torna os novos arquivos criados somente para leitura. É a mesma coisa que especificar a
variável CVSREAD.
-w
Torna os novos arquivos criados leitura/gravação que é o padrão.
-x
Utiliza criptografia para a transferência dos arquivos quando é utilizado em conjunto com o
Kerberos.
Você pode obter detalhes sobre opções sobre um comando em especial do CVS (commit, checkout,
etc) digitando: cvs comando –help. Veja Criando projetos para serem usados no CVS, Seção
17.3 para exemplos sobre cada uma delas.
17.2 Servidor de CVS – configurando métodos de acesso ao
repositório
O CVS é uma aplicação cliente/servidor, possuindo diversas maneiras de fazer o acesso seu
repositório (veja Repositório, Seção 17.3.1 repositórios). Estes métodos são os seguintes:
• local (local, Seção 17.2.1).
• ext (ext, Seção 17.2.3).
• pserver (pserver (password server), Seção 17.2.4).
• fork (fork, Seção 17.2.2).
• GSSAPI (gssapi, Seção 17.2.6).
Eles são explicados em detalhes nas sub-seções a seguir.
17.2.1 local
Acessa o diretório do repositório diretamente no disco local. A vantagem deste método é que não é
requerido nem nome nem senha para acesso (você precisa apenas ter permissões para acesso aos
arquivos que deseja trabalhar) e também não é preciso nenhuma conexão de rede.
Este método é ideal para trabalhar na máquina local ou com os arquivos administrativos do CVS
existentes no diretório CVSROOT do repositório. É muito útil também para configurar outros
métodos de acesso, como o pserver.
Para criar seu repositório, veja Criando um repositório, Seção 17.3.2.
17.2.1.1 Configurando o método local
Para utilizar o método de acesso local, basta definir a variável CVSROOT da seguinte forma
(assumindo que o repositório esteja instalado em /var/lib/cvs):
export CVSROOT=/var/lib/cvs
ou
export CVSROOT=local:/var/lib/cvs
Depois disso, basta utilizar os comandos normais do cvs sem precisar se autenticar no sistema.
Veja os detalhes de utilização dos comandos de CVS após o login na seção Clientes de CVS, Seção
17.5.
17.2.2 fork
Este método é semelhante ao local, mas ele “simula” uma conexão de rede com o servidor. É muito
usado para fins de testes.
17.2.2.1 Configurando o método fork
Para utilizar o método de acesso fork, basta definir a variável CVSROOT da seguinte forma
(assumindo que o repositório esteja instalado em /var/lib/cvs):
export CVSROOT=fork:/var/lib/cvs
Depois disso, basta utilizar os comandos normais do cvs, sem precisar se autenticar no sistema.
Veja os detalhes de utilização dos comandos do CVS após o login em Clientes de CVS, Seção 17.5.
17.2.3 ext
Este método de acesso lhe permite especificar um programa externo que será usado para fazer uma
conexão remota com o servidor cvs.Este programa é definido na variável CVS_RSH e caso não ela
seja especificada o padrão é rsh.
Este método requer que o usuário possua um login/senha no banco de dados de autenticação
/etc/passwd do servidor de destino. Suas permissões de acesso ao CVS (leitura/gravação) serão
as mesmas definidas neste arquivo.
O uso do acesso criptografado via ssh é possível definindo o programa ssh na variável CVS_RSH.
Veja os exemplos a seguir em Configurando o método ext, Seção 17.2.3.1.
Para criar seu repositório, veja Criando um repositório, Seção 17.3.2.
17.2.3.1 Configurando o método ext
Defina a variável CVSROOT da seguinte forma para utilizar este método de acesso (assumindo
/var/lib/cvs como repositório):
export CVSROOT=:ext:[email protected]:/var/lib/cvs
cvs login
A “conta” é uma conta de usuário existente no servidor remoto (por exemplo, gleydson) seguido
do nome do servidor remoto (separado por uma “@”). Por exemplo para acessar o servidor
cvs.cipsga.org.br usando a conta michelle:
export CVSROOT=:ext:[email protected]:/var/lib/cvs
cvs checkout
OBS: A senha via método de acesso “ext” será pedida somente uma vez quando for necessário o
primeiro acesso ao servidor remoto. Veja os detalhes de utilização dos comandos de CVS após o
login na seção Clientes de CVS, Seção 17.5. O uso mais freqüente do ext é para conexões seguras
feitas via ssh, feita da seguinte forma:
export CVS_RSH=ssh
export CVSROOT=:ext:[email protected]:/var/lib/cvs
cvs checkout
O acesso de leitura/gravação do usuário, é definido de acordo com as permissões deste usuário no
sistema. Uma maneira recomendada é definir um grupo que terá acesso a gravação no CVS e
adicionar usuários que possam fazer gravação neste grupo.
OBS1: O acesso via ssh traz a vantagem de que as senhas trafegarão de forma segura via rede, não
sendo facilmente capturadas por sniffers e outros programas de monitoração que possam estar
instalados na rota entre você e o servidor.
OBS2: É possível especificar a senha na variável CVSROOT usando a sintaxe semelhante a usada
no ftp:
export CVSROOT=:ext:michelle:[email protected]:/var/lib/cvs
Entretanto isto não é recomendado, pois os processos da máquina poderão capturar facilmente a
senha (incluindo usuários normais, caso a máquina não esteja com patches de restrições de acesso a
processos configurada, que é o padrão em quase todas as distribuições de Linux).
17.2.4 pserver (password server)
Este é um método de acesso remoto que utiliza um banco de dados de usuários senhas para acesso
ao repositório. A diferença em relação ao método de acesso ext é que o pserver roda através de um
servidor próprio na porta 2401. O acesso dos usuários (leitura/gravação) no repositório pode ser
feita tanto através do banco de dados de usuários do sistema (/etc/passwd) como através de um
banco de dados separado por repositório.
A grande vantagem deste segundo método é que cada projeto poderá ter membros com acessos
diferenciados; o membro x poderá ter acesso ao projeto sgml mas não ao projeto focalinux; ou
o usuário y poderá ter acesso de gravação (para trabalhar no projeto focalinux) mas somente
acesso de leitura ao projeto sgml.
Este é o método de acesso preferido para a criação de usuários anônimos (uma vez que o
administrador de um servidor que hospede muitos projetos não vai querer abrir um acesso anônimo
via ext para todos os projetos).
Também existe a vantagem que novos membros do projeto e tarefas administrativas são feitas por
qualquer pessoa que possua acesso de gravação aos arquivos do repositório.
17.2.5 Configurando um servidor pserver
17.2.5.1 Ativando o servidor pserver
Para ativar o pserver (caso ainda não o tenha feito). Execute o comando dpkg-reconfigure
cvs e selecione a opção Ativar o servidor pserver. Uma maneira de fazer isso
automaticamente é modificando o arquivo /etc/inetd.conf adicionando a seguinte linha:
# na Debian
cvspserver stream tcp nowait.400 root /usr/sbin/tcpd
/usr/sbin/cvs-pserver
# em outras Distribuições
cvspserver stream tcp nowait root /usr/bin/cvs cvs -f –allowroot=/
var/lib/cvs pserver
Na Debian, o cvs é iniciado através do script /usr/sbin/cvs-pserver que checa os
binários e executa o cvs para todos os repositórios especificados no arquivo /etc/cvspserver.
conf.
Caso precise adicionar mais repositórios para acesso via pserver ou outro método de acesso, veja
Criando um repositório, Seção 17.3.2.
Você também poderá executar o método pserver sob um usuário que não seja o root, para isto,
modifique a entreada referênte ao usuário.grupo no inetd.conf e tenha certeza que o daemon
consegue fazer as operações de suid/sgid no diretório onde o repositório se encontra.
17.2.5.2 Servidor pserver usando autenticação do sistema
Para usar o banco de dados de autenticação do sistema (/etc/passwd) para autenticar os
usuários remotos, primeiro tenha certeza que o servidor pserver está ativado (como descrito em
Ativando o servidor pserver, Seção 17.2.5.1. Repetindo o exemplo anterior, a usuária Michelle
deverá ter uma conta em /etc/passwd para fazer acesso ao cvs:
export CVSROOT=:pserver:[email protected]:/var/lib/cvs
cvs login
Será pedido a senha da usuária michelle. Entrando com a senha correta, o sistema retornará para
o aviso de comando. Uma mensagem será mostrada caso a senha entrada seja incorreta. Daqui em
diante, o resto da seção CVS é normal e você terá as permissões de acesso ao repositório de acordo
com as suas permissões de acesso naquele diretório.
OBS1: A senha poderá ser passada junto com o login da mesma forma como o ftp. Veja a
observação em Configurando o método ext, Seção 17.2.3.1.
OBS2: A desvantagem do método pserver padrão é que a seção é feita em texto plano, desta forma,
alguns cuidados podem ser tomados para tornar o sistema um pouco mais seguro. Um deles é dar
/bin/false como shell de usuário (para desativar o login no sistema) ou usar o método de
acesso descrito em Servidor pserver usando autenticação do sistema, Seção 17.2.5.2 em combinação
com este. Tenha conciencia das influências disso se a máquina for usada para outras tarefas, como
um servidor “pop3” por exemplo.
17.2.5.3 Servidor pserver com autenticação própria
Esta forma de acesso armazena os usuários em um banco de dados próprio, não requerendo a
criação de contas locais no arquivo /etc/passwd. Para criar um servidor deste tipo siga os
seguintes procedimentos:
• Exporte a variável CVSROOT apontando para o repositório que deseja configurar o acesso.
Como isto é uma configuração administrativa, assumo o método de acesso local sendo usada
pelo usuário administrador do servidor: export CVSROOT=/var/lib/cvs.
• Crie um diretório para trabalhar nos arquivos administrativos do repositório: mkdir
/tmp/repos
• Entre no diretório criado acima e execute o comando: cvs checkout .
• Quando terminar de baixar os arquivos, entre no subdiretório CVSROOT, os arquivos de
configuração do repositório se encontram lá (para detalhes sobre cada um destes arquivos,
veja Arquivos administrativos em CVSROOT, Seção 17.4.
• Edite o arquivo config e mude a variável SystemAuth para no. Isto diz ao servidor
pserver não usar os arquivos de autenticação do sistema, mas a invés disso usar seu banco
de dados próprio.
Em algumas instalações, caso exista o arquivo passwd no repositório, o pserver automaticamente
o utiliza ao invés do /etc/passwd.
• Crie um arquivo passwd no diretório CVSROOT o formato deste arquivo é:
usuario:senha:usuario_local
Onde:
usuario
Nome da conta de usuário que fará acesso ao CVS.
senha
Senha que será usada pelo usuário. Ela deverá ser criptografada usando o algoritmo crypt. O
comando mkpasswd senha pode ser usado para gerar a senha criptografada. Caso este
campo seja deixado em branco, nenhuma senha de usuário será utilizada. O utilitário
mkpasswd está presente no pacote whois na Debian.
usuario_local
Usuário local que terá suas permissões mapeadas ao usuário do CVS. Como a conta de
usuário do cvs não existe no sistema, é necessário que o sistema tenha uma maneira de saber
que nível de acesso este usuário terá. Caso não crie este usuário ou ele seja inválido, você terá
erros do tipo “: no such user” no momento que fizer o “cvs login”.
Uma forma segura de se fazer isto, é criar uma conta de usuário *somente* com acesso aos
arquivos do CVS, sem shell e senha. Isto permitirá mapear a UID/GID do usuário criado com
o acesso do CVS sem comprometer a segurança do sistema de arquivos. Isto pode ser feito
através do seguinte comando:
adduser –disabled-password –disabled-login usuario
É necessário especificar um diretório home do usuário, pois o servidor cvs precisa ter acesso
ao arquivo /home/do/cvs/.cvsignore.
OBS1: Mais uma vez: Leve sempre em conta a forma que os outros serviços em sua máquina
estão configurados (como eles fazem acesso, permissões de acesso, diretórios onde gravam
arquivos, são algumas delas) antes de escolher como um serviço novo na máquina funcionará.
Isto poderá modificar ou deixar vulnerável a segurança de sua instalação.
OBS2: Permita que os usuários somente tenham acesso a máquina via CVS.
OBS3: Certifique-se sempre que o dono/grupo do repositório seja root.src (ou outro
grupo que tenha criado) adicione somente usuários de confiança no grupo src para criar
novos projetos.
Exemplos:
gleydsonm:K32dk1234k:cvsuser
anonymous::pooruser
O usuário cvs gleydsonm quando logar no cvs, terá as permissões de acesso do usuário
cvsuser do sistema.
OBS1: Certifique-se que o usuário local possui permissões de gravação no diretório do CVS,
caso contrário ele não poderá fazer commits. Lembre-se que as permissões de leitura/gravação
do usuário serão controladas através de arquivos do próprio pserver, mas também é necessária
a permissão de gravação do usuário no repositório. Isto poderá ser feito através de grupos de
sistema e garante uma dupla camada de segurança.
OBS2: Caso tenha preferido usar o pserver sob um usuário diferente de root e esteja
obtendo a mensagem setgid failed: Operation not permitted, significa que
o servidor CVS não consegue mudar para o grupo referente ao usado no diretório do
repositório. Verifique se as permissões estão adequadas e se o grupo do usuário CVS no
/etc/passwd é o mesmo que especificou para acesso ao repositório.
• Para dar direito de leitura ao repositório, crie um arquivo chamado readers e adicione os
nomes de usuários que terão acesso ao repositório (um por linha). O nome que deverá ser
usado é o nome do usuário de CVS e não do sistema (usuário gleydsonm, segundo o
exemplo).
Exemplo:
gleydsonm
anonymous
• Para dar direito de gravação ao repositório, crie um arquivo chamado writers. Seu
formato é idêntico ao arquivo readers.
Exemplo:
gleydsonm
macan
otavio
hmh
kov
• Pronto, o acesso a CVS usando um banco de dados próprio está pronto! basta dar o commit
nos arquivos, adicionar os arquivos readers, writers e passwd no repositório (veja
Adicionando um arquivo ao módulo CVS do servidor, Seção 17.3.9) para o servidor de CVS
para te-lo funcionando. Note que em versões mais novas do CVS, não é possível transferir o
arquivo passwd via rede, então será necessário cria-lo manualmente dentro do repositório
do servidor.
OBS: O arquivo passwd não é transferido pelo commit por motivos de segurança, pois ele contém
senhas que podem ser capturadas e usada por pessoas maliciosas. Será necessário transferi-lo
manualmente para o repositório do servidor remoto (você terá que ser o usuário root ou ter
permissões adequadas). O recomendável é utilizar o scp (scp, Seção 15.2.2) para realizar
transferências seguras. .
O método de acesso do CVS aos arquivos readers e writers é restritiva, portanto se um nome
de usuário existir no arquivo readers e writers o que valerá será o menor nível de acesso.
Vendo os exemplos acima, os usuários gleydsonm e anonymous terão somente acesso a leitura do
repositório e macan, otavio, hmh, kov acesso de leitura e gravação.
17.2.6 gssapi
Quando o CVS é compilado com o suporte a Kerberos 5, ele tenta estabelecer automaticamente uma
conexão segura usando este método. Este método funciona somente se o CVS estiver compilado
com o suporte a Kerberos (opção –with-gssapi).
17.3 Criando projetos para serem usados no CVS
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.
17.3.1 Repositório
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, 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 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:[email protected]:/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.
17.3.2 Criando um repositório
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.
17.3.3 Logando no servidor de CVS via pserver
Quando é usado o método de acesso 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:[email protected]:/var/lib/cvs
cvs login
ou
cvs -d :pserver:[email protected]:/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.
17.3.4 Encerrando uma seção de 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:[email protected]:/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.
17.3.5 Baixando arquivos
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:[email protected]:/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.
17.3.6 Adicionando um novo projeto
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:[email protected]: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.
17.3.7 Sincronizando a cópia remota com a cópia local
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, Seção 17.3.8) use o update:
cvs update main.c
ou
cvs -d :ext:[email protected]: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, Seção 17.3.8).
Você pode fazer o update de mais arquivos usando referências globais (*, ? ou []).
17.3.8 Enviando as mudanças para o servidor remoto
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
17.3.9 Adicionando um arquivo ao módulo CVS do servidor
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
17.3.10 Adicionando um diretório ao módulo CVS do servidor
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, 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.
17.3.11 Removendo um arquivo do módulo CVS 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
17.3.12 Removendo um diretório do módulo CVS remoto
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, 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.
17.3.13 Dizendo que o módulo atual não está mais em uso
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 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 Sincronizando a cópia remota com a cópia local, Seção 17.3.7 e 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.
17.3.14 Visualizando diferenças entre versões de um arquivo
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.
17.3.15 Visualizando o status de versão de arquivos
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).
17.3.16 Outros utilitários para trabalho no repositório
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).
17.4 Arquivos administrativos em CVSROOT
Esta seção descreve a função de cada um dos arquivos administrativos, isto pode ser útil na
configuração e personalização do CVS e de seu repositório.
Para não alongar muito o capítulo, procurei colocar uma breve descrição da função de cada um
deles, o comentários e exemplos existentes nos arquivos oferecem uma boa compreensão do seu
conteúdo.
17.4.1 config
Este arquivo é segue os padrões do arquivos de configuração e possui alguns parâmetros que
controlam o comportamento do CVS. Segue uma lista deles:
SystemAuth
Define se será utilizado a autenticação via /etc/passwd quando o método pserver for
utilizado. Note que se o arquivo passwd for criado no CVSROOT, o SystemAuth será
definido automaticamente para no.
Exemplo: SystemAuth=yes.
LockDir
Especifica o diretório onde serão gravados os arquivos de lock. Caso não seja especificado,
será usado o diretório do CVS.
Exemplo: LockDir=/var/lock/cvs
TopLevelAdmin
Permite criar ou não um diretório chamado CVS no root do diretório de trabalho durante o
cvs checkout.
LogHistory
Utiliza opções para especificar o que será registrado nos arquivos de log do CVS.
• TOFEWGCMAR ou all
Registra todas as operações nos logs do cvs.
• TMAR
Registra todas as operações que modificam os arquivos “,v”
17.4.2 modules
Especifica opções e programas externos que serão usados durante a execução de comandos no
repositório CVS.
17.4.3 cvswrappers
Este arquivo define ações de controle de características de arquivos, de acordo com seu nome.
Pode ser também definidas ações através de arquivos .cvswrappers.
17.4.4 commitinfo
Define programas para fazer uma checagem baseada no diretório e dizer se o commit é permitido.
17.4.5 verifymsg
Especifica o programa usado para verificar as mensagens de log.
17.4.6 loginfo
Programa que é executado após o commit. Ele pode ser usado para tratar a mensagem de log e
definir onde ela será gravada/enviada, etc.
17.4.7 cvsignore
Tudo que constar neste arquivo não será gravado (commit) no cvs. Referências globais podem ser
usadas para especificar estes arquivos. Veja a info page do cvs para detalhes sober seu formato.
Pode também ser especificado através de arquivos .cvsignore.
17.4.8 checkoutlist
Especifica os arquivos que deseja manter sobre o controle do CVS que se encontram em CVSROOT.
Se adicionar um script adicional, ou qualquer outro arquivo no diretório CVSROOT ele deverá
constar neste arquivo.
17.4.9 history
É usado para registrar detalhes do comando history do CVS.
17.5 Clientes de CVS
Esta seção traz alguns programas cliente em modo texto/gráfico e visualizadores de repositórios via
web. Eles facilitam o trabalho de controle de revisão por parte de iniciantes e flexibilidade para
pessoas mais experientes, além de ter uma interface de navegação disponível para todos os
interessados em fazer pesquisas no repositório.
17.5.1 cvs
Este é o cliente Unix padrão, bastante poderoso e que opera em modo texto. As explicações neste
capítulo do guia assumem este cliente de cvs, então as explicações sobre sua utilização se encontra
em Criando projetos para serem usados no CVS, Seção 17.3 e os parâmetros de linha de comando
em Opções de linha de comando, Seção 17.1.10
É altamente recomendável a leitura caso deseje utilizar um cliente de cvs gráfico, pois os
conceitos são os mesmos.
17.5.2 gcvs – Linux
Este é um cliente CVS em GTK+Python para Linux que interage externamente com o cliente cvs
externo, todas as opções do cvs estão disponíveis através de checkboxes nas telas de comando,
incluindo suporte a compactação, visualizador gráfico da árvore de releases, histórico, diffs, etc.
Sua instalação é bastante fácil, instale o programa com apt-get install gcvs e execute o
programa através do menu do sistema ou do terminal. Utilize os seguintes procedimentos para
configurar e utilizar o programa:
• Defina o repositório CVSROOT através do menu Admin/Preferences. Selecione o método de
acesso, entre com o login, servidor e repositório.
Exemplo: :pserver:anonymous@servidor:/var/lib/cvs
O formato deve ser EXATAMENTE como o usado na variável CVSROOT no shell, incluindo os “:”.
Caso tenha erros de login, verifique o valor de CVSROOT cuidadosamente antes de contactar o
administrador de sistemas!
• Agora faça o login no sistema em: Admin, Login. Note que o status de todas as operações do
cvs são mostradas na janela de status que fica na parte inferior da tela.
• Crie um diretório que será usado para armazenar os fontes baixados do CVS, por exemplo:
mkdir ~/projetos
• Acesse o menu Create, Checkout Module para baixar o projeto do CVS para sua máquina
local. Ele irá te pedir o nome de diretório para onde o código fonte do servidor CVS será
baixado. Digite ~/projetos ou outro diretório que foi criado no passo anterior.
OBS: Não utilize o nome “cvs” para o diretório local, pois o gcvs oculta automaticamente pois
os arquivos administrativos de controle ficam neste local.
• Altere o diretório padrão do gcvs para o diretório onde baixou o projeto
(~/projetos)clicando no botão “set” no topo da coluna esquerda do gcvs.
• Para enviar um arquivo modificado de volta ao servidor, selecione os arquivos, clique em
Modify, Commit Selection, entre com a mensagem descrevendo as alterações e clique em
“OK”.
Note que os arquivos modificados serão identificados por um ícone vermelho e seu status será
“Mod. File” (arquivo modificado).
• Se desejar adicionar um novo projeto no CVS, entre em Create, Import Module, entre no
diretório que deseja adicionar como um projeto no servidor de CVS. Após isto será feita
uma checagem e mostrada uma tela de possíveis problemas que podem ocorrer durante a
importação do novo projeto.
Na próxima tela, digite o nome do módulo e caminho no servidor remoto no primeiro campo, no
segundo campo a mensagem de log para adicionar o projeto ao servidor. Em “Vendor tag”
especifique o nome do projeto e sua versão logo abaixo. Clique em “OK” e aguarde a transferência
dos arquivos para o servidor.
Para maiores detalhes sobre a criação de novos projetos no servidor de CVS, veja Adicionando um
novo projeto, Seção 17.3.6.
OBS: Você deverá ter permissão de gravação para criar um novo projeto no servidor CVS.
• A partir de agora você poderá explorar as funções do programa e fazer uso das funções
habituais do CVS. Todas as funções de operação e opções extras do CVS estão disponíveis
na interface gráfica, basta se acostumar com sua utilização.
Após isto, explore bastante as opções do programa. Todas as funcionalidades do CVS estão
organizadas entre os menus do programa. Caso não entenda bem as funções do programa, leia
atentamente Criando projetos para serem usados no CVS, Seção 17.3 e também não deixe de
consultar detalhes na info page do cvs.
17.5.3 WinCVS – Windows
Este é um cliente CVS em Python para Windows equivalente ao gcvs para Linux. Suas
funcionalidades e recomendações são idênticas aos do gcvs. Este cliente pode ser baixado de:
http://telia.dl.sourceforge.net/sourceforge/cvsgui/WinCvs13b13.zip
e o Python para Windows de
http://starship.python.net/crew/mhammond/downloads/win32all-
153.exe.
Para sua utilização, as explicações em gcvs – Linux, Seção 17.5.2 são totalmente válidas.
17.5.4 MacCVS – Macintosh (PPC)
Idêntico ao gcvs, pode ser baixado de
http://telia.dl.sourceforge.net/sourceforge/cvsgui/MacCvsX-3.3a1-
1.dmg.
17.5.5 viewcvs
Este é um visualizador de repositórios CVS via web, ele precisa apenas de um servidor web
instalado com suporte a CGI. Para instalar, execute o comando apt-get install viewcvs e
siga os passos para configurar programa. Para adequar melhor o viewcvs ao seu sistema, edite o
arquivo /etc/viewcvs/viewcvs.conf.
O viewcvs possui uma interface que se parece com a navegação de um diretório de ftp, recursos
como a extração de diffs coloridos entre versões de um arquivo selecionado, visualização de
commits (com data, log do commit, usuário, etc.), classificação da listagem exibida.
OBS:Leve em consideração as implicações de segurança impostas por aplicativos cgi sendo
executados em seu sistema. Veja Apache, Capítulo 12 para entender melhor o assunto.
17.6 Exemplo de uma seção CVS
Nota: este exemplo é apenas didático, não foi feita nenhuma modificação real no conteúdo do
repositório do dillo 🙂
# Definir o CVSROOT
export CVSROOT=:pserver:[email protected]:/var/lib/cvs
# entrar no servidor
gleydson@host:/tmp/teste$ cvs login
Logging in to :pserver:[email protected]:2401/var/lib/cvs
CVS password: <password>
gleydson@oberon:/tmp/teste$
# Pegar o módulo “dillo do cvs”
cvs -z 3 co dillo
cvs server: Updating dillo
cvs server: Updating dillo/CVSROOT
U dillo/CVSROOT/checkoutlist
U dillo/CVSROOT/commitinfo
U dillo/CVSROOT/config
U dillo/CVSROOT/cvswrappers
U dillo/CVSROOT/editinfo
U dillo/CVSROOT/loginfo
U dillo/CVSROOT/modules
U dillo/CVSROOT/notify
U dillo/CVSROOT/rcsinfo
U dillo/CVSROOT/taginfo
U dillo/CVSROOT/verifymsg
cvs server: Updating dillo/CVSROOT/Emptydir
cvs server: Updating dillo/dillo
U dillo/dillo/AUTHORS
U dillo/dillo/COPYING
U dillo/dillo/ChangeLog
U dillo/dillo/ChangeLog.old
U dillo/dillo/INSTALL
U dillo/dillo/Makefile.am
U dillo/dillo/Makefile.in
U dillo/dillo/NEWS
U dillo/dillo/README
U dillo/dillo/aclocal.m4
U dillo/dillo/config.h.in
U dillo/dillo/configure
U dillo/dillo/configure.in
U dillo/dillo/depcomp
U dillo/dillo/dillorc
U dillo/dillo/install-sh
U dillo/dillo/missing
U dillo/dillo/mkinstalldirs
U dillo/dillo/stamp-h.in
cvs server: Updating dillo/dillo/doc
U dillo/dillo/doc/Cache.txt
U dillo/dillo/doc/Cookies.txt
U dillo/dillo/doc/Dillo.txt
U dillo/dillo/doc/Dw.txt
U dillo/dillo/doc/DwImage.txt
U dillo/dillo/doc/DwPage.txt
…
# Modifica o arquivo do projeto
cd /dillo/dillo/doc
vi Cache.txt
# Update no arquivo para atualizar a cópia local com a remota
cvs update Cache.txt
M Cache.txt
gleydson@host:/tmp/teste
# Damos o commit no arquivo
cvs commit Cache.txt
# Saimos do sistema
cvs logout
