ANÁLISIS Y DISEÑO DE SISTEMAS 2

Práctica 1
Laboratorio
Elder Manuel Mutzus Arévalo - 200611109
18/12/2010

En este documento se detallan los pasos que deben seguirse para la correcta instalación y configuración de
un Servidor Apache con Subversion + Hudson + Trac.
ÍNDICE
Índice .................................................................................................................................................................. 1
Introducción ....................................................................................................................................................... 3
Objetivos ............................................................................................................................................................ 4
Objetivos generales ........................................................................................................................................ 4
Objetivos específicos ...................................................................................................................................... 4
Parte teórica ....................................................................................................................................................... 5
SVN ................................................................................................................................................................. 5
Comandos Principales ................................................................................................................................ 5
Otros Comandos ......................................................................................................................................... 6
SVNADMIN ..................................................................................................................................................... 6
Herramientas similares a Hudson ................................................................................................................... 7
Luntbuild..................................................................................................................................................... 7
Apache Continnum ..................................................................................................................................... 7
Comparación .............................................................................................................................................. 7
Herramientas similares a Trac ........................................................................................................................ 8
Redmine ..................................................................................................................................................... 8
Mantis bug tracker ..................................................................................................................................... 8
Comparación .............................................................................................................................................. 8
Parte Práctica ..................................................................................................................................................... 9
Integración del servidor Apache con Subversion y WebDAV ......................................................................... 9
Requerimientos .......................................................................................................................................... 9
En cuanto a Hardware ............................................................................................................................ 9
En cuanto al Software ............................................................................................................................. 9
Pasos ........................................................................................................................................................... 9
WebSVN........................................................................................................................................................ 14
¿Cómo crear un proyecto en NetBeans y subirlo al repositorio SVN? ......................................................... 17
Instalación de NetBeans 6.5.0 .................................................................................................................. 17
Hudson ......................................................................................................................................................... 23
Instalación ................................................................................................................................................ 23
Trac ............................................................................................................................................................... 25
Instalación ................................................................................................................................................ 25
Configurando Trac .................................................................................................................................... 25
Integrando Hudson y Trac con el servidor Apache ....................................................................................... 27
 Enlazando Trac y Hudson ............................................................................................................................. 30
Tres Builds exitosos con Hudson desde el repositorio web de Subversion .................................................. 35
Verificando los cambios desde Trac ......................................................................................................... 40
Bibliografía........................................................................................................................................................ 44
Anexos .............................................................................................................................................................. 45
INTRODUCCIÓN
Integrar las partes de un “sistema” ha sido importante desde siempre dado que es más fácil abordar un
problema desde una perspectiva tal como la filosofía que dicta literalmente: “divide y vencerás”.

Si se divide la resolución de un problema, se incurre en riesgos, algunos sencillos de resolver y otros no

tanto. Una de de los riesgos de mayor peso sobre el proyecto es tener la incertidumbre si “¿Funcionará bien
al unirlo?”

La integración continua es un concepto aplicado que fue propuesto por Martin Fowler, a pasos agigantados,
este concepto representa hacer integraciones automáticas de un proyecto, la frecuencia con la que se hagan
las integraciones dependerá integralmente del tipo de proyecto así como del equipo de trabajo pero se
recomienda que se hayan lo más a menudo posible. Al hacerlo así, se obtiene la ventaja de poder detectar
fallos cuanto antes.

La detección de fallos del proyecto es importante ya que se deben cubrir las expectativas de los clientes y en
este ámbito, recibir un “Eso es lo que necesitaba” no es lo ideal sino se debe tratar de cumplir todos los
requerimientos de los clientes y sobrepasarlos para obtener respuestas como “Eso es más de lo que
esperaba” o “Es mucho mejor de lo que pensé”; al recibir respuestas como las anteriores, caeremos en
cuenta de que hicimos un buen trabajo.

Al hablar de integración continua no pueden obviarse temas de suma importancia dentro del desarrollo de
un proyecto, estos son, la compilación y la ejecución de tests de todo el proyecto como tal.

Existe un proceso característico, he aquí los pasos ordenados:

1. Se obtienen las fuentes del proyecto (desde Subversion, CVS, etc.)

2. Se realizan las modificaciones necesarias
3. Se compilan las fuentes modificadas
4. Se ejecutan las tests para la detección de errores y por último
5. Se generan los reportes necesarios.

