Control de Versiones

Versión en Borrador 534 (Mon Dec 5 17:02:10 2005)

Problema #1: Sincronización de Archivos

Quiere trabajar un conjunto de archivos en tres diferentes máquinas.
- Casa, oficina, donde un amigo
Opción 1: usar un sistema de archivos compartidos.
- Difícil de configurar.
  - e incluso más difícil de asegurar.
- Inflexible: qué si usted está en el camino?
Opción 2: Cargar un floppy o un llavero USB
- Ha recordado copiar sus archivos en el recientemente
- Qué pasa si su proyecto es muy grande?
Opción 3: mail, FTP, SCP, etc.
- Aún tiene que recordar sacar y poner exactamente los mismos archivos en el tiempo exactamente correcto.
Opción 4: Lograr que el computador haga el trabajo.
- Mantiene una copia maestra en un sólo sitio.
- Usa un programa para sincronizar las copias de trabajo cuando y como es requerido.

Problema #2: Deshacer Cambios

A menudo quiere deshacer cambios a un archivo.
- Empieza un trabajo, se da cuenta que es el enfoque incorrecto, quiere devolverse al punto de inicio.
- Como "deshacer" en un editor de texto...
- ... pero una más larga vida es mantenida para toda la historia de cualquier archivo, para siempre.
- Cuando se trabaja en equipos, quiere saber lo que sus compañeros hicieron.
- Los errores son más probables en el código fresco que en el código que se ha estado ejecutando por largo tiempo.

Solución: Control de Versiones

Solucione ambos problemas de una vez usando un sistema de control de versiones (SCV)
Mecánica
- Mantiene una copia maestra de cada archivo en un repositorio central.
  - De hecho, mantiene una copia de todas las versiones antiguas de cada archivo.
- Cada uno en el equipo de trabajo hace su trabajo en una copia de trabajo
  - Cuanto usted está listo para compartir sus cambios, los envia al repositorio.
    - El SCV guarda la vieja versión del archivo, entonces escribe sus cambios arriba.
      - También almacena la hora del cambio, quien lo hizo, y un comentario.
    - Tome un vistazo en un momento de qué pasa si dos o más personas intentan hacer un cambio al mismo tiempo.

CVS y Subversion

Dos sistemas de control de versiones en amplio uso.
- Muchos otros están disponibles comercialmente.
- por ejemplo está Perforce.
- CVS (Concurrent Version System, Sistema de Versiones Concurrentes)
- Inventado en los ochentas.
- Muy popular, pero está mostrando su edad.
- Falla #1: Mantiene una huella de cada archivo separadamente.
  - Pero los autores a menudo cambian varios archivos en tandem.
  - Cómo CVS no tiene noción de un envío en batch, no hay una forma confiable de decir, "Qué otros cambios fueron hechos en conjunción con este otro?"
- Falla #2: Usted puede crear nuevos directorios, pero no puede nunca borrar los viejos.
Subversion.
- Diseñado como un remplazo compatible hacia atrás para CVS empezando en 2000
- Arregla dos de las principales fallas en CVS
- Muchos proyectos de código abierto han cambiado, o están cambiando...
- ... así que lo usaremos en este curso.
- Mire en sitio de Subversion para más detalles

Uso Básico

Asuma por un momento que un repositorio ha sido creado y que Ron y Hermione ya tiene copias de trabajo.
- Mire abajo cómo hacer esto.
Ron quiere hacer cambios en una simulación de giro de motor.
- Ejecuta svn update para poner su copia en actualizada con el repositorio.
- Edita spin.c y spin.h
- Ejecuta svn commit para guardar esos cambios en el repositorio
  - Nota: Todo el repositorio adquiere un nuevo número de versión
Ron se da cuenta que olvido hacer un cambio
- Ejecuta svn update de nuevo, sólo en caso de que Hermione haya estado haciendo cambios también (no lo ha estado)
- Edita spin.c de nuevo.
- Ejecuta svn commit por segunda vez
Varias horas después, Hermione ejecuda svn update en su copia de trabajo.
- Subversion copia los cambios de Ron en el directorio de ella
  Figura 1: Uso Basico

Cómo usarlo

Una forma de usar Subversion es teclear comandos en una consola.
- Funciona garantizado sin nada más siendo instalado
- Pero hay buenas interfaces gráficas para Subversion también
RapidSVN corre en Windows, Linux y Mac
- Bueno, tal vez "camina" es una mejor descripción de la Versión 0.9, no es la cosa más rápida en el mundo.
  Figura 1.2: RapidSVN
