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

checkout

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

$ svn checkout <url> <path>

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

copy

Éste comando se encarga de copiar un archivo en una copia del trabajo o bien sobre el repositorio. Su sintaxis es la siguiente:

$ svn copy <fuente> <destino>

update

Éste comando se encarga de actualizar cambios que hayan sido realizados en el repositorio y los refleja hacia nuestra copia de trabajo actual.

$ svn update <path>

import

É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.

$ 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

add

Éste comando se encarga de agregar archivos, directorios, enlaces simbólicos, etc, al repositorio central. La sintaxis es:

$ svn add <path>

Nota. Los cambios se reflejan en el repositorio al darle COMMIT.

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. 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>

delete

Éste comando elimina archivos, directorios, enlaces simbólicos, etc. La sintaxis es:

$ svn delete <path>

OTROS COMANDOS

Como nota adjunta, se tienen los siguientes comandos:

Comando Explicación

info

Éste comando da información sobre el repositorio. La sintaxis es la siguiente:

$ svn info

status

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

$ svn status --show-updates --verbose

checkout (con parámetros)

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

$ svn checkout --revision <numero>

update (con parámetros)

Éste comando se utiliza para actualizar la copia local con una revisión en concreto. La sintaxis es la siguiente:

$ svn update --revision <numero>

diff

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

$ 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

create

Éste comando crea un directorio en la ruta especificada como parámetro. La sintaxis es la siguiente:

$ svnadmin create <path>/nombre_directorio

recover

Éste comando se ejecuta solamente para recuperar nuestro repositorio cuando haya ocurrido algún error. La sintaxis es la siguiente:

$ svnadmin recover <path_del_repositorio>

load Éste comando lee un “dumpfile” el cual es un stream con formato proveniente de 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>

dump

Éste comando envía el contenido de un repositorio del sistema hacia un archivo “dumpfile”. La sintaxis es la siguiente:

$ 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:

EN CUANTO A HARDWARE

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

EN CUANTO AL SOFTWARE

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