Se puede hacer uso de herramientas para el Versioning de las fuentes así como para manejar todo el
proceso de integración continua, entre las herramientas más conocidas se encuentra Hudson (Para
proyectos de java) y Team Foundation Build (para proyectos de .Net).

La integración continua ha llegado para quedarse y nadie pone en tela de juicio la capacidad de desarrollo
que ha traído consigo. El tiempo que se considera correcto para la integración continua se basa en horas y
dependerá de cada equipo el cómo implementar dicho tiempo.

A menudo, la integración continua se relaciona con XP (Extreme Programming) y por ende, las metodologías
de desarrollo ágil.
OBJETIVOS

Con la elaboración del presente reporte, se pretende alcanzar algunos logros, entre los cuales se pueden
citar:

OBJETIVOS GENERALES
 Utilizar diferentes herramientas de ayuda para la integración continua de un proyecto de software
y enlazarlas entre sí para que compartan información y trabajen de una manera sincronizada.

OBJETIVOS ESPECÍFICOS
 Utilizar Subversion como herramienta para el control de versiones de proyectos de software.
 Enlazar Hudson y Trac mediante un plugin específico dedicado a este fin.
 Utilizar el servidor Apache como central de funcionamiento para las herramientas: Subversion,
Hudson y Trac.
 Encontrar nuevas herramientas similares a Hudson y Trac y compararlas.
PARTE TEÓRICA

SVN
SVN es el programa cliente que se basa en líneas de comandos para Subversion, todas las modificaciones las
realiza sobre el repositorio central.

COMANDOS PRINCIPALES
Entre los comandos más importantes que se tienen para SVN se encuentran los siguientes:

Comando Explicación
Éste comando genera una referencia (copia) del repositorio central hacia un
repositorio local. La sintaxis es la siguiente:

checkout $ svn checkout <url> <path>

Si se omite el “path” entonces se tomará la dirección base de la “url”.

Éste comando se encarga de copiar un archivo en una copia del trabajo o bien
sobre el repositorio. Su sintaxis es la siguiente:
copy
$ svn copy <fuente> <destino>

Éste comando se encarga de actualizar cambios que hayan sido realizados en el

repositorio y los refleja hacia nuestra copia de trabajo actual.
update
$ svn update <path>

Éste comando se encarga de realizar un commit de tipo recursivo de lo que se

encuentra en “path” hacia y lo manda a “url”.

Si se está creando el proyecto, generalmente se realiza un import para enviar una

copia completa del proyecto hacia el repositorio. La sintaxis es la siguiente.
import
$ svn import path_directorio nombre_repositorio
Un ejemplo de la aplicación de este comando, sería:
$ svn import /home/meme/cp/practik /var/svn-repos/practica_no

Éste comando se encarga de agregar archivos, directorios, enlaces simbólicos, etc,

al repositorio central. La sintaxis es:
add $ svn add <path>
Nota. Los cambios se reflejan en el repositorio al darle COMMIT.

Éste comando envía los cambios realizados en nuestra copia de trabajo hacia el
repositorio. La sintaxis es:
$svn commit <path>
Con commit se aplican los cambios realizados con add.
commit
Como parámetros se pueden enviar mensajes que serían las descripciones de los
cambios realizados, la sintaxis para esto sería:
$ svn commit –m <”mensaje”> <path>
 Éste comando elimina archivos, directorios, enlaces simbólicos, etc. La sintaxis es:
delete $ svn delete <path>

OTROS COMANDOS
Como nota adjunta, se tienen los siguientes comandos:

Comando Explicación
Éste comando da información sobre el repositorio. La sintaxis es la siguiente:
info $ svn info

Éste comando da información sobre la última revisión. La sintaxis es la siguiente:

status $ svn status --show-updates --verbose

Éste comando se utiliza para obtener una revisión en concreto. La sintaxis es la

checkout (con siguiente:
parámetros) $ svn checkout --revision <numero>

Éste comando se utiliza para actualizar la copia local con una revisión en
update (con concreto. La sintaxis es la siguiente:
parámetros) $ svn update --revision <numero>

Éste comando muestra las diferencias entre el repositorio local y la copia con la
que contamos. La sintaxis es la siguiente:
diff
$ svn diff

SVNADMIN
SVNADMIN es una herramienta para crear, modificar y reparar un repositorio de Subversion.

Los comandos más utilizados son los siguientes:

Comando Explicación
Éste comando crea un directorio en la ruta especificada como parámetro. La
sintaxis es la siguiente:
create
$ svnadmin create <path>/nombre_directorio

Éste comando se ejecuta solamente para recuperar nuestro repositorio cuando

haya ocurrido algún error. La sintaxis es la siguiente:
recover
$ svnadmin recover <path_del_repositorio>

Éste comando lee un “dumpfile” el cual es un stream con formato proveniente de

load stdin.
Realiza un commit al repositorio y luego envía el progreso hacia el stdout. La
 sintaxis es la siguiente:
$ svn load <path_del_reposotorio>

Éste comando envía el contenido de un repositorio del sistema hacia un archivo

“dumpfile”. La sintaxis es la siguiente:
dump $ svnadmin dump <path_del_repositorio> [-r LOWER|UPPER] [--
incremental]

HERRAMIENTAS SIMILARES A HUDSON

LUNTBUILD
Es una herramienta versátil para la automatización y gestión. La integración contínua se puede configurar
fácilmente mediante la interfaz web que posee cuya característica que resalta es la limpieza y simplicidad.

Los builds que son ejecutados son bien manejados utilizando funciones de búsqueda, categorización,
borrado, parcheado, etc.

Puede actuar como un build central de construcción de artefactos para un repositorio de descarga para el
equipo de desarrollo completo.

APACHE CONTINNUM
Es un servidor de integración continua que está listo para empresas de gran tamaño, entres sus
características más importantes resaltan:

 Builds automoatizados/automáticos
 Gestión de releases
 Seguridad basada en roles
 Integración con herramientas populares de builds
 Sistema de gestión de las fuentes

COMPARACIÓN
Si se toma la dificultad de instalación como punto de partida para elegir una de las 3 herramientas
mostradas, sin duda la más fácil de instalar es Hudson ya que cuenta con paquetes precompilados para
diferentes distribuciones, la instalación se resume a descargar un paquete .deb (en este caso ya que se
utilizó una distribución basada en Debian), y luego, proceder con su instalación.

La única “dificultad” que se encontró en el camino fue que tenía dependencias rotas, lo cual bastó con
ejecutar un simple “sudo apt-get –f install” para corregir dichos errores y listo.

En cuanto a usabilidad, Hudson cuenta con una interfaz amigable a la vista y diseñada para los usuarios
noveles.
HERRAMIENTAS SIMILARES A TRAC
REDMINE
Es una aplicación web para la gestión de proyectos. El lenguaje que se utiliza para desarrollarla es el
framework Ruby on Rails, lo cual lo dota de ser multiplataforma.

Redmine es un proyecto de código abierto y se liberó bajo la licencia GPL (GNU General Public Licence)
versión 2.

Entre las características más importantes se encuentran:

 Soporte para proyectos simultáneos

 Control de acceso basado en roles
 Sistema de seguimiento de errores
 Calendario y diagrama de Gantt
 Gestión de archivos, documentos y noticias
 Wiki por proyecto
 Seguimiento del tiempo
 Soporte para autenticación LDAP
 Soporte para múltiples bases de datos
 Notificaciones por correo y feeds
 Integración con SVN, CVS, Git, Mercurial, Bazaar y Darcs.

MANTIS BUG TRACKER

También conocido como MantisBT es un sistema gratuito de seguimiento de cambios (bugs) que tiene sus
orígenes en una aplicación web.

Está escrito en PHPScripting y funciona con Gestores de Bases de Datos tales como MySQL, MS SQL y
PostgreSQL y servidores web.

Es multiplataforma y casi cualquier explorador web debería funcionar correctamente como cliente.

Está liberado bajo la licenca GNU GPL (General Public Licence). La última versión estable es la 1.2.4.

COMPARACIÓN
Trac es sin duda un gran sistema de seguimiento de cambios y se debería elegir debido al nivel de detalle
que ofrece al mostrar reportes de cambios, así como la fácil integración que posee con Hudson.

La integración entre Hudson y Trac se reduce a la instalación de un Plugin especial para conectarlos.
PARTE PRÁCTICA

INTEGRACIÓN DEL SERVIDOR APACHE CON SUBVERSION Y WEBDAV

REQUERIMIENTOS
Los requerimientos básicos para realizar una instalación limpia de Apache con Subversion, son los
siguientes:

E N CUANTO A H ARDWARE
La práctica se realizó utilizando una computadora con las siguientes especificaciones:

 Procesador: AMD Athlon II Dual-core de 64 bits

 Memoria RAM: 3 GB
 Memoría de video: 256 MB
 Disco Duro: 320 GB
 Pantalla: VGA con resolución de 1280 x 800 pixeles

E N CUANTO AL S OFTWARE
La práctica se realizó utilizando el siguiente entorno:

 Sistema operativo: GNU/Linux Ubuntu™

 Versión: 10.10 de 64 bits
 Codename: Maverick Meerkat
 Entorno de escritorio: GNOME versión 2.29
 El sistema cuenta con todas las actualizaciones hasta la fecha
 Todos los programas necesarios se instalaron desde los repositorios

NOTA: en la terminal, un símbolo $ indica que el comando debe ejecutarse desde la sesión del usuario y no
como usuario root.

PASOS
Para iniciar la instalación, debemos contar con todos los paquetes necesarios para un correcto
funcionamiento del sistema, esto se logra tecleando en la consola, lo siguiente:

Actualizamos la lista de paquetes disponibles:

$ sudo apt-get update

Actualizamos los paquetes del sistema operativo:

$ sudo apt-get dist-upgrade

Instalamos los paquetes necesarios

$ sudo apt-get install apache2 libapache2-svn subversion subversion-tools

Una vez finalizada la instalación, debemos crear un Nuevo grupo en el sistema operativo, para efectos de la
práctica, se utilizará el nombre “subversion"

$ sudo groupadd subversion

Ahora hay que agregar un nuevo usuario, se llamará “www-data” y se agregará al grupo anteriormente
creado. Esto se logra con:

$ sudo adduser www-data subversion

Apache necesita de un usuario para poder acceder al sitio, debemos agregarlo en un archivo dedicado,
nuestro usuario se llamará “meme” y esto se logra con la siguiente orden:

$ sudo htpasswd –c /etc/apache2/dav_svn.passwd meme

A continuación, debemos localizar un lugar en dónde almacenar el repositorio, para facilidad, se eligió la
ruta “/var/svn-repos/”

$ sudo mkdir –p /var/svn-repos

Acto seguido, toca crear un nuevo proyecto, lo llamaremos “practica_uno” y se realiza como sigue:

$ sudo svnadmin create /var/svn-repos/practica_uno

Ahora, debemos asegurarnos que el nuevo usuario y pertenecientes al nuevo grupo, sean capaces de
acceder a las nuevas rutas que creamos, esto se hace con el siguiente comando:

$ sudo chown –R www-data:subversion /var/svn-repos/practica_uno

$ sudo chmod –R 770 /var/svn-repos/practica_uno

Ahora ya tenemos el repositorio y la carpeta del proyecto, debemos configurar webDAV para que sea capaz
de iniciar la interfaz web, esto se hace modificando el archivo “dav_svn.conf”.

$ sudo vi /etc/apache2/mods-available/dav_svn.conf

Tenemos que agregar las siguientes líneas al final del archivo, de modo que quede con el siguiente
contenido:

<Location /svn/practica_uno>

DAV svn

SVNPath /var/svn-repos/practica_uno
 #SVNParentPath /var/svn-repos/practica_uno

#SVNParentPath Se puede utilizar en vez de SVNPath

SVNIndexXSLT “/svnindex.xsl”

#Para el estilo de la pagina

AuthType Basic

AuthName “Repositorio para la practica uno de AYD2”

AuthUserFile /etc/apache2/dav_svn.passwd

<LimitExcept GET PROPFIND OPTIONS REPORT>

Require valid-user

</LimitExcept>

</Location>

 En Location se debe colocar la dirección sobre la cual se accederá al proyecto.

 En SVNPath se debe colocar la ruta completa de acceso hacia el proyecto.

Ahora debemos descargar algunos archivos de estilos, para darle un mejor LookAndFeel a la interfaz de
WebDAV. Esto lo podemos hacer desde cualquier explorador web para descargar los siguientes archivos:

 svnindex.css
 svnindex.xsl

Las rutas para descargarlos son:

 http://svn.haxx.se/users/archive-2005-10/att-0956/svnindex.css
 http://dev.e-taxonomy.eu/trac/browser/trunk/devtools/svnindex/svnindex.xsl

Por ejemplo, si descargamos los archivos a nuestro Home, debemos moverlos a las siguientes localidades:
 $ cd /home/meme

