PDF de programación - Montando un entorno ágil (Hudson + Ant + SVN + NetBeans)

Montando un entorno de integración continua

Iván Párraga García

Índice de contenido

Introducción...................................................................................................................................................1
Configuración Subversion.............................................................................................................................2
Crear el repositorio del SVN que almacenará el proyecto........................................................................2
Establecer la seguridad del repositorio......................................................................................................3
Configuración NetBeans................................................................................................................................4
Conexión con el Subversion......................................................................................................................4
Tests unitarios con JUnit en NetBeans......................................................................................................6
Configuración del Ant....................................................................................................................................8
Configuración Hudson.................................................................................................................................11
Automatización de la construcción.........................................................................................................11
Configurar el workspace del Hudson y añadir dependencias externas al Subversion............................13
Comprobando que el job está bien configurado......................................................................................15
Conexión con el SVN..............................................................................................................................16

Introducción

Cuando uno lee posts, libros y escucha experiencias de la aproximación ágil al desarrollo del software y
empieza a profundizar y a aprender conceptos tales como el TDD (test driven development) y la
integración continua, se le despiertan una ganas irrefrenables de empezar a trabajar de este modo. En este
post lo que intentaré explicar es cómo montar un entorno sencillo que nos permita tener los cimientos de
un sistema ágil que cada uno podrá extender para satisfacer sus propias necesidades. Como se menciona
en este post, tres de los pilares de la integración continua son: un repositorio de datos, un servidor de
integración continua y una herramienta que permita automatizar la construcción de la aplicación. Yo
además añadiría un cuarto: un IDE que se integre bien con el resto del entorno. No es el propósito de este
post discutir la utilidad de estos componentes (el post mencionado anteriormente puede ser un buen punto
de partida para los recién llegados), sino elegir unas herramientas concretas y describir su configuración e
integración. En mi caso he hecho la siguiente elección (que no tiene por qué ser la única ni la mejor):

•

•

repositorio de código: SVN

servidor de integración continua: Hudson

• herramienta de construcción: ANT

•

IDE: NetBeans 6.5

Por simplicidad he distribuido el entorno entre una máquina Linux (Ubuntu 8.10) con IP 192.168.1.10
(dato que es relevante para tareas de configuración que iremos viendo) que actúa simultáneamente como
repositorio de datos y de integración continua y un número arbitrario de máquinas de desarrollo (también
Ubuntu 8.10) que contienen los IDE's y el entorno con el que trabajan los desarrolladores. En cualquier
caso, otras distribuciones tienen exactamente la misma complicación y los pasos requeridos son
directamente extrapolables y fácilmente adaptables. Para explicar los diferentes pasos utilizaré un mismo
ejemplo ya que considero que hablar con algo concreto suele ser más sencillo, tanto para el que explica
como para el que intenta entender, que hacerlo en general o en abstracto. Presupongo la inteligencia de
los potenciales lectores para hacer las adaptaciones requeridas en cada punto a sus propias necesidades.
No es muy relevante, pero utilizaré un proyecto personal que estoy empezando estos días que sirve para
hacer un seguimiento de las valoraciones de mis cursos y que se titula, en un alarde de originalidad,

- 1 -

Montando un entorno de integración continua

Iván Párraga García

"Encuestas".

En el siguiente diagrama muestro el entorno que acabaremos montando. Las rutas que aparecen en el
servidor no tenemos por qué entenderlas ahora pero servirán como referencia a medida que vayamos
construyendo la solución.

Configuración Subversion

He elegido Subversion porque es un repositorio más o menos potente que supera algunas de las
limitaciones de nuestro querido y viejo CVS y aún a día de hoy es una de las herramientas que, bajo mi
humilde opinión, están más extendidas en la industria. No voy a entrar en los detalles de instalación y de
configuración del propio Subversion. Para ello ya hay mucha documentación online (por ejemplo aquí).
Me centraré en la creación de un repositorio para nuestro proyecto. Es cierto que se puede usar el mismo
repositorio para más de un proyecto, pero yo prefiero tenerlo separado (alguno de los motivos aparecerán
más adelante, aunque también se puede justificar razonadamente la otra postura).

Crear el repositorio del SVN que almacenará el proyecto

