02-cvs-1.pdf

USANDO CVS
Unidad II
Dra. Rafaela Blanca Silva López
Mtro. Hugo Pablo Leyva

Contenido
Explicar los beneficios de
usar cvs.
Describir el ciclo de vida
cvs.
Implementar las palabras
clave cvs en headers.

Introducción
Al desarrollar un proyecto de software, rara vez se
termina con la primera versión.
Por lo regular se realizan varias versiones, hasta
cumplir los objetivos del sistema.
Comúnmente el programador saca una copia del
archivo y la modifica para crear una versión nueva.
Concurrent Version System, es un software libre
cuya función es gestinar versiones.

CVS
Permite que varios programadores trabajen con un archivo
sin interferirse mutuamente.
Maneja directorios en vez de archivos separados.
Bitácora para obtener alguna versión en función de la fecha
y hora.
Acepta archivos binarios.
Soporta varios métodos de acceso, inclusive remotos.
Tiene mecanismos de seguridad.

Terminología usada
Proyecto: Un
archivo o conjunto
de archivos
puestos bajo el
control de CVS.
Repositorio: Es un
árbol de archivos
que almacena la
versión original en
un servidor central.
Guarda la
historia
completa de
las
modificaciones
que ha tenido.
Cada proyecto
tiene
exactamente
un repositorio.
Copia de trabajo:
Es una copia de la
ultima versión de
archivo, con la
cual se va a
trabajar.
Puede ser
también de
alguna versión
especifica.
Cada
desarrollador
puede tener su
propia copia
de trabajo.
Conflicto: Cuando
2 o mas
programadores
desean hacer
cambios a la
misma zona del
mismo archivo.
CVS avisa de su
existencia pero
los
desarrolladores
deben de
resolverlo.

Terminología usada
Revisión: Es una "foto" de
los cambios que ha habido
en archivo(os).
Check out (Chequeo):
Solicitar una copia de
trabajo del repositorio.
Commit (Consolidar) o
Check in: Enviar los
cambios de la copia de
trabajo al repositorio
central.
Log message (Mensaje de
bitácora): Un comentario
que se le agrega a una
revisión al momento de
hacer el commit.
•Describe los cambios
realizados.
Update (Actualizar):
Reflejar los cambios que ha
habido en el proyecto en
la copia de trabajo y
mostrar si hay cambios que
no se les halla hecho
commit.

Invocación de CVS
´ CVS es un programa que puede realizar diversas
acciones para el control de versiones de un
proyecto de software.
´ Se debe de invocar con el comando de la acción
deseada.
$ cvs [-opciones globales] comando [-opciones
especificas]
´ Las opciones globales modifican en general el
comportamiento de CVS.
´ Las opciones especificas modifican el
comportamiento del comando en particular que se
ejecute.

Acceder al
repositorio
´ En CVS se debe de indicar la ubicación
del repositorio a emplear.
´ Se usa la variable de ambiente
CVSROOT o la opción global -d.
´ En ambos casos se debe de emplear
rutas absolutas para indicar el
repositorio a usar.
$ export CVSROOT=/usr/local/cvs (En ksh)
% setenv CVSROOT /usr/local/cvs (En csh)
$ cvs -d /usr/local/cvs

Acceder al
repositorio
´ Para crear un repositorio local se usa
el comando:
´ $ cvs -d /usr/local/cvs/repositorio init
´ Para el caso de uso
´ $ cvs -d /home/souser01/ec4/cv init
´ El directorio PATH/repositorio debe
de existir previamente.
´ Si no hay problemas se creara en el
directorio en cuestión el subdirectorio
CVSROOT, el cual NO debe de
confundirse con la variable de
ambiente CVSROOT.

Iniciando
un
proyecto
de cvs
´ Para crear un proyecto que este
bajo el control de CVS el comando
es:
´ $ cvs import -m "log message"
proyecto vendortag releasetag
´ Este comando debe de ejecutarse
dentro del directorio que tiene los
archivos que formaran parte del
proyecto.
´ El repositorio debe de especificarse
ya sea con la variable de ambiente
CVSROOT o con la opción global -d.