$ sudo mv svnindex.css /var/www

$ sudo mv svnindex.xsl /var/www

Ahora debemos cambiarle los permisos a ambos archivos, esto se logra con:

$ sudo chown www-data:subversion /var/www/svnindex.css

$ sudo chown www-data:subversion /var/www/svnindex.xsl

Y finalmente, para que los cambios surtan efecto, debemos reiniciar el servidor Apache.

$ sudo /etc/init.d/apache2 stop

$ sudo /etc/init.d/apache2 start

Hasta este momento, deberíamos poder ingresar a la siguiente ruta, y veríamos algo como esto:
http://localhost/svn/practica_uno

Ahora tenemos que crear la estructura de directorios básicos, requeridos por el enunciado de la práctica,
estos son: Trunk, Branches y Tags.

$ sudo svn mkdir file:///var/svn-repos/practica_uno/trunk -m “Trunk”

$ sudo svn mkdir file:///var/svn-repos/practica_uno/tags -m “Tags”

$ sudo svn mkdir file:///var/svn-repos/practica_uno/branches -m “Branches”

Ahora solo es necesario presionar F5 si teníamos abierto nuestro explorador web, esto con el fin de que los
cambios sean evidentes.

WEBSVN
Entre las dependencias de este paquete se tiene PHP en su versión 5 pero con la siguiente línea de
comandos se instala el paquete objetivo así como sus dependencias.

$ sudo apt-get install websvn

Al momento de instalar el programa, nos pedirá algunas configuraciones básicas, si se nos pasa esta etapa
por X o Y motivo podremos “sacar” nuevamente este wizard de configuración, esto con el siguiente
comando:

$ sudo apt-configure websvn

La dirección de trabajo de WebSVN es: http://localhost/websvn y deberá mostrar los proyectos que
tengamos en el repositorio, actualmente solo nos mostrará el proyecto “practica_uno” ya que fue el que
creamos a modo de ejemplo.
¿CÓMO CREAR UN PROYECTO EN NETBEANS Y SUBIRLO AL REPOSITORIO SVN?
Para lograr esto, se utilizó la versión 6.5.0 de NetBeans, la versión utilizada de NetBeans fue la JavaSE.

INSTALACIÓN DE NETBEANS 6.5.0

Para principiar, se debe dirigir a la página oficial de este IDE para proceder a su descarga, la página es:
http:/www.netbeans.org.

Al descargar el archivo .sh se debe proceder a ejecutarlo para instalarlo, eso se logra con:

$ sh nombre_del_archivo_netbeans.sh

Luego se abrirá el wizard que lo guiará a través del resto del proceso de la instalación. El resto de la
instalación es trivial y relativamente sencilla por lo que no se ahondará en estos temas.

Lo primero es abrir NetBeans y dirigirnos hacia el menú “Versioning” en el ítem “Subversion” y luego en
“Check out”.
Luego, en la ventana emergente, se deberán llenar los siguientes datos, tal y como se muestra en la figura a
continuación.

En el apartado Repository URL se debe colocar la ruta que definimos anteriormente, la ruta que debe
colocarse es: http://localhost/svn/practica_uno..

En User debemos colocar el usuario que agregamos anteriomente (meme) y luego colocar su contraseña
para iniciar sesión autentificada.

En el repository Folder(s) deberemos seleccionar la carpeta trunk.

Al llenar los datos anteriores, podremos guardar los cambios y crear nuevos proyectos, a continuación
crearemos un proyecto el cual ingresaremos dentro del repositorio SVN.

Se creará un nuevo proyecto, para efectos de simplicidad, se correrá un proyecto con una única ventana que
mostrará un texto y luego se cerrará a traves de pulsar el botón salir.
Ahora, para agregarlo al repositorio, le damos clic derecho al proyecto, seleccionamos el nuevo menú de
Versioning y la opción “Import into subversion repository”.

Ahora nos preguntará dónde queremos guardar el proyecto, para efectos del enunciado, la ruta será en la
carpeta Trunk de Subversion.

Esto se logra con lo siguiente mostrado en la gráfica.

Acto seguido, se preguntarán cuáles son los archivos que se desean compartir mediante el repositorio SVN.

Ahora, en la página de websvn se debería tener la siguiente salida.