- TortoiseSVN es una extensión de consola para Windows.
  - Lo que significa que se integra bien con el explorador de archivos de Windows, en lugar de ejecutarse separadamente.
  - Pero también significa que no funciona sobre Linux o Mac
    Figura 1.3: TortoiseSVN
- Y si está en un Macintosh, está SmartSVN

Trabajando Juntos

Qué si dos (o más personas) quieren editar el mismo archivo al mismo tiempo?
- Opción 1: prevenirlo.
  - Sólo permitir a una persona tener una copia escribible del archivo a la vez.
  - Concurrencia pesimista.
  - Microsoft Visual SourceSafe
- Opción 2: Parchar después.
  - Concurrencia optimista.
  - "Es más fácil obtener perdón que permiso"
  - CVS, Perforce, Subversion
    Figura 1.4: Conflictos de mezcla

Ron y Hermione tiene ambos copias de spin.c versión 15

            int maxRotateSetting(int * available, int length)
            {
                int i, maxFound;
                if (length == 0) {
                    return 0;
                }
                for (i=0; i<length; i+=1) {
                    if (available[i] > maxFound) {
                        maxFound = available[i];
                    }
                }
                return maxFound;
            }

Ron envia sus cambios.

Crea spin.c version 16

            // Find maximum rotation setting from those available,
            // or 0 if none are available.
            int maxRotateSetting(int * available, int length)
            {
                int i, maxFound;
                if (length == 0) {
                    return 0;
                }
                for (i=0; i<length; i+=1) {
                    if (available[i] > maxFound) {
                        maxFound = available[i];
                    }
                }
                return maxFound;
            }

Mientras tanto, Hermione está editando su copia, y produce esto:

            // Find maximum rotation setting, or 0.
            int maxRotateSetting(int * available, int length)
            {
                int i, maxFound = 0;
                for (i=0; i<length; i+=1) {
                    if (available[i] > maxFound) {
                        maxFound = available[i];
                    }
                }
                return maxFound;
            }

Trata de enviar sus cambios: conflicto!
- Subversion pone los cambios de Ron y Hermione con marcadores en la copia de trabajo de Hermione
  - ```
        <<<<<<< .mine
        // Find maximum rotation setting, or 0.
        =======
        // Find maximum rotation setting from those available,
        // or 0 if none are available.
        >>>>>>> .r471
        int maxRotateSetting(int * available, int length)
        {
            int i, maxFound = 0;
            for (i=0; i<length; i+=1) {
                if (available[i] > maxFound) {
                    maxFound = available[i];
                }
            }
            return maxFound;
        }
```
- También crea spin.c.mine, spin.c.15, y spin.c.16 como referencia
- Hermione tiene que decidir qué se deja y qué se quita
  - Subversion no le permitirá enviar sus cambios hasta que todas las marcas de conflicto hayan sido eliminadas
- Una véz Hermione termina sus cambios, ella:
  - Ejecuta svn resolved spin.c para decirle a Subversion que el conflicto se ha resuelto
  - Ejecuta svn commit spin.c para crear create spin.c versión 17

Lo que Quiere Decir Versión Realmente

La discusión anterior se refiere a “la versión 16 de spin.c”, pero de hecho no es tal cosa
Al contrario, es la versión 16 (o 17, o 18…) de el repositorio
- Se supone que los usuarios intentan mantener los archivos en el repositorio en un estado consistente
  - Ej., no envíe cosas que están medio hechas
  - Porque la siguiente persona en hacer un update estaría entonces en el mismo estado medio-hecho en el que usted está
- Por lo tanto Subversion actualiza el número de versión de el repositorio entero cada vez que un conjunto de cambios es enviado
  - Cada conjunto de cambios puede afectar cualquier cantidad de archivos (incluyendo adicionar o eliminar archivos)
- La frase “versión 229” por lo tanto identifica un conjunto total de archivos
  - A diferencia de CVS y otros sistemas, en donde la versión 319 de un archivo puedo corresponder a la versión 107 de otro, y a la versión 794 de un tercero

Atención: Archivos Binarios

Subversion solo puede marcar conflictos de esta manera en archivos de texto
- Ej., arhivos que almacenan líneas de caracteres que los humanos pueden leer
- Código fuente, HTML, basicamente cualquier cosa que pueda editar con Notepad, Vi, o Emacs
En imágenes, video clips, Microsoft Word, y en muchos otros formatos no
- Cuando ocurre un conflicto, Subversion guarda su copia y la copia maestra lado a lado en su directorio de trabajo
- Usted debe resolver las diferencias

Deshaciendo Cambios

