JUnit: uso de asserts en Netbeans 6.5.1

JUnit es una librería Java de código abierto que facilita la realización de pruebas de unidad aunque también se usa para correr pruebas de integración o funcionales. Básicamente facilita la construcción de tests y su ejecución conjunta.

JUnit tiene diversos paquetes: framework como paquete básico de marcos, runner para algunas clases abstractas y para la ejecución de pruebas, textui y swingui para interfaces de usuario y extensions para algunas contribuciones prácticas al marco. Antes de JUnit las pruebas de unidad se reducían a incluir un main en cada clase que permitiera probar su ejecución, poco cómodo y poco flexible.

Las pruebas que se pueden desarrollar sobre JUnit parten de un sencillo concepto: assert, un assert en una condición que debe cumplirse para considerar que nuestra clase probada funciona de la manera esperada.

NetBeans integra la librería JUnit de forma que es muy sencillo crear un test para una clase determinada. Además permite crear tests en el formato del JUnit v3.8.1, así como en la nueva versión v4.0 basada en anotaciones. Incluso es posible mezclar ambos tipos de tests.

Método	Parámetros	Significado
assertEquals	(double expected, double actual, double delta)	Indica si dos valores double son iguales dentro de un determinado delta
	(float expected, float actual, float delta)	Indica si dos valores float son iguales dentro de un determinado delta
	(Object[] expecteds, Object[] actuals)	Indica si dos arrays de objetos son iguales
	(Object expected, Object actual)	Indica si dos objetos son iguales
assertFalse	(boolean condition)	Comprueba que la condición pasada es falsa
assertNotNull	(Object object)	Comprueba que un objeto NO es nulo
assertNotSame	(Object unexpected, Object actual)	Comprueba que dos objetos NO se están refiriendo al mismo objeto (comparación de identidad en vez de igualdad)
assertNull	(Object object)	Comprueba que un objeto es nulo
assertSame	(Object unexpected, Object actual)	Comprueba que dos objetos se están refiriendo al mismo objeto (comparación de identidad en vez de igualdad)
assertTrue	(boolean condition)	Comprueba que la condición pasada es cierta
Fail	()	Provoca que el test falle

Nota: todos los métodos tienen una segunda versión que acepta como primer parámetro un String en el que mandar.

JUnit incorpora las siguientes ventajas y modificaciones respecto a versiones anteriores:

Las clases que contienen los métodos que representan las pruebas ya no tienen que ser subclases de junit.framework.TestCase
Los métodos que representan las pruebas a realizar ya no tienen que tener el prefijo “test” en su nombre sino que se indican con la anotación @Test
Sustitución del método ’setUp’ por la anotación o anotaciones @Before.
Sustitución del método ‘tearDown’ por la anotación o anotaciones @After.
Se pueden realizar pruebas en donde el tiempo de ejecución es crítico. De manera que una prueba falle si tarda más de X milisegundos en ser ejecutada.
Se pueden realizar pruebas en donde se debe controlar que una excepción es lanzada.
Se pueden desactivar pruebas, a través de la anotación @Ignore.

Utilizar JUnit en Netbeans 6.5.1

Para utilizar JUnit en Netbeans 6.5.1 no tenemos que instalar nada ya que lo trae integrado. Basta con hacer los siguientes pasos:

Creamos nuestra clase genérica con los métodos y atributos.
Seleccionamos la clase a la que le vamos a realizar las pruebas. Le damos clic derecho –> Tools –> Create JUnit Tests
Elegimos el nombre de para la clase y el paquete y lo demás lo dejamos como esta.