Como se pude apreciar en la imagen, el proyecto generado es HelloWorldConsole y se encuentra en el
Trunk.
HUDSON
Hudson es una aplicación que monitorea ejecuciones de tareas repetitivas, tales como Builds de proyectos
de software o tareas corriendo por Crons.

Hudson se centra básicamente en estas dos tareas:

1. Builds/Tests contínuos de proyectos de software, por ejemplo tales como CruiseControl o

DamageControl.
2. Monitoreo de ejecuciones de tareas de ejecución externa, tales como Crons y tareas de procmail.

INSTALACIÓN
Como la distribución sobre la cual se realizaron estas instalaciones y configuraciones está basada en Debian,
Hudson fue instalado desde repositorios pero primeramente, debemos agregar los repositorios Hudson para
que la lista de paquetes sea actualizada y se encuentre disponible.

Primero descargamos la llave pública del repositorio y la agregamos a nuestras claves de confianza.

$ wget –O /tmp/key http://hudson-ci.org/debian/hudson-ci.org.key

$ sudo apt-key add /tmp/key

Para continuar, primero deberemos actualizar la lista de paquetes disponibles y luego proceder a instalar
Hudson, esto se realiza con:

$ sudo apt-get update

$ wget –O /tmp/Hudson.deb http://hudson-ci.org/latest/debian/hudson.deb

$ sudo dpkg –i /tmp/Hudson.deb

El sistema se quejará de que faltan algunas dependencias, si ocurriese esto, entonces debemos instalar
automáticamente las dependencias, para esto debemos teclear en una terminal:

$ sudo apt-get –f install

Aceptamos los cambios y listo, el sistema iniciará la descarga y posterior instalación de todas las
dependencias faltantes.

Al finalizar la instalación, debe aparecernos en la terminal el siguiente texto para saber si Hudson se instaló
correctamente.

* Starting Hudson Continuous Integration Server Hudson

Otra manera de saber si Hudson está trabajando correctamente es a través del front-end web que posee,
esto se puede verificar siguiendo la dirección http://localhost:8080/ en un explorador web cualquiera. Como
podemos observar, Hudson trabaja sobre el puerto 8080 y la interfaz se parece algo a lo que sigue:

Está de más decir que ningún otro servidor o aplicación podrá utilizar el puerto 8080 ya que es el que le
corresponde a Hudson para acceder a él mediante un explorador web.

La integración de Hudson y Track se especificará más adelante.

TRAC
Trac es un sistema de seguimiento para desarrollo de proyectos de software. Utiliza una aproximación
minimalista de aplicaciones basadas en la web (web applications) para la gestión de proyectos.

La misión de Trac es ayudar a los desarrolladores a escribir software de gran calidad aunque no puedan estar
en el mismo lugar.

Trac puede integrarse con Subversion, Utiliza SQLite, MySQL o PostgreSQL para almacenar la información.

INSTALACIÓN
Debido a que estamos utilizando una distribución derivada de Debian, Ubuntu tiene Trac en sus repositorios,
lo que implica una instalación extremadamente sencilla, la instalación se encuentra a una línea de comando
de distancia, tal y como sigue:

$ sudo apt-get install trac libapache2-mod-python

Como podemos observer, también se instaló el plugin de Python para el servidor Apache. Todas las
dependencias MySQL, MySQLite, etc, se instalarán automáticamente para lograr la consistencia del sistema
y no tener dependencias rotas, es una característica de APT y de todos los gestores de paquetes de las
distintas distribuciones GNU/Linux.

Una vez instalado, debemos crear una carpeta la cual contendrá los proyectos de Trac, para facilidad, se
utilizó la ruta /var/ para crear dicho directorio.

CONFIGURANDO TRAC
$ sudo mkdir –p /var/trac/projects/practica_uno

Ahora debemos especificar el Entorno del proyecto (Project Environment), esto se logra con el siguiente
comando:

$ sudo trac-admin /var/trac/projects/practica_uno initenv

La ejecución de este comando, nos llevará a una serie de preguntas cuyo fin es obtener la información
necesaria para la correcta configuración y funcionamiento de Trac, estas preguntas con sus respectivas
respuestas son:

 Project Name [My Project] > Practica Uno

 Database connection string [Sqlite] > ---dejaremos la de default, por lo tanto, solo presionar Enter---
 Versioning control type [SVN] > ---dejaremos el valor por defecto ya que utilizaremos SVN---
 Subversion directory path [/var/lib/svn] > /var/svn-repos/practica_uno