Asuma que Ron decide que no le gustan los cambios recientes
- svn diff le mostrará que archivos él ha cambiado, y cuales son esos cambios
- Él no ha enviando nada más, así que puede usar svn revert para re-sincronizarse con la copia maestra
- Sí usted se encuentra haciendo esto repetidamente, probablemente debe ir y hacer algo diferente por un rato…
Ahora asuma que Ron decide que no le gustan los cambios que Hermione acaba de hacer a spin.c
- Quiere hacer el equivalente de “deshacer” en varios archivos
- svn log muestra la historia reciente
- Él decide que quiere volver a la versión 16 del repositorio
- svn merge -r 17:16 spin.c quiere decir “mezcle los cambios, desde la versión 17 a la versión 16” (ej., hacia atrás)
  - Puede obviamente ir incluso a versiones más antiguas para deshacer más cambios

Figura 3.5: Deshaciendo Cambios

Y Finalmente, Cómo Empezar

Crear un repositorio:
- Decida en donde ponerlo (ej., /rotor/repo)
- Vaya al directorio que lo contenderá: cd /rotor
- svnadmin create repo
Puede interactuar con el repositorio de dos maneras
- Directamente a través del sistema de archivos: file:///rotor/repo
  - Úselo sí está trabajando en la misma máquina en la que el repositorio está
- A través de un servidor web: https://your.host.name/rotor/repo
  - Úselo sí su repositorio está en una máquina remota
  - Nota: requiere que su administrador del sistema configure el servidor web adecuadamente
  - https (en vez de http) quiere decir “use una conexión segura”
Para obtener una copia de trabajo (asumiendo que está usando un servidor web):
- svn checkout https://your.host.name/rotor/repo
- Crea un nuevo directorio repo
  - Es común darle un nombre más informativo usando svn checkout https://your.host.name/rotor/repo rotorproject
- Importante: use svn checkout solo una vez para inicializar su copia de trabajo

Referencia de Comandos Subversion

Nombre	Proposito	Ejemplo
`svn add`	Adiciona archivos y/o directorios al control de versión.	`svn add newfile.c newdir`
`svn checkout`	Obtiene una copia de trabajo fresca de un repositorio.	`svn checkout https://your.host.name/rotor/repo rotorproject`
`svn commit`	Envia cambios de una copia de trabajo a un repositorio (lo contrario de `update`).	`svn commit -m "Comment on the changes"`
`svn delete`	Borra archivo y/o directorios del control de versión.	`svn delete oldfile.c`
`svn help`	Obtener ayuda (en general, o para un comando en particular).	`svn help update`
`svn log`	Muestra la historia de los cambios recientes.	`svn log --verbose *.c`
`svn merge`	Une dos versiones diferente de un archivo en uno.	`svn merge -r 18:16 spin.c`
`svn mkdir`	Crea un nuevo directorio y lo pone bajo control de versión.	`svn mkdir newmodule`
`svn rename`	Renombra un archivo o directorio, registrándolo en la historia.	`svn rename temp.txt release_notes.txt`
`svn revert`	Deshace cambios a la copia de trabajo (Re-sincronizar con el repositorio).	`svn revert spin.h`
`svn status`	Muestra el estado de archivos y directorios en la copia de trabajo.	`svn status`
`svn update`	Trae cambios desde el repositorio a la copia de trabajo (Lo contrario de `commit`).	`svn update`

Tabla 3.1: Comandos cómunes de Subversion

Cómo Leer la Salida de Subversion

svn status compara su copia de trabajo con el repositorio imprimiendo una línea por cada archivo del que vale la pena hablar
```
            $ svn status

            M      spin.c
            MC     readme.txt
```
- spin.c ha sido modificado
- readme.txt ha sido modificado y tiene conflictos
svn update imprime una línea por cada archivo o directorio, hace algo como
- ```
            $ svn update

            A  newspin.c
            U  spin.c
            C  spin.h
```
- newspin.c ha sido añadido
- spin.c ha sido actualizado (alguien más lo modificó)
- Hay un conflicto en spin.h
  - Que tendrá que resolver antes de poder enviar sus cambios

Ramificar y Unir

Algunas veces querrá trabajar en varias versiones diferentes del software al mismo tiempo
- Ejemplo: necesita corregir fallos en la versión 3 mientras hace cambios incopatibles en la versión 4
- O quiere dos grupos de programadores para ser capaces de escribir y probar grandes cambios independientemente, entonces poner las cosas juntas de nuevo
Todos los sistemas modernos de control de versiones le permiten ramificar un repositorio
- Crear un “universo paralero” que es inicialmente igual al original, pero que tiene independencia

