Pequeña introducción a Git

Git es un sistema de control de versiones al igual que CVS, Subversion y otros.

Git fue diseñado por Linus Torwalds (creador de Linux) para utilizarlo en el desarrollo del núcleo de Linux. En su sección de descargas podemos encontrar entre otras, enlaces a versiones para Linux (en rpm o deb), MacOS y Windows (a través de Cygwin o del proyecto MSysGit que provee instalables completos e incluso una versión portable).

Si venimos desde un enfoque más clásico como CVS o Subversion, la principal diferencia que aporta Git es que es un sistema distribuido. ¿Y qué quiere decir distribuido?. Pues que a diferencia de CVS o Subversion podemos trabajar con nuestro control de versiones aunque no estemos conectados a una red, ya que es como si tuviésemos el servidor en nuestra propia máquina. De esta forma está diferenciado lo que son las acciones con nuestro repositorio y las que llevamos cabo con repositorios remotos (ese sería el estilo CVS).

En principio es una solución muy recomendable si queremos mantener un versionado en nuestra máquina de desarrollo (en este caso sólo utilizaremos los comandos entre desarrollo y el repositorio propio del esquema. Vamos a ver un pequeño resumen de los comandos que utilizaríamos en este caso.

• Lo primero que necesitamos es configurar nuestro usuario:

  git config --global user.name "Don Nadie"
git config --global user.email "don.nadie@test.com"

• Para crear un repositorio nos situaremos en el directorio principal de nuestro proyecto (o en uno vacío si es un proyecto nuevo) y haremos:

  git init

  y si el proyecto está empezado añadiremos los archivos mediante

  git add .
git commit -m "Mensaje" (Si no se le pasa -m nos pedirá un mensaje, ya que es obligatorio)

  con lo que ya tendremos todo nuestro proyecto bajo el control de versiones.

• Para el ciclo de desarrollo normal, primero se añaden los cambios al índice (es como un almacén intermedio que almacena todos los cambios) y luego lo persistiremos en el repositorio.

  git add ruta/fichero Añade el fichero nuevo o modificado al índice
  git commit Persiste los cambios que tenemos en el índice al repositorio (nos pide mensaje)
  git commit -a Hace el paso al índice y el commit en un solo paso

• Para ver el estado del desarrollo podemos utilizar los siguientes comandos:

  git status Muestra el estado de la rama de desarrollo
  git diff Muestra las diferencias entre la rama de desarrollo y el índice
  git diff --cached Muestra las diferencias entre el índice y el HEAD (último commit)
  git diff HEAD Muestra las diferencias entre la rama de desarrollo y el HEAD
  git log Nos muestra un historial de los commits del repositorio

• El trabajo con ramas es muy sencillo en Git.

  git branch test Crea una rama de nombre «test» a partir de la actual
  git branch Nos muestra las ramas existentes y la rama en la que nos encontramos (cuando hacemos git status también nos muestra la rama en la que nos encontramos)
  git checkout test Nos sitúa en la rama test
  git merge test Si nos hemos situado en la rama master (la rama principal, en la que empezamos) nos combina los cambios en la rama test con esta rama

Git también tiene gran potencia para compartir el código con otros desarrolladores, aunque este caso lo dejaremos para otra entrada.

Por último no quisiera terminar esta entrada sin decir que Git no es el único control de versiones distribuido. También Mercurial o Bazaar nos pueden servir para los mismos fines e incluso pueden ser más sencillas si estamos acostumbrados a CVS.

Instalación de un servidor CVS casero

CVS (Concurrent Versions System) es un sistema de control de versiones, algo que no debería ser ajeno a ningún desarrollador.

En mi XUbuntu (todavía necesito las X para alguna cosilla, aunque estoy en proceso de quitarme) voy a instalar un servidor casero de CVS para mis cosillas. Voy a utilizar CVS porque es lo que más domino, aunque pretendo migrar a Subversion o Git más pronto que tarde. Cuando suceda, tendréis el correspondiente tutorial.

Lo primero que he hecho es instalar cvsd (es un recubrimiento a cvs para aumentar algo la seguridad), lo que nos instala cvs como dependencia. Durante la instalación nos pregunta los repositorios que queremos publicar mediante cvsd, aunque esto lo podemos modificar luego en el archivo cvsd.conf (en /etc/cvsd), más concretamente con las líneas que comienzan por Repos.

Para crear un repositorio (lógicamente los que le hemos indicado durante la instalación) utilizamos el comando init de cvs. Explicaros que cvs desde línea de comandos tiene la siguiente estructura:

cvs [cvs-options] cvs-command [command-options] [command-args]

El comando init inicializa un repositorio (lo ejecutaremos como root o mediante sudo). Mediante la opción -d le indicamos la ruta al repositorio.

cvs -d /var/lib/cvsd/tcymu init

Esto crea el repositorio en la ruta especificada, lo que podemos comprobar mirando el contenido de /var/lib/cvsd/tcymu. Observaremos el directorio CVSROOT con contenido propio del servidor CVS.

Ahora añadimos un usuario a nuestro repositorio (de nuevo como root):

cvsd-passwd /var/lib/cvsd/tcymu +tcymu

Nos pide un password, que será el que utilizaremos para entrar posteriormente. Lo almacena (cifrado por supuesto) en /var/lib/cvsd/tcymu/CVSROOT/passwd.

Bien, ya tenemos preparado el CVS. Si tenemos un firewall activado, debemos recordar abrir los puertos correspondientes: 2401 por defecto.

Y ahora y desde línea de comandos (es decir, que así podemos trabajar tanto en Linux como en Windows) podremos identificarnos en CVS mediante el comando:

cvs -d :pserver:user@server:/repository login

Hay que notar que la opción -d sólo es necesaria si no tenemos definida una variable de entorno CVSROOT. Por lo tanto si trabajamos con un único servidor CVS pues lo más cómodo es añadir dicha variable de entorno.

Una vez identificados en CVS el primer paso sería añadir un directorio al CVS, ya que de momento nuestro repositorio está vacío. Creamos un directorio local que albergará nuestro proyecto CVS y dentro de ese directorio ejecutamos:

cvs -d :pserver:user@server:/repository co -l .

Notaremos que se nos ha creado una carpeta CVS que contiene los archivos necesarios para mantener el estado de nuestra imagen del CVS.

Ahora ya podemos empezar a trabajar en nuestro proyecto de la forma habitual. Crearemos archivos, los añadiremos, haremos commit y demás. El trabajo habitual con CVS queda para una entrada futura, aunque no faltan precisamente recursos en la red.