Iniciando un proyecto de cvs
proyecto es el nombre del proyecto que se esta
creando, por lo regular coincide con el nombre del
directorio que tiene los archivos del proyecto.
vendortag normalmente es el login del usuario.
releasetag es normalmente start.
log message es un texto que indica los comentarios
pertinentes a la versión que se esta creando del
proyecto. Este comentario es obligatorio.
Sin el CVS ejecutaría el editor definido en la
variable EDITOR (por lo regular vi) para que el
usuario especifique el comentario

Iniciando
un
proyecto
de cvs
´ Para nuestro caso de uso
$ cvs -d /home/mn-8-01/ec4/cv
import -m "Primer importación en CVS"
fuente mn-8-04 start
´ Le agrega una letra N indica que
el los archivos son nuevos para el
proyecto.
´ En este momento el directorio
original ya no es necesario, ya que
todos los archivos se hallan bajo el
control de CVS.
´ Es recomendable mover o borrar el
directorio fuente original para no
confundirlo con la copia de
trabajo.

Iniciando
un
proyecto
de cvs
$ pwd
/home/souser01/ec4/fuente
$ cd ..
$ pwd
/home/souser01/ec4
$ mv fuente fuente_old

Generando
una copia
de trabajo
´ $ cvs checkout proyecto
´ Generará una copia de trabajo de
la última versión del proyecto.
´ Se debe ejecutar en el directorio
padre que contenía al directorio
original.

Generando
una copia
de trabajo
$ cvs -d /home/souser01/ec4/cv checkout
fuente
cvs checkout: Updating fuente
cvs checkout: Updating fuente/ec4
´ Una letra U indica que se esta realizando
una actualización de la copia de trabajo.
´ Como no existía una esta se crea.
´ La diferencia que existe con el directorio
original es la presencia de un directorio CVS
en cada directorio del proyecto.
´ El termino repositorio es el directorio que
contiene varios proyectos.
´ En otras ocasiones se refiere al subdirectorio
de un proyecto especifico.

Haciendo Modificaciones
´ Una vez que se genera una copia de trabajo esta se
modifica por parte del programador.
´ Si el programador es interrumpido y reanuda su trabajo
tiempo después, es posible que no recuerde que cambios
hizo.
´ Por lo anterior no sabrá si conviene o no hacer el commit
de los cambios que tiene en ese momento.
´ Para resolver este problema puede comparar su copia de
trabajo contra la versión que se halla en el repositorio.

Haciendo
Modificaciones
´ Para ver que cambios se usa el
comando update:
$ cvs update
$ cvs -d /home/souser01/ec4/cv update
cvs update: Updating
M compilar.sh
´ M indica que el archivo ha sido
modificado y que las modificaciones no
se les ha hecho commit.
´ Para obtener información mas
especifica se usa el comando diff.
$ cvs diff

Haciendo Modificaciones
$ cvs -d /home/souser01/ec4/cv diff
cvs diff: Diffing .
´ Para ver la versión anterior con la actual se usa las
opciones -Q y -c
$ cvs -Q diff -c

Haciendo
Modificaciones
$ cvs -Q -d /home/souser01/ec4/cv diff
–c
´ Si lo deseas puedes comparar
únicamente el archivo que te
interesa.
$ cvs -d /home/souser01/ec4/cv diff -c
compilar.sh

Enviando
los
cambios
al CVS
´ Para hacer permanentes los cambios en
el CVS creando una versión nueva se
emplea el comando commit:
$ cvs commit -m "log message"
´ El log message es un mensaje alusivo a
la creación de la nueva versión.
$ cvs -d /home/souser01/ec4/cv commit -
m "Versión Nueva del script Shell de
Compilación de grado0”
´ Es Posible hacer el commit de solo un
archivo.
$ cvs commit -m "log message" archivo