Por último, necesitamos activar Trac, lo haremos sobre el puerto 8000 ya que está libre y esto lo hacemos
con el siguiente comando:

$ sudo tracd –port 8000 /var/trac/projects/practica_uno

Al finalizar las preguntas, todo debería andar sobre ruedas.

Ahora faltaría proporcionar permisos de acceso a la carpeta para el usuario que utiliza Apache, esto se
realiza mendiante:

$ sudo chown –R www-data /var/trac/projects/practica_uno

Ahora debemos ingresar a la página http://localhost:8000 y tendríamos que ser capaces de ver algo
parecido a la siguiente imagen.
INTEGRANDO HUDSON Y TRAC CON EL SERVIDOR APACHE
Como podremos recordar, anteriormente instalamos el módulo de Python para Apache, ahora es necesario
verificar si lo tenemos correctamente activado, esto se logra mediante la siguiente línea de mando:

$ a2enmod python

Si lo tenemos activado, la salida nos debería decir lo siguiente:

Module python already enabled

Si el módulo aún no estuviera habilitado, esta línea lo activaría por nosotros y tendríamos que reiniciar el
servidor apache:

$ sudo /etc/init.d/apache2 stop

$ sudo /etc/init.d/apache2 start

A partir de acá, debemos crear una nueva directiva Location, esto se hace a través de la modificación del
archivo “default” de los sitios disponibles de Apache, o bien, para mayor orden, crear un nuevo archivo y
colocarle lo siguiente:

$ sudo vi /etc/apache2/sites-available/trac

Esta línea nos abrirá y creará automáticamente el archivo, ahora le agregaremos las siguientes líneas:

<Location /trac/practica_uno>

SetHandler mod_python

PythonInterpreter main_interpreter

PythonHandler trac.web.modpython_frontend

PythonOption TracEnv /var/trac/projects/practica_uno

PythonOption TracUriRoot /trac/practica_uno

</Location>

# Autenticacion

<Location /var/trac/projects/practica_uno/login>

AuthType Basic

AuthName “Practica Uno AYD2 – Trac”

AuthUserFile /var/trac/projects/practica_uno.htpasswd”

Require valid-user

</Location>
Guardamos los cambios realizados sobre el archivo y luego procedemos a activar el módulo, esto se logra
con:

$ sudo a2ensite trac

Ahora tenemos que crear el archivo que nos servirá para validar los usuarios que ingresarán a Trac, dichos
usuarios estarán escritos en el archivo “practica_uno.htpasswd”, lo haremos de la siguiente manera:

$ sudo htpasswd –cm /var/trac/projects/practica_uno/practica_uno.htpasswd meme

En este caso, le agregamos el usuario “meme” y luego nos pedirá la contraseña, la ingresamos y nos pedirá
una vez más la contraseña para verificación y listo, tendremos nuestro usuario creado.

El administrador del proyecto es parte importante por lo que debemos asignarle uno al proyecto, esto lo
haremos de la siguiente manera:

$ sudo trac-admin /var/trac/projects/practica_uno permission add meme TRAC_ADMIN

Con esto le decimos que “meme” será el administrador del proyecto.

Para aplicar los cambios, reiniciaremos apache y luego ingresaremos a la dirección

http://localhost/trac/practica_uno

$ sudo /etc/init.d/apache2 stop

$ sudo /etc/init.d/apache2 start

ENLAZANDO TRAC Y HUDSON
Esto se logra mediante el plugin “Hudson Edgewall Trac”, para instalarlo debemos descargarlo de internet
(se encuentra en la página oficial de Hudson) y luego:

Primero debemos ingresar a la página principal de Hudson,

luego, en el menú contextual del lado izquierdo, debemos
elegir la opción “Manage Hudson”.

En la nueva ventana que se abrió, en las opciones del lado

derecho, debemos elegir la llamada “Configure System”.

Ahora debemos dirigirnos hasta la opción del plugin de Trac, debemos seleccionarlo para que se proceda a
la instalación.

Luego, hasta el final de página se encuentra el botón para guardar y aplicar cambios, lo pulsamos y nos
redirigirá a una página similar a la que se muestra a continuación, donde nos dirá que tuvimos éxito al
realizar las modificaciones de las configuraciones y una advertencia que dirá que es necesario reiniciar el
Apache y Hudson.
Ahora, para verificar que el plugin está instalado correctamente, debemos ingresar nuevamente a la ruta en
la que se encuentran los plugins, con la salvedad que, ahora nos situaremos en la pestaña “Installed” y
podremos encontrar ahí el plugin Hudson Edgewall Trac.