Como decía, presupongo que el servidor que actuará como repositorio de datos tiene instalado el
Subversion y sus herramientas administrativas (si no es así, nuestro querido apt-get o Synaptic vendrán a
nuestro rescate). Lo primero que hay que hacer es determinar en qué ruta almacenaré el repositorio. Yo
tiendo a almacenar los diferentes repositorios de cada uno de los proyectos bajo una misma raíz y así
mantengo el servidor más o menos organizado. La ruta también debería ser vistosa porque luego formará
parte de la configuración que utilicen los clientes (como los IDE's) para conectarse con dicho repositorio.
Trabajando con Ubuntu, y si hemos instalado el Subversion desde paquetes, se crea un usuario svn. Para
que todo funcione de manera correcta, deberíamos asegurarnos que el propietario del repositorio es este
usuario. Una manera de hacerlo es ejecutar los comandos de administración del Subversion con este
usuario y otro es cambiar después el propietario del directorio (y su contenido) con el comando chown
(chown -fR svn .)/Encuestas-2). En definitiva, para crear el repositorio haremos lo siguiente:

svnadmin create /srv/svn/Encuestas-2

- 2 -

Montando un entorno de integración continua

Iván Párraga García

El directorio /srv/svn es la raíz de todos mis repositorios y Encuestas-2 es el que usaré para este proyecto
en particular. Si ahora nos situamos en en el ese directorio y hacemos un listado deberíamos ver (más o
menos) lo siguiente:

ivan@hargon:/srv/svn/Encuestas-2$ ls -alh
total 36K
drwxr-xr-x 7 svn root 4,0K 2009-01-11 10:43 .
drwxr-xr-x 6 svn root 4,0K 2009-01-11 10:43 ..
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 conf
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 dav
drwxr-sr-x 5 svn root 4,0K 2009-01-11 10:43 db
-r--r--r-- 1 svn root 2 2009-01-11 10:43 format
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 hooks
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 locks
-rw-r--r-- 1 svn root 229 2009-01-11 10:43 README.txt

Establecer la seguridad del repositorio

Cuando se crea un repositorio en el Subverson es, obviamente, para que los desarrolladores puedan
utilizarlo. Por tanto un paso importante es la parte de securización y autorización del mismo: establecer
quién podrá acceder y sus credenciales. Subversion tiene diferentes mecanismos de autenticación y de
transporte seguro de la información (incluyendo ssh). No voy a entrar en los detalles y explicaré cómo
hacerlo de la manera más sencilla. Para más información os remito al anterior enlace.

En mi caso, todas las máquinas residen en el interior de mi red de área local, que puede considerarse
"zona segura". Un punto importante es que los mecanismos de seguridad (y otros más) se establecen por
repositorio (en contraposición a una configuración global para todos ellos) lo que nos permite que
convivan repositorios con diferentes configuraciones (este es uno de los motivos por los que prefiero
tener un repositorio por proyecto). Lo primero es determinar el modo de autenticación. Para ello
habremos de editar el fichero

/srv/svn/Encuestas/conf/svnserve.conf

para que quede más o menos así:

[general]
anon-access = none
auth-access = write
password-db = passwd
realm = My Realm

De hecho estas opciones seguramente preexisten en el fichero generado en el repositorio y lo único que
habrá que hacer es descomentarlas. También es posible que en el fichero haya otras tantas opciones
comentadas que no vamos a necesitar para nuestra configuración básica, así como diferentes comentarios
descriptivos. Yo los he obviado por claridad. Con esta configuración lo que estamos haciendo es decirle
al Subversion que busque los usuarios y las credenciales en un fichero de texto plano. El siguiente paso,
precisamente, consiste en configurar qué usuarios y con qué credenciales podrán acceder al repositorio
editando dicho fichero que se encuentra en:

/srv/svn/Encuestas/conf/passwd

que editaremos para que quede algo parecido a lo siguiente:

- 3 -

Montando un entorno de integración continua

Iván Párraga García

[users]
ivan = super-secret-passwd
ana = top-secret-passwd

Estos serán los usuarios y passwords que habrá que configurar en los clientes (en nuestro caso usaremos
NetBeans).

Configuración NetBeans

Supongamos que nuestra aplicación de ejemplo Encuestas es una aplicación web típica que va a correr
encima de un To