Números de revisión
Como se puede observar
al hacer commit se
incrementa el número de
versión de los archivos
modificados, no de todos
los archivos.
Al crear una copia de
trabajo siempre se trae
las versiones mas altas de
los archivos.

Formas
cortas de
los
comandos
´ co por checkout
´ di por diff
´ ci por commit
´ up por update
$ cvs --help-synonyms

Checando
el estado
de un
archivo
´ Para ver como van los números de
revisión de un archivo usa el
comando status
$ cvs status archive
$ cvs -d /home/souser01/ec4/cv status

Detectando y Resolviendo
Conflictos
´ Un conflicto surge cuando 2 programadores generan sus
copias de trabajo, y cada quien por separado hace
cambios.
´ Estas copias al hacer commit por separado generarían la
misma versión, lo cual es un conflicto.
´ Para detectar un conflicto se usa los comandos status,
diff y update.
$ cd /tmp
$ cvs -d /home/souser01/ec4/cv checkout fuente

Detectando
y
Resolviendo
Conflictos
´ Se edita el archivo compilar.sh en
ambas copias de trabajo y se hará
commit en la de /tmp
$ cd fuente/grado0
$ vi compilar.sh
$ cvs -d /home/hpl/ec4/cv commit -m
"Nueva Versión de compilar.sh”
´ En la otra copia de trabajo se
editara el mismo archivo
$ vi compilar.sh

Detectando
y
Resolviendo
Conflictos
´ Revisando el estado
compilar.sh
´ Actualizando el proyecto
$ cvs -d /home/souser01/ec4/cv
update compilar.sh
´ Se registra que existe un conflicto.
´ Para resolver el conflicto hay que
revisar las diferencias entre la versión
de la copia de trabajo y la del
repositorio
$ cvs -d /home/souser01/ec4/cv diff -c
compilar.sh

Detectando
y
Resolviendo
Conflictos
´ Para resolver el conflicto hay que
decidir si dejar nuestros cambios o
los del otro programador.
´ Para ello editamos el archivo y
eliminamos lo que consideremos
necesario hacemos commit.
commit -m "Versión Nueva del script
Shell de Compilación de grado0 sin
conflicto“
compilar.sh
´ Si decidimos dejar nuestros cambios
se generara una nueva versión.

Revisando que ha ocurrido y
quién realizó cambios
´ Para checar el histórico de lo que ha ocurrido revisamos la bitácora
con el comando
´
$ cvs log
$ cvs -d /home/souser01/ec4/cv log
´ Para un solo archivo
$ cvs -d /home/souser01/ec4/cv log compilar.sh

Examinando
y revirtiendo
cambios
´ Para revisar las diferencias precisas entre
2 versiones se usa el comando diff
$ cvs diff -c -r versión1 -r versión2 archivo
$ cvs -d /home/souser01/ec4/cv diff -c -r
1.11 -r 1.10 compilar.sh
´ Para regresar a una versión especifica
primero actualizamos y después otra vez
con update regresamos a alguna versión
en particular

Examinando
y revirtiendo
cambios
update compilar.sh
update -p -r 1.10 compilar.sh
´ Estos comandos lo muestra en la
salida estándar
´ Para traer de vuelta la versión se
redireciona la salida y se actualiza
$ cvs -d /home/souser01/ec4/cv -Q
update -p -r 1.10 compilar.sh >
compilar.sh
update compilar.sh

Examinando
y revirtiendo
cambios
´ Para revisar que realmente se ha regresado a
la versión anterior podemos usar el comando
diff
$ cvs -d /home/souser01/ec4/cv diff -c compilar.sh
´ Ahora hacemos un commit
$ cvs -d /home/souser01/ec4/cv commit -m
"Volviendo a la versión 1.10 ”
´ Otra forma de hacerlo es con la opción j del
comando update
$ cvs -d /home/souser01/ec4/cv update -j 1.12 -j
1.11 compilar.sh
$ cvs -d /home/souser01/ec4/cv update
compilar.sh
$ cvs -d /home/souser01/ec4/cv commit -m
"Volviendo a la versión 1.11 "