Se creara una nueva clase que contiene los métodos de prueba (uno por cada método de la clase original. Solo basta con agregarle la prueba, en nuestro caso un assert.
Ya hecho implementado la prueba basta con ejecutarla, para ello nos vamos a la opción Run del menú y luego a Test Project.
Listo. Se generan los resultados de la prueba la cual podemos verificar.

Julio 5, 2009. Etiquetas: junit, netbeans, 6.5.1, asserts, test. Analisis 2. Deja un comentario.

Struts 2 Framework MVC

Los frameworks pueden ser vistos como implementaciones de patrones de diseño que facilitan la reutilización de diseño y código.
Dado que MVC ha sido utilizado en muchas aplicaciones web, se han desarrollado un conjunto de frameworks que den soporte a áreas comunes en todas las aplicaciones MVC.

Apache Struts es una de estas frameworks

Creada por Craig McClanahan y donada a la Apache Software Foundation en el 2000 (pertenece a Apache Jakarta).

Provee librería de clases y TAG-LIBS que conforman el Controlador, la integración con el Modelo (o lógica de negocio) y facilitan la construcción de vistas.

El Modelo o lógica de negocio es la parte que nos corresponde desarrollar.

Struts 2 está basado en el patrón MVC (Modelo-Vista-Controlador), una arquitectura que busca reducir el acoplamiento dividiendo las responsabilidades en 3 capas claramente diferenciadas:

El modelo, que hace referencia a los datos que maneja la aplicación y las reglas de negocio que operan sobre ellos y que se traducen en Struts 2 en las acciones.

La vista, encargada de generar la interfaz con la que la aplicación interacciona con el usuario. En Struts 2 equivale a los resultados.

El controlador, que comunica la vista y el modelo respondiendo a eventos generados por el usuario en la vista, invocando cambios en el modelo, y devolviendo a la vista la información del modelo necesaria para que pueda generar la respuesta adecuada para el usuario. El controlador se implementa en Struts 2 mediante el filtro FilterDispatcher

Struts ofrece su propio componente controlador y proporciona integración con otras tecnologías para implementar el modelo, mediante tecnologías de acceso a datos como JDBC, y la vista, mediante JSP o XSLT. Además ofrece un sistema de tuberías que permite la comunicación entre el modelo que contiene los datos y las vistas que ofrecen estos datos a los usuarios y reciben sus órdenes.

Una aplicación Struts no es más que una Aplicación Web sobre el Framework de Struts.

Struts 2 es, como el nombre sugiere, la nueva versión del popular framework de desarrollo web en Java Apache Struts. Sin embargo, contrariamente a lo que cabría esperar, el código de ambos tiene poco que ver, dado que Struts 2 no se basa en el código de Struts 1.x, sino en el de otro framework de desarrollo web en Java llamado WebWork, un framework que el creador de Struts consideraba superior a Struts 1.x en varios aspectos.

Mejoras:

Facilitar el deploy de aplicaciones.
Diseño mejorado.
Nuevos tags incorporados
Mejora en la gestión de checkboxes.
Botones para cancelar flexibles.
Soporte para AJAX.
Integración sencilla para Spring.
Resultados especializados.
Formularios POJO (olvídate de los ActionForm).
Acciones POJO.
Añadir plugins fácilmente.
Integrar herramientas de profiling.
Reporte de errores más preciso.
Acciones fáciles de testear.
Valores por defecto para las configuraciones.
Controladores fáciles de customizar.
Integración de herramientas de debbuging.
Añadir nuevos tags fácilmente.

Ventajas

La utilización de esta metodología conlleva una serie de ventajas que nos ayudan a reducir el tiempo requerido para el desarrollo y facilitar el mantenimiento de la aplicación web:

Transporte automático de los datos introducidos en el cliente (JSP) hasta el controlador (Action) mediante formularios (ActionForm).
Transporte automático de los datos enviados por el controlador (Action) a la parte de presentación (JSP) mediante formularios (ActionForm).
Implementa la parte común a todas las aplicaciones en la parte de Controlador (ActionServlet); la parte particular de cada aplicación es fácilmente configurable (struts-config.xml).
La separación de los componentes en capas (MVC) simplifica notablemente el desarrollo y su mantenimiento.

Junio 28, 2009. Etiquetas: framework, java, mvc, struts, struts 2. Analisis 2. Deja un comentario.

Enlace de un contenedor de servlets, Tomcat5.5, con servidor web, Apache, sobre Debian Lenny

Debemos tener instalado Apache2, Tomcat5.5 y Java JDK

Pasos para enlazar Apache con Tomcat:

1. Instalar mod-jk.

$ apt-get install libapache2-mod-jk

2. Editamos el archivo de configuración del mod-jk.

$ vim /etc/libapache2-mod-jk/workers.properties

Escribimos los siguiente:

workers.tomcat_home=/usr/share/tomcat5.5 workers.java_home=/usr/lib/jvm/jdk1.6.0_12 (su path de java jdk) ps=/ worker.list=ajp13_worker worker.ajp13_worker.port=8009 worker.ajp13_worker.host=localhost worker.ajp13_worker.type=ajp13 worker.ajp13_worker.cachesize=10 worker.ajp13_worker.cache_timeout=600 worker.ajp13_worker.socket_timeout=300

3. Creamos y editamos la configuración del mod_jk para el uso de apache.

$ touch /etc/apache2/mod_jk.conf
$ vim /etc/apache2/mod_jk.conf

Añadimos las siguientes líneas:

JkWorkersFile /etc/libapache2-mod-jk/workers.properties JkShmFile /var/log/apache2/mod_jk.shm JkLogFile /var/log/apache2/mod_jk.log JkLogLevel info JkLogStampFormat "[%a %b %d %H:%S %Y] "

4. Añadimos la declaración del módulo.

$ vim /etc/apache2/mods-enabled/jk.load

Debajo del LoadModule ponemos:

Include /etc/apache2/mod_jk.conf

5. Añadimos un nuevo Virtual Host en Apache.

$ vim /etc/apache2/sites-enabled/000-default

Escribimos lo siguiente al final del archivo:

<VirtualHost *:8080> ServerAdmin webmaster@localhost JkMount /* ajp13_worker <LocationMatch ".*WEB-INF.*"> deny from all </LocationMatch> </VirtualHost>

6. Añadimos el nuevo puerto a ser escuchado.

$ vim /etc/apache2/ports.conf

Debajo de NameVirtualHost *:80 ponemos:

NameVirtualHost *:8080

Y añadimos al final:

Listen 8080

7.- Reiniciamos Apache y Tomcat.

$ /etc/init.d/apache2 restart
$ /etc/init.d/tomcat5.5 restart

8. Probamos.

En un explorador web colocamos la siguiente direccion:

http://localhost:8080/

Listo!!!

Junio 18, 2009. Etiquetas: apache, debian, enlazar, jdk, lenny, mod-jk, tomcat, tomcat5.5. Analisis 2. Deja un comentario.

Comandos de Subversion, Investigación Hudson y Trac (Parte Teorica)

Comandos SVN

Desde el lado del cliente-programador, las cosas son más sencillas. A partir de que el programador se haya instalado el svn, hay cientos de comandos que puede utilizar para la interacción con el svn, entre ellos quisiera descatar algunos.

Comandos útiles

Conseguir el código:
svn checkout file:///ruta/hasta/repositorio/ProyectoA/trunk /directorio/de/trabajo/ProyectoA/

Detecta todos los cambios de fichero y árbol que el cliente ha hecho en su copia local:
svn status

Actualizar el código del proyecto:
svn update

Tras modificar y guardar los cambios, se envian al server:
svn commit --message 'comentario'

Añadir archivos al código:
svn add /archivo-N/ --force

Borrar archivos:
svn delete archivo

Rechazar los cambios en un archivo:
svn revert archivo

Volver a una versión anterior determinada:
svn update -r N

Donde N denota la revisión N que a su vez representa el estado del sistema de ficheros del repositorio tras el envío de cambios N-ésimo.
svn revert para eliminar todos sus cambios locales.

Ver un informe de los cambios producidor:
svn log

Fijar una versión, crear una rama, etiquetandola con un nombre sencillo:
Etiquetando la última versión:
svn copy file:///path/repositorio/trunk file:///path/repositorio/tags/0.01-prerelease -m "Version 0.01"

O bien especificando una revisión concreta:
svn copy -r 3 file:///path/repositorio/trunk file:///path/repositorio/tags/0.03-prerelease -m "Version 0.03"

Para hacer una copia limpia del código, y poderlo distribuir
svn export file:///path/repositorio/ProyectoA/trunk tar -cvf proyectoA.tar trunk gzip proyectoA.tar

Hacer copias de seguridad del repositorio:
svnadmin dump /paht/repositorio/ProyectoA | gzip -9 > dump_svn_proyectoA.gz

Si se incluye en el CRON, se harán las copias de seguridad cada tanto de una manera automática.

Comandos SvnAdmin

Crear Repositorio
svnadmin create /usr/local/svn/repos

Comando para hacer un backup
svnadmin dump /home/javoaxian/repositorioSVN | gzip -9 > respaldo_repositorio_2008-09-08.gz

Deltify
comprime el repoitorio almacenado solo las diferencias respecto a la version anterior

Dump
Vuclea el contenido del repositorio empleando un formato portable

Hotcopy
Crea una copia de un repositorio de forma segura aunque este siendo usado

List-dblogs
Muestra los archivos de historial de Berkeley DB asociados con el repositorio

List-unused-dblogs
Muestra los archivos de historial de berkeley DB asociados con el repositorio y que ya no son usados. Pueden borrarse sin problemas, aunque podrian almacenarse para recuperarse de una perdida de datos catastrofica.

Load
Carga una serie de revisiones en un repositorio a partir de un flujo de datos que emplee el mismo formato de volcado que el subcomando dump

Lstxns
muestra la lsita de transacciones que todavia no han sido enviadas

Recover
realiza una recuperacion en caso de error.

Rmtxns
elimina las transacciones limpiamente.

Setlog
sustituye el mensaje de historial de una revision en concreto por otro nuevo.

Verify
Compruebala integridad del repositorio.

Herramientas Para Integracion Continua

Existen diversos productos en el mercado para la Integracion Continua. La mayoria cuentan con una interfaz web que muestra el estado de los proyectos, ultimas corridas, e informes gráficos de diversos tipos.

Hudson

Esta herramienta de Integración Continua nos lleva un paso más allá de los resultados de nuestra solución de Ciclo de Vida, que es Maven. Es decir, ya no sólo se trata de paquetizar e integrar las distintas áreas de desarrollo de nuestro producto resolviendo las dependencias de código de los paquetes subdivididos, sino de que la integración sea efectiva, cumpla nuestros criterios de calidad y el tiempo empleado en la detección de errores y su resolución sea el menor posible. Hudson nos proporciona una solución sencilla para llevarlo a cabo.

Podemos comparar a Hudson con una de las herramientas CI más consolidadas actualmente, que es CruiseControl, comprobando que, además de ofrecer mayor amplitud de funcionalidad, sus características vienen determinadas por la instalación sencilla de plugins.

Resumiendo, parte de las ventajas de Hudson vienen determinadas por:

Fácil instalación y uso (un fichero WAR es toda la herramienta de instalación)
Plugins fácilmente extensibles
Soporte completo de Maven, lo que nos facilita enormemente la integración
Soporte para entornos “colaborativos” (múltiples equipos y grupos de proyectos)
Software Libre 100%
Sistema de alertas intuitivo para los desarrolladores
Muy pocos problemas “reportados” de esta herramienta

Maven

De forma más detallada a nuestra introducción anterior, Maven es una herramienta de gestión y comprensión de proyectos de desarrollo de software, normalmente en Java, que nos permite compilar, testar integridad y compilación, desplegar, documentar y gestionar las dependencias de código de forma sencilla y extendible.

Maven es una herramienta abierta y libre (pertenece al Proyecto Apache) claramente orientada al trabajo en equipo, siendo esta es una de las principales razones por las que la elegimos como herramienta ideal para metodologías agiles de programación y posterior Integración Continua con otras herramientas software.

La herramienta es compleja pero fácil de usar y muy rápida a la hora de compilar y desplegar proyectos. Entre las ventajas de usar Maven como herramienta de desarrollo en el trabajo en equipo, podemos destacar:

La dependencia entre proyectos no es problema
Un mismo proyecto se puede ejecutar en distintos entornos. Sólo hay que cambiar un archivo de configuración
La integración del trabajo de desarrolladores es transparente
Hay una maximización de la cohesión del código y una minimización del acoplamiento
Fácil reutilización del código

Para los desarrolladores familiarizados con herramientas similares, como Apache Ant, Maven ofrece las mismas funcionalidades, con la diferencia de gestionar las dependencias de proyectos de una forma mucho más sencilla y comprensible, optimizando notablemente el tiempo de desarrollo en trabajos multiproyecto.

En definitiva y en nuestro caso, Maven nos proporciona una solución modular orientada al trabajo en equipo que elimina problemas de herramientas anteriores, como es la compleja resolución de dependencias, a la vez que nos permite integrar el trabajo con otras herramientas de Integración Continua. Es importante destacar para nuestro caso que se dispone de un plugin para proyectos JRuby.

CruiseControl

CruiseControl es un framework para el proceso de Integracion Continua. Incluye, aunque no es limitado, plugins para notificaciones por Email, Ant, y se puede usar con varias herramientas de control de versiones. Provee una interfaz web para ver el detalle del actual y anteriores build’s.

Herramientas de Gestores de Fallos

Trac

http://trac.edgewall.com/

Trac es un poco más que un gestor de fallos: realmente es un sistema wiki y gestor de fallos integrado. Usa el enlace Wiki para conectar ejemplares, ficheros, grupos de cambios de control de versión, y simples páginas wiki. Es bastante simple de configurar, y se integra con Subversion

GNATS

http://www.gnu.org/software/gnats/

GNU GNATS es uno de los gestores de fallos de código abierto más antiguos, y se usa extensamente. Su mayor fortaleza reside en la diversidad de interfaces (no solamente puede ser usado a través de un navegador WEB, sino que también a través de correo electrónico o utilidades de línea de comandos), y el almacenamiento de los ejemplares en texto plano. El hecho de que los datos de todos los ejemplares se almacenen en ficheros de texto en el disco hace que sea más fácil escribir herramientas a medida para buscar y analizar sintácticamente los datos (por ejemplo, para generar informes estadísticos). GNATS también puede absorber correos electrónicos de muchas maneras, y añadirlos a los ejemplares apropiados basados en patrones dentro de las cabeceras del correo electrónico, lo que hace que el registro de las conversaciones del usuario/desarrollador sean muy fáciles.

Scarab

http://scarab.tigris.org/

Scarab está pensado para ser un gestor de fallos altamente parametizable y con todas las características, ofreciendo más o menos el conjunto total de las características ofrecidas por otros gestores de fallos: entradas de datos, consultas, informes, notificaciones a grupos interesados, acumulación colaborativa de comentarios, y gestión de dependencias.

Se parametriza a través de páginas web administrativas. Se puede tener múltiples “módulos” (proyectos) activos en una única instalación de Scarab. Dentro de un módulo dado, se puede crear nuevos tipos de ejemplares (defectos, mejoras, tareas, peticiones de apoyo, etc.), y añadir atributos arbitrarios, para afinar el gestor a los requisitos específicos de tu proyecto.

Tabla Compartiva

Herramienta	Proyecto Origen	Open Source	Free	Lenguaje de Aplicación	Numero de Desarrolladores Activos	Otras Dependencias	Subversion	Añade Nuevos Proyectos	Clona Proyectos	Autenticacion de Usuario
HUDSON	java.net	si	si	java	5 a 10	JRE	si	si	si	si
CRUISECONTROL	ThoughtWorks	no	Gratis para los pequeños equipos y proyectos de código abierto	java	5	JRE, SCM cliente	si	Falla	no	si
CUNTINUUM	ThoughtWorks	no existe	Edicion Gratuita Disponible	java	?	SCM cliente	si	si	no	si

Conclusion

Hudson es una herramienta libre y abierta relativamente nueva de Integración Continua muy utilizada y de gran éxito en el entorno de desarrollo del software. Su arquitectura basada en plugins y su fácil instalación la hacen una herramienta potente y fácil de usar. El desarrollo de plugins es una característica importante al destacar su flexibilidad.

Trac permite enlazar información entre una base de datos de errores de software, un sistema de control de versiones y el contenido de un wiki. También sirve como interfaz web de un sistema de control de versiones como Subversion, Git, Mercurial, Bazaar o Darcs.

Junio 14, 2009. Etiquetas: comandos, fallos, gestor, integracion continua, svn, svnadmin. Analisis 2. Deja un comentario.

Instalación de Subversion + Trac + Hudson (Parte Practica)

Pasos para instalar subversion, trac y hudson en Debian Lenny

Instalando apache con webDAV

1. Instalar los paquetes Apache2, Subversion y libApache2-svn como usuario root.

$ su
$ apt-get install apache2 subversion libapache2-svn

2. Creamos una carpeta que sera nuestro repositorio

$ sudo mkdir /var/svn-repos

3. A continuación le indicamos a Subversion que es un repositorio:

$ svnadmin create /var/svn-repos/practica1

4.Creamos un grupo y le agregamos un usuario

$ groupadd subversion $ addgroup usuario subversion

5. Ponemos permisos para que el servidor web pueda modificar el repositorio:

$ chown -R www-data.subversion /var/svn-repos $ chmod -R 770 /var/svn/repos/*

Configurar apache con soporte de webDAV y enlazarlo con subversion

6. Modificamos el archivo siguiente:

$ vim /etc/apache2/mods-available/dav_svn.conf

7. Le agregamos las siguientes lineas al final:

<Location /svn_p1>

DAV svn SVNPath /var/svn-repos/practica1 AuthType Basic AuthName "Subversion Repository" AuthUserFile /etc/apache2/dav_svn.passwd Require valid-user

</Location>

8. Creamos el archivo de autenticación:

$ htpasswd -c /etc/subversion/passwd usuario

9. Reiniciamos apache

$ /etc/init.d/apache2 restart

10. Abrimos el explorador e insertamos la direccion:

http://localhost/svn_p1

11. Nos muestra lo siguiente

svn – Revision 0: /

Creamos un proyecto nuevo en el repositorio

12. Lo primero es, en un directorio temporal, crear el directorio del proyecto:

~$ cd tmp/ ~/tmp$ mkdir hola_mundo

Creación de un repositorio con la estructura básica (trunk,branches,tags)

13. Se acostumbra tener tres directorios dentro de un proyecto: branches donde están las ramas del proyecto, tags las diferentes versiones y trunk donde está la versión actual del proyecto. Para ello realizamos lo siguiente:

~/tmp$ cd hola_mundo/ ~/tmp/hola_mundo$ mkdir branches tags trunk

14. A continuación importamos todo eso al repositorio:

~/tmp/hola_mundo$ cd .. ~/tmp$ svn import hola_mundo http://localhost/svn_p1 -m "Creando la estructura del proyecto"

Ya podemos borrar el archivo temporal.

16. El siguiente paso es obtener una copia de trabajo de los archivos:

$ svn checkout http://localhos/svn_p1/trunk practica1

Fijese que obtuvimos trunk, (no es necesario por ahora los otros directorio). El practica1 del final es una indicación del directorio donde se va a grabar la copia de trabajo.

Creación de un proyecto java, hola mundo, y ubicarlo en el trunk del respositorio

17. A continuación vamos a adicionar dos nuevos archivos al proyecto: hola_mundo.java. Lo primero es crear el archivo:

$ cd practica1/ $ vim hola_mundo.c
con el siguiente contenido:

public class HolaMundo { public static void main(String[] args) { System.out.println("Hola Mundo"); } }

18. Lo adicionamos al proyecto:

$ svn add hola_mundo.java

19. Finalmente enviamos todos los cambios al repositorio:

$ svn commit -m "Se adicionó el programa hola_mundo.java"

snapshot3

Modificar el aspecto utilizando un css elaborado para darle buen
aspecto al front-end web de subversion

20. Descargamos ReposStyle.zip aqui

21. Lo descomprimos en la carpeta root de apache

$ cd /var/www $ unzip carpeta_donde_se_descargo/repos-style-2.0.zip

22. Agregamos la siguiente linea despues de SVNPath /var/svn-repos/practica1

SVNIndexXSLT "/repos-web/view/repos.xsl"

23. Cambiamos los permisos a la carpeta:

$ chown -R www-data.subversion /var/www $ chmod -R 755 /var/www

24. Reiniciamos apache

$ /etc/init.d/apache2 restart

25. Verificamos la pagina

http://localhost/svn_p1

Listo!!!!

Instalando Trac

1. Primero instalamos algunos paquetes para que funcione trac con subversion

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

2. Editamos un archivo de apache para integrar python

$ vim /etc/apache2/sites-available/default

3. La seccion Directory /var/www/ debe quedar asi
[...]

Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
AddHandler mod_python .py
PythonHandler mod_python.publisher
PythonDebug On

[...]

4. Creamos la base de datos de trac

$ mkdir /srv/trac

5. Inicializamos el proyecto

$ trac-admin /srv/trac/practica1 initenv

6. Dejamos todas las opciones por default menos “Path to repository [/path/to/repos]” que seria:

Path to repository [/path/to/repos]> /srv/svn-repos/practica1

7. Le cambiamos propietario a la carpeta

$ chown -R www-data.www-data /srv/trac/proyecto

8. Es el momento de comprobar que trac y su unión con el repositorio de subversion funcionan correctamente, para ello lanzaremos el servidor incluido en trac:

$ tracd -p 8080 /srv/trac/proyecto

9. Abriendo la URL http://localhost:8080/ deberíamos ver disponible nuestro proyecto, “practica1“.

10. Comprobamos que la función de “Browse Source” funciona correctamente.

Configurar trac para que soporte el proyecto creado en subversion

11. Bien, ahora editamos la configuración para que Apache pase las peticiones que vayan a /trac a nuestro conjunto de proyectos en /srv/trac.
Editando el fichero /etc/apache2/conf.d/trac.conf añadimos antes del cierre de lo siguiente:

$ vim /etc/apache2/conf.d/trac.conf

SetHandler mod_python PythonInterpreter main_interpreter PythonHandler trac.web.modpython_frontend PythonOption PYTHON_EGG_CACHE /tmp/python_egg_cache PythonOption TracEnvParentDir /srv/trac

12. Reinciamos Apache:

$ /etc/init.d/apache2 restart

13. Probamos la pagina

http://localhost/trac

Listo!!!

Instalando Hudson

1. Antes de poder instalar Hudson debemos instalar java y tomcat, lo hacemos de la siguiente manera:

$ apt-get install sun-java6-jdk
$ apt-get install tomcat5.5 tomcat5.5-admin tomcat5.5-webapps

2. Modificar el archivo para que tomcat deshabilitarle la seguridad ya que si no le agregamos esta linea nos muestra error

$ vim /etc/default/tomcat5.5

3. Agregar al final

TOMCAT5_SECURITY=no

4. Probamos si tomcat esta funcionando escribiendo en un browser: http://localhost:8180. Si todo anda bien deberemos crear un usuario administrador con un rol. Para eso editamos el archivo tomcat-users.xml y luego reiniciamos el servidor:

$ vim /var/lib/tomcat5.5/conf/tomcat-users.xml

 <role rolename="manager"/> <role rolename="admin"/> <user username="user" password="secreto" roles="manager"/> <user username="hudson-admin" password="secreto" roles="admin"/> </tomcat-users>

5. Abrimos el administrador de Tomcat, aquí nos pedira el usuario y contraseña que recien agregamos en tomcat-users.xml. Para esto escribimos la siguiente direccion en el browser: http://localhost:8180/manager/html. En la sección apropiada agregamos el archivo hudson.war para poder desplegarlo en el contenedor.

6. Creamos el directorio de trabajo de Hudson y le otorgamos permisos:

$ mkdir /home/hudson
chown -R tomcat55:nogroup /home/hudson/ chmod -R 755 /home/hudson/

7. En el archivo /etc/init.d/tomcat6 agregamos a la variable JAVA_OPTS la variable -DHUDSON_HOME con el valor del directorio de trabajo de hudson que definimos en el paso 6.

$ vim vim /etc/init.d/tomcat5.5

8. Debe quedar asi

JAVA_OPTS="$JAVA_OPTS -Djava.endorsed.dirs=$CATALINA_HOME/endorsed -Dcatalina.base=$CATALINA_BASE -Dcatalina.home=$CATALINA_HOME -Djava.io.tmpdir=$CATALINA_BASE/temp -DHUDSON_HOME=/home/hudson"

9. Reiniciamos Tomcat

$ /etc/init.d/tomcat5.5 restart

10. Bueno…ahora el ultimo paso es probar si hudson esta andando escribiendo en el browser la dirección: http://localhost:8180/hudson