Figura 3.6: Ramificando y Uniendo

Mucho mejor que solo copiar todas los archivos fuentes: el sistema de control de versiones recuerda de donde las ramas vinieron, y puede trazar la historia hacia atrás

Puede luego unir los cambios desde una rama a otra
- Ejemplo: corregir un fallo en una rama, unir los cambios en otras ramas que tienen el mismo fallo
- De nuevo, mucho mejor que solo copiar a mano, porque el sistema de control de versiones puede llevar registro de donde las cosas vinieron, y a donde ellas fueron
Atención: mucha gente se sobre-emociona con el ramificado cuando empiezan a usarlo por primera vez
- Seguirle la pista a lo que sucede y en donde, puede ser una sobrecarga de administración considerable
- En pequeños proyectos, es muy raro necesitar más de dos ramas activas

Ejercicios

Ejercicio 3.1:
- Siga las instrucciones que su instructor le de para obtener una copia del repositorio Subversion que usará en este curso. A menos que otra cosa sea indicada, los ejercicios siguientes asumen que ud ha hecho esto, y que su copia de trabajo está en un directorio llamado course. Enviará todos sus ejercicios en este curso añadiendo archivos en su repositorio.
Ejercicio 3.2:
- Cree un archivo course/ex01/bio.txt (en donde course es la raiz de la copia de trabajo de su repositorio Subversion), y escriba una corta biografía de usted mismo (100 palabras o más) del tipo usado en publicaciones acádemicas, conferencias, etc. Envie el archivo al repositorio. Recuerde proveer un comentario significativo cuando envie el archivo!
Ejercicio 3.3:
- ¿Cuál es la diferencia entre mv y svn mv? Ponga la respuesta en un archivo llamado course/ex01/mv.txt y envie sus cambios.
  Una vez haya enviado sus cambios, escriba svn log en su directorio course. Sí usted no sabe lo que acaba de hacer, seria usted capaz de saberlo a partir de los mensajes de log? Sí no, ¿por qué no?
Ejercicio 3.4:
- En este ejecicio, simulará las acciones de dos personas editando un archivo. Para hacerlo, necesitará obtener una segunda copia de su repositorio. Una forma de hacerlo es usar un computador a parte (ej., Su portátil, el computador de su casa, o una máquina en el laboratorio). Otra es crear un directorio temporal, y obtener una segunda copia del repositorio allí. Por favor asegurese que su segunda copia no esta dentro de la primera o vice versa, Subversion se confundirá. Llamemos las dos copias de trabajo Blue y Green. Haga lo siguiente:
  a) Cree Blue/ex01/planets.txt, y añada las siguientes líneas:
```
Mercury
Venus
Earth
Mars
Jupiter
Saturn
```
  Envie el archivo.
  b) Actualice el repositorio Green. (Debe obtener una copia de planets.txt.)
  c) Cambie Blue/ex01/planets.txt para que se lea:
```
1. Mercury
2. Venus
3. Earth
4. Mars
5. Jupiter
6. Saturn
```
  Envie los cambios.
  d) Edite Green/ex01/planets.txt para que su contenido sea vea como a continuación. No haga svn update antes de editar este archivo porque va a estropear este ejercicio.
```
Mercury 0
Venus 0
Earth 1
Mars 2
Jupiter 16 (and counting)
Saturn 14 (and counting)
```
  e) Ahora, en Green, haga svn update. Subversion debe decirle que hay conflictos en planets.txt. Resuelva los conflictos de manera que el archivo contenga:
```
1. Mercury 0
2. Venus 0
3. Earth 1
4. Mars 2
5. Jupiter 16
6. Saturn 14
```
  Envie los cambios.
  f) Actualice el repositorio Blue, y revise que planets.txt ahora tenga el mismo contenido que el reposito Green.
Ejercicio 3.5:
- Añada una o dos líneas de código a course/ex01/bio.txt y envie esos cambios. Entonces, use svn merge para recuperar el contenido original de su biografía (course/ex01/bio.txt), y envie el resultado. Cuando lo haga, bio.txt debe verse como al final de la primera parte del ejercicio anterior.) Nota: el proposito de este ejercicio es enseñarle como ir hacia atrás en el tiempo para obtener versiones antiguas de sus archivos, mientras que podria ser más simple en este caso simplemente editar bio.txt, no puede hacerlo (con seguridad) cuando ha hecho cambios grandes, a varios archivos, en un largo periodo de tiempo.

CategoryPython CategoryLenguajes