Agregando nuevos archivos
´ Usa el comando add
$ cvs add archivo
$ cvs -d /home/souser01/ec4/cv add LEE.PORFA
´ Agregar directorios es similar
$ mkdir subdirectorio
$ cvs -d /home/souser01/ec4/cv add subdirectorio

CVS y
archivos
binarios
´ Se puede manejar archivos binarios pero
con algunas precauciones.
´ CVS maneja lo que se conoce como
cadenas palabras clave CVS.
´ Estas cadenas se expanden
automáticamente para incluir
información útil como el número de
versión $Revision$
´ En un archivo binario por casualidad
podría aparecer alguna cadenas de
estas y expanderse corrompiendo el
archivo binario.
´ Para evitarlo se usa la opción -kb en el
comando add
$ cvs -d /home/souser01/ec4/cv add -kb
imagen.png
m "Agregando imagen.png "

CVS y
archivos
binarios
´ Para deshabilitar la expansión en
archivos de texto usa la opción -ko
$ cvs add -ko archivoTexto
´ diff no funciona bien con archivos
binarios.

Borrando
archivos
´ Se borra la copia de trabajo y se usa el
comando remove
$ rm LEE.PORFA
$ cvs -d /home/souser01/ec4/cv remove
LEE.PORFA
m "Eliminando LEE.PORFA "
´ Para directorios se deben vaciar y borrar
los archivos.
´ Después del commit se debe hacer un
update desde el directorio con la opción
-P
$ cvs -d /home/souser01/ec4/cv update -P