Para corroborar el correcto funcionamiento de Hudson, crearemos una nueva tarea, esto se logra con la
opción New Job de la selección de menús de la izquierda.

Luego, nos pedirá el tipo de tarea y un nombre, el tipo que debemos elegir para efectos de prueba, es :
“Build a free-style software Project”.

Esto nos creará una nueva tarea, ahora debemos configurarla para que todo funcione bien.
Yendo a la opción “Configure” tendremos que configurar 2 direcciones para que el proyecto funcione bien.
Estos parámetros son:

 Trac website: http://localhost:8000/practica_uno/

 Repository URL: http://localhost/svn/practica_uno/trunk

En la imagen anterior se puede corroborar que el plugin de Trac está correctamente instalado en Hudson.
 Hasta este momento, si ingresamos al página de nuestro
proyecto, el sistema se quejará de que aún no tenemos
creado un Build del proyecto, la advertencia que nos da es la
siguiente:

Podemos crear un Build dando clic en el menú del lado izquierdo, llamado “Build Now”. O bien, en el link
que nos proporciona la advertencia “Run a build”.

Al darle clic, iniciará la compilación y luego, al finalizar veremos

algo como lo
siguiente.

Ahora solo nos queda ingresar al Build y verificar los cambios

realizados, los cambios se muestran en la siguiente imagen.

Nota: Para crear construcciones (Builds) solamente bastará con

pulsar sobre el link “Build Now”.
TRES BUILDS EXITOSOS CON HUDSON DESDE EL REPOSITORIO WEB DE SUBVERSION
Cuando tengamos creado nuestro proyecto dentro de Hudson, nos aparecerá algo similar a lo que se
muestra a continuación.

Le damos clic encima y nos mostraría la siguiente página.

Como podemos observar en la imagen anterior, solamente tenemos disponible un Build. Ahora
procederemos a realizar cambios sobre el proyecto y que dichos cambios se vean reflejados en Hudson y
posteriormente en Trac.

Al proyecto que creamos anteriormente desde NetBeans, le realizaremos cambios, en este caso, la creación
de una nueva clase llamada CNueva1. Al terminar de crearla y colocarle algún código, tendremos que dar clic
derecho sobre el proyecto, luego en el menú Subversion y posteriormente, para aplicar los cambios, en
Commit.
Nos aparecerá la nueva ventana que nos pedirá agregar alguna descripción para el nuevo cambio que se
realizará sobre el proyecto.

Una vez aplicados los cambios deberemos crear un nuevo Build para el proyecto desde la página de Hudson.

El nuevo build se verá en la siguiente imagen, será el Build # 2

Y ahora, los cambios los veremos reflejados en la página de Hudson, como se muestra a continuación.

Ahora realizamos nuevos cambios y los aplicamos con NetBeans, luego creamos un nuevo Build y éste
reflejará dichos cambios. Éste será nuestro Build #3.
Ahora realizamos nuevos cambios y los aplicamos con NetBeans, luego creamos un nuevo Build y éste
reflejará dichos cambios. Éste será nuestro Build #4.
VERIFICANDO LOS CAMBIOS DESDE TRAC
Primeramente, ingresaremos a la página de Trac desde Hudson, ahí podremos encontrar varias opciones y
pestañas dedicadas a cada uno de los temas, por ejemplo, Timeline que tiene el historial de los builds así
como links específicos para adentrarse y verificar los cambios realizados.
Dando clic sobre cada uno de los registros del TimeLine, se obtienen las siguientes imágenes:
BIBLIOGRAFÍA
Los enlaces consultados para la realización del presente reporte, son:

 http://chany1989.blogspot.com/
 http://mario502gt.blogspot.com/
 http://diagonalasterisco.blogspot.com/2009/06/integracion-de-subversion-y-netbeans.html
 http://luntbuild.javaforge.com/
 http://continuum.apache.org/
 http://www.redmine.org/
 http://www.mantisbt.org/
ANEXOS
Para mostrar el ID de los discos duros del sistema, se utilizó la siguiente línea de comando:

$ ls –IF /dev/disk/by-uuid/

Y la salida se muestra a continuación