Renombrando
archivos y
directorios
´ Se renombra el archivo, se borra el
anterior y se agrega el nuevo. Por ultimo
se hace un commit con los 2 nombres
del archivo
$ mv LEE.ME LEER.PORFA
$ cvs -d /home/souser01/ec4/cv remove
LEE.ME
$ mkdir newdir
$ cvs add newdir
$ mv olddir/* newdir
mv: newdir/CVS: cannot overwrite directory
$ cd olddir

Renombrando archivos y
directorios
$ cvs rm archivo1 archivo2 ...
$ cd ../newdir
$ cvs add archivo1 archivo2 ...
$ cd ..
$ cvs commit -m "moviendo del directorio antiguo al nuevo "
$ cvs update –P
Para subdirectorios se mueven los archivos del viejo antiguo directorio al
nuevo, borrarse los archivos del antiguo y del proyecto, agregarlos otra
vez en el nuevo directorio y hacer update con la opción -P

Configuración
de CVS
´ El archivo de configuración de CVS
puede definir por default con que
opciones se ejecutaran los comandos.
´ Este archivo es .cvsrc y debe de estar en
el home del usuario.
$ cat .cvsrc
diff -c
cvs -d /home/souser01/ec4/cv –Q
´ Este archivo indica que siempre diff se
correrá con la opción -c.
´ También indica que siempre se usara la
opción -Q y que el repositorio será
/home/souser01/ec4/cv

Obtener
versión
particular
por fecha
hora
´ Se usa update con la opción -D
$ cvs -q update -D "año-mes-día”
´ Ejemplo
$ cvs -d /home/souser01/ec4/cv -q update -D
"2000-05-22"
´ Para verificarlo usamos la opción status
compilar.sh
´ Podemos ser mas específicos fijando la hora
también.
"2000-05-23 03:27:47“
compilar.sh

Obtener
versión
particular
por fecha
hora
´ La discrepancia en la hora es por que CVS
usa la hora de Greenwich NO la hora local.
´ Para indicar que usa la de Greenwich hay
que indicárselo.
"2000-05-28 02:12:55 GMT“
compilar.sh
´ Si hacemos ahora un update notaremos
qué NO trae la ultima versión si no la del
pasado
$ cvs -d /home/souser01/ec4/cv -q update
compilar.sh

Obtener
versión
particular
por fecha
hora
´ Si editamos un archivo e intentamos
el commit marcara error:
$ vi compilar.sh
commit -m "Nueva versión 1.3 ”
´ Podemos actualizar con la opción -A
en update
$ cvs -d /home/souser01/ec4/cv -q
update -A

Obtener
versión
particular
por fecha
hora
´ Editando eliminamos el conflicto
$ vi compilar.sh
commit -m "Nueva versión 1.13

Formatos
de
fechas
´ Consulta las direcciones:
´ www.saqqara.demon.co.uk/datefmt.htm
´ www.rfc-editor.org/rfc/
´ Algunos formatos validos son:
$ cvs update -D "19 Apr 1999"
$ cvs update -D "19 Apr 1999 20:05"
$ cvs update -D "19/04/1999"
$ cvs update -D "3 days ago"
$ cvs update -D "5 years ago"

Formatos
de
fechas
$ cvs update -D "19 Apr 1999 23:59:59
GMT"
$ cvs update -D "19 Apr”
´ Podemos incluir una etiqueta para
hacer mas fácil buscar alguna
versión en particular
$ cvs -d /home/souser01/ec4/cv -q tag
Version-2000_05_28
´ Para traer una copia de trabajo con
la etiqueta respectiva usamos la
opción -r en el comando checkout.
´ Debemos de irnos primero al
directorio apropiado.

Formatos de fechas
$ cd ..
$ cd ..
$ cvs -d /home/souser01/ec4/cv checkout -r Version-2000_05_28
$ cvs -d /home/souser01/ec4/cv checkout -r Version-2000_05_28 Fuente
´ Para ver las diferencias con alguna etiqueta en particular incluye la
opción -r en el comando diff .
´ Si hacemos una nueva versión marcara error al hacer el commit.
´ Para areglarlo usamos la opción -A del update y hacemos commit.

Formatos de fechas
$ vi compilar.sh
$ cvs -d /home/souser01/ec4/cv commit -m "Nueva versión
1.14 “
$ cvs -d /home/souser01/ec4/cv -q update –A
$ cvs -d /home/souser01/ec4/cv commit -m "Nueva versión
1.14 "

Sustitución de Palabras
Clave
´ Es útil incluir dentro del código fuente información
relevante a la hora, fecha, versión, autor, etc.
que halla trabajado en alguna versión en
particular.
´ Hacer esto a pie puede ser tedioso y difícil.
´ CVS puede hacer esto por nosotros, incluir
información relativa a quien trabajo en alguna
versión particular. Para hacer esto se deben
incluir las Palabras clave RCS.
´ Estas se escriben entre 2 signos de $

Sustitución de Palabras Clave
$Date$ ==> date of last commit, expands to ==>
$Id$ ==> filename, revision, date, and author; expands to ==>
$Revision$ ==> exactly what you think it is, expands to ==>
$Source$ ==> path to corresponding repository file, expands
to ==>
$Log$ ==> accumulating log messages for the file, expands to
==>

Otros
métodos
de
conexión
´ Para usar SSH se define la variable de
ambiente
´ CVS_RSH=ssh
´
´ Para rsh
´ CVS=rsh

Otros métodos de conexión
´ Para usar SSH se define la variable de ambiente
´ CVS_RSH=ssh
´ Para rsh
´ CVS=rsh
$ CVS_RSH=rsh; export CVS_RSH
$ cvs -d :ext:souser01@esystem.azc.uam.mx:/home/souser01/cvs
command

Caso de estudio
Dar de alta
en CVS el
directorio
fuente de
nuestro
proyecto.
Borra el
directorio
original
Recupéralo a
partir del
repositorio.
Practica lo
expuesto en
este material.
1 2
3
4

02-cvs-1.pdf

Recomendados

Recomendados

Más contenido relacionado

Similar a 02-cvs-1.pdf

Similar a 02-cvs-1.pdf (20)

Último

Último (20)

02-cvs-1.pdf