JUnit fue creado por Erich Gamma y Kent Beck y es utilizado en programación para hacer pruebas unitarias de aplicaciones  Java.

JUnit es también un medio de controlar las pruebas de regresión, necesarias cuando una parte del código ha sido modificado y se desea ver que el nuevo código cumple con los requerimientos anteriores y que no se ha alterado su funcionalidad después de la nueva modificación.

El propio framework incluye formas de ver los resultados (runners) que pueden ser en modo texto, gráfico (AWT o Swing) o como tarea en Ant.

En la actualidad las herramientas de desarrollo como Netbeans y Eclipse cuentan con plug-ins que permiten que la generación de las plantillas necesarias para la creación de las pruebas de una clase Java se realice de manera automática, facilitando al programador enfocarse en la prueba y el resultado esperado, y dejando a la herramienta la creación de las clases que permiten coordinar las pruebas.

Un método Assert es un método de JUnit que realiza una prueba y que retorna un “AssertionFailedError” si la prueba fallo.

Tipos de Assert:

1. assertTrue(boolean test)

assertTrue(String message, boolean test)

2. assertFalse(boolean test)

assertFalse(String message, boolean test)

3. assertEquals(expected, actual)

assertEquals(String message, expected, actual)

4. assertSame(Object expected, Object actual)

assertSame(String message, Object expected, Object actual)

5. assertNotSame(Object expected, Object actual)

assertNotSame(String message, Object expected, Object actual)

6. assertNull(Object object)

assertNull(String message, Object object)

7. assertNotNull(Object object)

assertNotNull(String message, Object object)

8. fail()

fail(String message)

Utilización de Junit en Netbeans:

Para esta práctica utilizaremos Netbeans versión 5.0 el cual ya trae integrado Junit versión 3.8.1.

Para realizar una clase de pruebas unitarias en Netbeans, seleccionamos la clase a la cual le queremos realizar las pruebas, le damos click derecho y nos vamos a “Tools”, luego en el submenú que aparecerá escogemos la opción de “Create JUnit Tests”.

Ahora nos aparecerá una ventana con una serie de opciones, en este caso dejamos las opciones default y le damos click a “OK”.

Automáticamente se creara la clase de pruebas para la clase que seleccionamos, se creara un método de prueba por cada método que tengamos en nuestra clase original.

A continuación se presenta una prueba de ejemplo:

public void testMete_pila() {

int expResult = 0;

int resultado = test.mete_pila(8);

System.out.println(“mete_pila=”+resultado);

assertNotSame(expResult, resultado);

}

Y a continuación se muestra el método original:

public int mete_pila(int a) {

this.pila.push(a);

return this.pila.size();

}

Podemos ver que esta prueba nos retornara verdadera ya que la pila no estará vacía, por lo que la prueba será exitosa.

Después de que escribamos las pruebas para cada método, debemos de correr las pruebas para ver si nuestro código esta correcto.

Para realizar esto vamos a “Run” y en el menú escogemos “Test <nombre_de_la_aplicacion>”.

Automáticamente se generaran los resultados de la prueba y aparecerán en la parte de debajo de la pantalla:

Instalación del JDK:
Primero debemos de descargar la JDK de la página de Sun, en este caso utilizaremos las versión 5. Para instalar el JDK ejecutamos las siguientes instrucciones
# cp -p jdk-1_5_0_06-linux-i586.bin /usr/local
# cd /usr/local
# chmod +x jdk-1_5_0_06-linux-i586.bin
#./jdk-1_5_0_06-linux-i586.bin
# rm jdk-1_5_0_06-linux-i586.bin

Ahora creamos la variable de entorno para indicar dónde está instalado el JDK y añadir a la variable PATH el directorio en el que se encuentran los binarios para poder ejecutarlos desde cualquier sitio. Para realizar esto abrimos el archivo /etc/profile y añadimos las siguientes líneas al final:
JAVA_HOME=/usr/local/jdk1.5.0_06
PATH=$PATH:$JAVA_HOME/bin
export PATH JAVA_HOME

Actualizamos las variables de entorno:
source /etc/profile

Compilación e instalación de Apache:
Descargamos el código fuente de Apache, luego lo descomprimimos, lo compilamos y por ultimo lo instalamos:
# cp -p httpd-2.2.0.tar.gz /usr/local/src/
# cd /usr/local/src
# tar xvzf httpd-2.2.0.tar.gz
# rm httpd-2.2.0.tar.gz
# cd /usr/local/src/httpd-2.2.0
#./configure –prefix=/usr/local/apache –enable-module=most –enable-mods-shared=most
# make
# make install

Ahora iniciamos el servidor para ver si no hemos cometido algún error:
# /usr/local/apache/bin/apachectl start

Si todo está bien deberíamos poder abrir la URL http://localhost en un navegador y ver la página de bienvenida de Apache.

Ahora detenemos Apache y lo iniciamos hasta después de instalar Tomcat y el conector:
# /usr/local/apache/bin/apachectl stop

Instalación de  Tomcat:
Descargamos Tomcat y la descomprimimos:
# cp -p apache-tomcat-5.5.16.tar.gz /usr/local/
# cd /usr/local
# tar xvzf apache-tomcat-5.5.16.tar.gz
# rm apache-tomcat-5.5.16.tar.gz

Vamos otra vez a editar el archivo /etc/profile para añadir la variable de entorno CATALINA_HOME:
CATALINA_HOME=/usr/local/apache-tomcat-5.5.16
export CATALINA_HOME

Y actualizamos:
source /etc/profile

Por último ejecutamos el script de iniciación de tomcat:
# /usr/local/apache-tomcat-5.5.16/bin/startup.sh

Se deberá ver la página de bienvenida de Tomcat en http://localhost:8080.

Ahora paramos Tomcat:
# /usr/local/apache-tomcat-5.5.16/bin/shutdown.sh

Compilación e instalación del conector JK:
Existen dos versiones del conector, JK y JK2. Aquí vamos a utilizar la versión JK. El código fuente lo podemos descargar de la página de Tomcat.
Ahora compilamos el módulo mod_jk.so:
# cp -p jakarta-tomcat-connectors-1.2.15-src.tar.gz /usr/local/src/
# cd /usr/local/src
# tar xvzf jakarta-tomcat-connectors-1.2.15-src.tar.gz
# rm jakarta-tomcat-connectors-1.2.15-src.tar.gz
# cd jakarta-tomcat-connectors-1.2.15-src/jk/native/
#./buildconf.sh
#./configure –with-apxs=/usr/local/apache/bin/apxs
# make
# make install

Y ahora sólo falta configurarlo. Creamos un nuevo archivo workers.properties en /usr/local/apache/conf con el siguiente contenido:
workers.tomcat_home=/usr/local/apache-tomcat-5.5.16/
workers.java_home=$JAVA_HOME
ps=/
worker.list=default
worker.default.port=8009
worker.default.host=localhost
worker.default.type=ajp13
worker.default.lbfactor=1

Editamos el archivo de configuración de Apache “/usr/local/apache/conf/httpd.conf” para cargar el módulo. En la sección LoadModules añadimos:
LoadModule jk_module modules/mod_jk.so

Y al final del archivo:
JkWorkersFile “conf/workers.properties”
JkLogFile “logs/mod_jk.log”
JkLogLevel warn
JkMount /jsp-examples default
JkMount /jsp-examples/* default

JkMount es la línea que indica a Apache que solicitudes reenviar a Tomcat. En este caso llamaremos a Tomcat siempre que se intente acceder a cualquier archivo del directorio jsp-examples, donde se guardan algunos ejemplos para demostrar el uso de JSP, utilizando el protocolo definido por “default”. También podríamos haber utilizado algo del estilo *.jsp para ejecutar Tomcat sólo en el caso de que los archivos terminaran con esta extensión. Por último iniciamos Apache y Tomcat:
# /usr/local/apache-tomcat-5.5.16/bin/startup.sh
# /usr/local/apache/bin/apachectl start

Al introducir la URL http://localhost deberíamos ver la web de bienvenida de Apache, al introducir http://localhost:8080 la de Tomcat, y con http://localhost/jsp-examples Apache enviará la petición a Tomcat.

Struts2 es un framework para desarrollar aplicaciones web basadas en Java. Surge de la unión de Webwork y de Struts 1.x. La base para Struts 2 es webwork, ya que su creador piensa que webwork es mucho más sencillo y muy superior a Struts 1.x, por lo que es solo el nombre lo que obtiene de Struts 1.x. En la web oficial de Struts 2 se informa de que es más simple y mucho más completo.

Herramientas necesarias

Necesitamos las herramientas de Java (JDK), un IDE y un servidor de aplicaciones que puede ser Tomcat, y por su puesto debemos descargar la distribución 2.0.14 de Struts.
Esta distribución contiene el código, la documentación, y varias aplicaciones web de ejemplo que se encuentran en formato “.war”.

La primera versión estable de Struts 2 es la 2.0.6 GA (General Availability). Esta versión incluye bastantes mejoras y/o cambios con respecto a Struts 1.x. Entre ellas están:
- 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 (Plain Old Java Objects), ya no se utilizan los ActionForm.
- Acciones POJO (Plain Old Java Objects).
- 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.

Struts 2 está basado en el patrón MVC (Modelo-Vista-Controlador). La qrquitectura MVC 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 y que en Struts 2 equivale a los resultados.
- El controlador (que se implementa mediante el filtro FilterDispatcher), 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 framework de Struts 2 se encarga de:
- Obtener y transformar los parámetros de las peticiones del cliente
- Validar los datos
- Buscar qué acción se debe realizar en el modelo según la petición
- Buscar la página a mostrar al usuario según la respuesta del modelo
- Proporcionar los datos del modelo a la vista
- Ocuparse de la internacionalización

A continuacion se muestra una imagen con la arquitectura de Struts2:

Ejemplo:
Para realizar este ejemplo utilizaremos Struts 2, Eclipse y Tomcat. Abrimos Eclipse y nos dirigimos a File > New > Dynamic Web Project para crear un nuevo proyecto. En Project name introducimos el nombre que queramos utilizar para el proyecto, en este caso “hola”, luego le damos click a Finish.
Ahora copiamos las librerías con las que vamos a trabajar a la carpeta WebContent\WEB-INF\lib:
- commons-fileupload
- commons-logging
- freemarker
- ognl
- struts2-core
- xwork.

Editamos el archivo web.xml para añadir el filtro que sirve a Struts 2 a modo de punto de entrada a la aplicación: FilterDispatcher. Hacemos doble clic sobre “Deployment Descriptor: hola” y sustituimos el contenido por el siguiente:
view plaincopy to clipboardprint?
<?xml version=”1.0″ encoding=”UTF-8″?>
<web-app xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns=”http://java.sun.com/xml/ns/javaee” xmlns:web=”http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
id=”WebApp_ID” version=”2.5″>
<display-name>hola</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>

Ahora vamos a crear la página de inicio de nuestra aplicación. Como en el descriptor de despliegue hemos indicado que index.jsp es uno de los archivos de bienvenida, cuando en la URL no se especifique el archivo a mostrar dentro del directorio se mostrará por defecto index.jsp; de esta forma tanto http://localhost:8080/hola/index.jsp como http://localhost:8080/hola/ mostrarán nuestra nueva página.

Hacemos clic con el botón derecho sobre WebContent y seleccionamos New > JSP, en File name escribimos index.jsp. El contenido de la página será el siguiente:
view plaincopy to clipboardprint?
<%@ taglib uri=”/struts-tags” prefix=”s” %>
<html>
<body>
<s:form action=”Hola”>
<s:textfield name=”nombre” label=”Nombre”/>
<s:submit/>
</s:form>
</body>
</html>

Las acciones en Struts 2 son clases Java que implementan la interfaz Action o extienden la clase ActionSupport. La creamos haciendo click derecho sobre Java Resources:src y seleccionando New > Class. En Name ponemos “Hola”. Al crear el WAR de la aplicación el archivo .class acabará en WebContent/WEB-INF/classes. El código de la acción es el siguiente:
view plaincopy to clipboardprint?
import com.opensymphony.xwork2.ActionSupport;
@SuppressWarnings(“serial”)
public class Hola extends ActionSupport {
private String nombre;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String execute() {
System.out.println(nombre);
return SUCCESS;
}
}

Como vemos el método execute devuelve un string indicando el resultado de la acción. En este caso se devuelve SUCCESS, que es una constante proveniente de la clase que extendemos, ActionSupport, y cuyo valor es “success”. Esto sirve para que Struts2 sepa a qué página redirigir. Creamos este archivo dandole click derecho sobre Java Resources:src, seleccionamos New > XML, hacemos click en Next y seleccionamos como nombre struts.xml y como directorio de destino src. Este archivo acabará en WebContent/WEB-INF/classes al crear el WAR de la aplicación. Su contenido debe ser el siguiente:
view plaincopy to clipboardprint?
<?xml version=”1.0″ encoding=”UTF-8″ ?>
<!DOCTYPE struts PUBLIC “-//Apache Software Foundation//DTD Struts Configuration 2.0//EN” “http://struts.apache.org/dtds/struts-2.0.dtd”>
<struts>
<package name=”mi-paquete” extends=”struts-default”>
<action name=”Hola”>
<result name=”success”>/hola.jsp</result>
</action>
</package>
</struts>

Vamos a ver por último el código de hola.jsp. Hacemos clic con el botón derecho sobre WebContent y seleccionamos New > JSP; en File name escribimos hola.jsp. El contenido del archivo es el siguiente:
view plaincopy to clipboardprint?
<%@ taglib uri=”/struts-tags” prefix=”s” %>
<html>
<body>
Hola <s:property value=”nombre”/>
</body>
</html>

En esta página lo único que hacemos es utilizar la etiqueta <s:property/> para mostrar la propiedad nombre de la acción, que se toma de una pila de valores llamada ValueStack.

Ahora debemos probar lo que hemos realizado. Arrastramos el proyecto sobre nuestra instancia de Tomcat en la pestaña Servers, e iniciamos el servidor haciendo clic con el botón derecho sobre él y seleccionando Start, se deberá mostrar una página con un textfield y un botón.

A continuación encontraran dos links hacia una guia y un tutorial:

http://struts.apache.org/2.x/docs/guides.html

http://struts.apache.org/2.x/docs/tutorials.html

Se incluyen las configuraciones de VirtualBox, Windows Server 2003 y SQL Server 2005.

Se utilizara Windows Server 2003 como sistema operativo y se correrán dos maquinas virtuales en VirtualBox.

Configuración de VirtualBox:

A continuación se configurara VirtualBox para tener una red interna entre 2 maquinas virtuales, los pasos a seguir son los siguientes:

1. Seleccionamos la primer maquina virtual y le damos click al botón de “Configuración”.

2. Ahora le damos click al botón que dice “Red” en el panel izquierdo. Luego seleccionamos la pestaña de “Adaptador 1”. En la parte donde dice “Attached to” seleccionamos la opción de “Red Interna” y en donde dice “Name” podemos dejar la opción default que es “intnet” o le podemos poner otro nombre. Después de realizar esto le damos click a “Ok” para guardar los cambios.

3. Luego hacemos lo mismo con la segunda maquina virtual. La seleccionamos, le damos click al botón de “Configuración” y repetimos el paso 2.

Luego de realizar lo descrito anteriormente tendremos una red entre nuestras dos maquinas virtuales.

Sin embargo estas maquinas virtuales aun no tendrán dirección IP por lo que se las podemos asignar manualmente, o crear un dominio, con servidor DHCP para que las direcciones se asignen automáticamente.

Yo decidí crear un dominio, por lo que a continuación les muestro los pasos para crear uno en Windows server 2003.

Creación de un dominio en Windows server 2003:

1. Nos vamos a “Herramientas administrativas” y luego a “Administre su servidor”

2. Luego le damos click al link que dice “Agregar a quitar función”.

3. Se abrirá el asistente de configuración, le damos click a “Siguiente”

4. En este paso se nos pedirá que ingresemos el CD de Windows server 2003, por lo que lo metemos a la unidad de CD-Rom y esperamos a que se copien a nuestra PC los archivos necesarios para poder continuar.

5. En la ventana de opciones de configuración escogemos la opción de “Configuración típica para un servidor principal” y luego le damos click a “Siguiente”.

6. Ahora escogemos un nombre para nuestro dominio, debe de ser de la forma: nombre_del_dominio.local, en este caso es “ove.local”.

7. Ahora en “Nombre de dominio NetBIOS”, escribimos solo el nombre del dominio que escribimos en el paso anterior, en este caso es “OVE”.

8. Ahora en la ventana de Reenviando consultas DNS escogemos la opción “No, no reenviar consultas” y le damos click a “Siguiente”.

9. La siguiente ventana nos mostrara un resumen con todos los componentes que se van a instalar. Le damos click a “Siguiente” y la instalación comenzara.

10. Cuando la instalación termine se abrirá una ventana indicándolo por lo que solo le damos click al botón de “Finalizar”.

Ahora que ya tenemos configurado nuestro servidor, solo tenemos que ir a la otra máquina virtual y hacerla parte del dominio que recién acabamos de crear. Para realizar esto hacemos lo siguiente:

1. Le damos click derecho a mi PC y nos vamos a propiedades.

2. Luego nos vamos a la pestaña de “Nombre de equipo” y después le damos click al botón de “Cambiar”.

3. Por último seleccionamos la opción de “Dominio” y escribimos el nombre del dominio que acabamos creamos, en este caso es “ove.local”.

Configuraciones en SQL Server 2005:

Cuando estemos instalando SQL Server 2005 tenemos que tener cuidado de realizar lo siguiente en las ventanas que se presentan a continuación:

1. En la ventana de “Service Account”, tenemos que ver que la opción de “Use the built-in System account” este seleccionada y que en el combo-box este seleccionada la opción de “Network Service”. Tambien tenemos que seleccionar la opción de “SQL Server Agent”.

2. Luego en la ventana de “Authentication Mode” seleccionamos la opción de “Mixed Mode” y establecemos una contraseña para el usuario “sa”.

Luego de terminar la instalación de SQL Server 2005 tenemos que realizar lo siguiente.

1. Abrimos “SQL Server Configuration Manager”

2. Nos vamos a “Protocols for MSSQLSERVER” y habilitamos el protocolo TCP/IP

3. Después nos aparecerá una ventana que nos indica que los cambios tomaran efecto hasta que se reinicie el servicio, le damos click a “Aceptar”.

4. Lo que tenemos que hacer después es reiniciar el servicio de SQL Server, entonces nos vamos a “SQL Server 2005 Services”, del lado derecho veremos los servicios que están corriendo, reiniciamos el servicio “SQL Server (MSSQLSERVER)”, para realizar esto seleccionamos el servicio y le damos click derecho y luego “Restart”.

Aparecerá una ventana que nos muestra el progreso de la tarea.

Ahora tenemos que revisar que nuestro servidor tenga habilitada la opción de conexiones remotas, para realizar esto hacemos lo siguiente:

1. Nos vamos a “SQL Server Surface Area Configuration”.

2. En la ventana de “Surface Area Configuration for Services and Connections”, seleccionamos del lado izquierdo “Database Engine” y luego “Remote Connections”. Revisamos que las opciones “Local and remote connections” y “Using TCP/IP only” estén seleccionadas.

Después de realizar los pasos descritos anteriormente, nuestro servidor ya debe de aceptar las conexiones remotas.

Para probar esto vamos a nuestra segunda maquina virtual, la que unimos al dominio que creamos. Vamos a “SQL Server Management Studio”.

En “Server Name” ponemos el nombre de nuestro servidor principal, en “Authentication” escogemos la opción de “SQL Server Authentication”.

Finalmente en “Login” escribimos “sa” y en “Password” escribimos la contraseña que escribimos en la instalación de SQL Server 2005 y hacemos click en “Connect”.

Con esto deberemos de poder conectarnos remotamente a nuestro servidor.

svn

svn add PATH…

Añadir archivos, directorios o enlaces simbólicos a su copia de trabajo y el calendario para la adición en el repositorio. Ellos serán cargados y añadido al repositorio en el próximo commit.

Ejemplo:

$ svn add –non-recursive otherdir

A         otherdir

svn checkout URL[@REV]… [PATH]

Obtiene una copia local del trabajo del repositorio que se está trabajando. Si se omite el path, se toma el path base de la URL que se está utilizando como destino.

Ejemplo:

$ svn checkout file:///tmp/repos/test  file:///tmp/repos/quiz

A  test/a

A  test/b

Checked out revision 2.

A  quiz/l

A  quiz/m

Checked out revision 2.

svn commit [PATH...]

Envía los cambios realizados en nuestra copia de trabajo hacia el repositorio.

Ejemplo:

$ svn commit -F msg foo.c

Sending        foo.c

Transmitting file data .

Committed revision 5.

svn copy SRC DST

Copia un archivo en una copia de trabajo o en el repositorio.

Ejemplo:

$ svn copy foo.txt bar.txt

A         bar.txt

$ svn status

A  +   bar.txt

svn update [PATH...]

Nos trae los cambios que hay en el repositorio hacia nuestra copia de trabajo actual.

Ejemplo:

$ svn update

A  newdir/toggle.c

A  newdir/disclose.c

A  newdir/launch.c

D  newdir/README

Updated to revision 32.

svn import [PATH] URL

Realiza un commit recursivo de lo que hay en path hacia URL.

Ejemplo:

$ svn import -m “New import” myproj \

http://svn.red-bean.com/repos/test/trunk/misc/myproj

Adding         myproj/sample.txt

…

Transmitting file data ………

Committed revision 19.

svnadmin

svnadmin create REPOS_PATH

Crea un repositorio nuevo y vacio en el path escrito.

Ejemplo:

$ svnadmin create /usr/local/svn/repos

svnadmin recover REPOS_PATH

Este comando debe de ser ejecutado cuando obtenemos un error de que nuestro repositorio debe de ser recuperado.

Ejemplo:

$ svnadmin recover /usr/local/svn/repos

svn: Failed to get exclusive repository access; perhaps another process

such as httpd, svnserve or svn has it open?

$

svnadmin load REPOS_PATH

Lee un “dumpfile” el cual es un stream con formato proveniente de stdin, realiza commit al repositorio del sistema de las nuevas revisiones existentes. Envia el progreso hacia stdout.

Ejemplo:

$ svnadmin load –parent-dir new/subdir/for/project /usr/local/svn/restored < repos-backup

<<< Started new txn, based on original revision 1

* adding path : test … done.

* adding path : test/a … done.

svnadmin dump REPOS_PATH [-r LOWER[:UPPER]] [--incremental]

Envia el contenido de un repositorio del sistema hacia un archivo “dumpfile”.

Ejemplo:

$ svnadmin dump /usr/local/svn/repos -r 21 –incremental

* Dumped revision 21.

SVN-fs-dump-format-version: 1

Revision-number: 21

Prop-content-length: 101

Content-length: 101

Hudson

Es una herramienta de integración continua escrita en código Java, la cual corre en un contenedor de servlets, como por ejemplo Apache Tomcat o el servidor de aplicaciones GlassFish. Soporta las herramientas de SCM como CVS, Subversion, Git y Clearcase, y puede ejecutar proyectos basados en Apache Ant y Apache Maven, como también scripts de Shell y comandos batch de Windows.

Durante los últimos años Hudson se a convertido en una alternativa muy popular para algunos servidores open source.

Hudson es un proyecto open source, y su desarrollador principal es Kohsuke Kawaguchi quien trabaja para Sun Microsystems.

Trac

Trac es un sistema web libre para la gestion de proyectos y seguimiento de errores. Está inspirado en CVSTrac, y su nombre original era svntrac, debido a su fuerte dependencia de Subversion. Está desarrollado y mantenido por Edgewall Software.

Trac está escrito en Python. Hasta mediados de 2005 estaba disponible bajo GNU General Public License, pero desde su versión 0.9, se distribuye de acuerdo a una modificación de la licencia BSD.

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. Antes de la verión 0.11 el front-end web de Trac estaba soportado por ClearSilver. A partir de la versión 0.11 comenzó a utilizar un sistema de plantillas web propio llamado Genshi, aunque la compatibilidad con plugins basados en ClearSilver se mantendrá a lo largo de varias versiones más.

Alternativas a Trac

RapidSVN

Es un cliente gráfico que nos permite manipular nuestros repositorios de Subversion. Además es una de las alternativas más conocidas para los sistemas GNU/Linux, muy intuitivo y fácil de utilizar. Es un cliente gráfico para Subversion, un programa de control de versiones sustituto de CVS.

TortoiseSVN

Es un cliente para Subversion implementado de forma muy práctica: integrado en Windows. Es intuitivo y fácil de usar, y te proporciona un acceso más rápido y visual a todas las funciones de Subversion.

Utilizar o no utilizar Hudson y trac??

Bueno en mi opinión estas dos herramientas son de gran ayuda a la hora de estar realizando proyectos de software. Nos ayudan a tener control sobre las versiones que vamos desarrollando. Estas herramientas nos permiten tener una perspectiva más clara de que es lo que estamos haciendo con cierta porción de código y porque lo estamos haciendo.

APACHE Y SUBVERSION

Para instalar debemos ejecutar el siguiente comando:

# apt-get install apache2

# apt-get install libapache2-mod-python

Ahora procederemos a instalar subversion

# apt-get install subversion libapache2-svn

El siguiente paso es reiniciar el servicio “apache2”, por lo que ejecutamos:

# /etc/init.d/apache2 restart

PASOS PARA CONFIGURAR SUBVERSION

Para configurar subversión debemos de seguir los siguientes pasos:

# cd /var

# mkdir svn-repos

# svnadmin create /var/svn-repos/practica1

# svn mkdir practica1/{branches,tags,trunk}

Con lo anterior creamos un repositorio, ahora debemos crear un grupo y un usuario y luego le damos permisos al repositorio y posteriormente creamos una contraseña para el repositorio:

# groupadd subversion

# addgroup sergio subversión

# chown -R www-data:subversion /var/svn-repos /*

# chmod -R 770 /var/svn-repos /*

# htpasswd -c /etc/apache2/dav_svn.passwd sergio

Ahora abrimos el archivo “dav_svn.conf”

# gedit /etc/apache2/mods-available/dav_svn.conf

Y le agregamos las siguientes líneas al final

<Location /svn/repositorio>

DAV svn

SVNPath /var/svn-repos/prueba1

AuthType Basic

AuthName “Mi Repositorio”

AuthUserFile /etc/apache2/dav_svn.passwd

Require valid-user

</Location>

Y volvemos a reiniciar el servicio “apache2”:

# /etc/init.d/apache2 restart

Para ver lo que hemos hecho hasta el momento abrimos un explorador de Internet y vamos a la siguiente ubicación:

http://localhost/svn/repositorio/

A continuación  se muestra un screenshot con la página:

Para darle una apariencia diferente a nuestra página de subversión, debemos descargar un estilo css. Yo descargue el archivo repos-style-2.0.zip de la página http://www.reposstyle.com/

Descomprimimos este archivo a la carpeta /var/www

Ahora volvemos a abrir el archivo “dav_svn.conf”

# gedit /etc/apache2/mods-available/dav_svn.conf

Y le agregamos la siguiente línea:

SVNIndexXSLT /repos-web/view/repos.xsl

Por lo que el archivo deberá de quedar así:

<Location /svn/repositorio>

DAV svn

SVNPath /var/svn-repos/prueba1

SVNIndexXSLT /repos-web/view/repos.xsl

AuthType Basic

AuthName “Mi Repositorio”

AuthUserFile /etc/apache2/dav_svn.passwd

Require valid-user

</Location>

Y volvemos a reiniciar el servicio “apache2”:

# /etc/init.d/apache2 restart

Para ver lo nueva apariencia vamos otra vez a:

http://localhost/svn/repositorio/

INTEGRACION DE NETBEANS CON SUBVERSIÓN

Si no tenemos instalado netbeans podemos ir al gestor de paquetes Synaptic e instalarlo desde allí.

Una vez que lo tengamos instalado creamos un proyecto cualquiera, luego le damos click derecho sobre el proyecto y luego le damos click a “Versioning”, luego “Import into Subversion Repository”.

Luego se abrirá una ventana en donde debemos ingresar la dirección URL de nuestro repositorio, asi como el usuario y contraseña creados en la configuración de subversión:

Después ingresamos el nombre del folder del repositorio y le posteriormente le damos click a “Finish”

Ahora netbeans y subversión estarán integrados, a continuación se muestra un screenshot:

INSTALACIÓN Y CONFIGURACIÓN DE TRAC

Abrimos el archivo “sources.list”:

# gedit /etc/apt/sources.list

Y le agregamos la siguiente línea al final:

deb http://ftp.edgewall.com/pub/debian sarge trac

Ahora ejecutamos los siguientes commando:

# apt-get update

# apt-get install trac

Creamos un nuevo directorio

mkdir /trac

y ahora creamos un nuevo ambiente:

trac-admin /trac/practica1 initenv

Despues de ejecutar nos pedirá un nombre, ingresamos el que queramos, luego nos pedirá otras opciones a las cuales les damos simplemente enter para que quede la opción default. Luego nos pedirá el path de nuestro repositorio, por lo que ingresamos:

/var/svn-repos/prueba1

Si hacemos bien todo lo anterior deberemos ver el siguiente mensaje:

Ahora abrimos el archivo “default”:

# gedit /etc/apache2/sites-available/default

Y agregamos lo siguiente antes de la etiqueta </VirtualHost>:

<Location /trac>

SetHandler mod_python

PythonInterpreter main_interpreter

PythonHandler trac.web.modpython_frontend

PythonOption TracEnvParentDir /trac

PythonOption TracUriRoot /trac

</Location>

Luego cambiamos los permisos de la recién creada:

# chown -R www-data.www-data /trac/practica1

Ahora abrimos la siguiente direccion:

http://localhost/trac

Ahora se muestra una pantalla con la página de Trac del proyecto:

Abajo se muestra un screenshot con el código del proyecto:

INSTALACIÓN DE HUDSON

Para instalar Hudson debemos descargar el archivo:

Hudson.war

Lo podemos descargar de

https://hudson.dev.java.net/

Ahora instalamos tomcat:

# apt-get install tomcat6 tomcat6-admin

Luego copiamos el archivo .war a /var/lib/tomcat6/webapps

# cp Hudson.war /var/lib/tomcat6/webapps

Ahora debemos abrir el archive “tomcat-users.xml”:

# gedit /var/lib/tomcat6/conf/tomcat-users.xml

Y agregamos las siguientes lineas antes de “</tomcat-users>”:

<role rolename="manager"/>
<role rolename="admin"/>
<user username="root" password="root" roles="manager"/>
<user username="root2" password="root2" roles="admin"/>

Ahora reiniciamos el servicio de tomcat:

# /etc/init.d/tomcat6 restart

Ahora creamos un directorio para hudson

# mkdir /home/Hudson

Le damos permisos al directorio:

# chmod 777 /home/hudson

Ahora abrimos el archivo “tomcat6”:

# gedit /etc/init.d/tomcat6

Buscamos la variable JAVA_OPTS y le agregamos al final lo siguiente:

-DHUDSON_HOME=/home/hudson

Buscamos la variabla TOMCAT6_SECURITY y cambios su valor a no.

“TOMCAT6_SECURITY=no”

Luego vamos a:

http://localhost:8080/manager/html

Nos pedirá un usuario y contraseña, por lo que tenemos que ingresar los creados en el archivo “tomcat-users.xml”

Se abrirá una página así:

ENLACE DE HUDSON Y TRAC

Debemos de descargar el archivo:

trac.hpi

Lo podemos descargar de

https://hudson.dev.java.net/

Ahora ingresamos a:

http://localhost:8080/hudson/

Luego le damos click al link que dice “Manage Hudson” y se deberá de abrir una página como la siguiente:

Ahora le damos click al link que dice “Manage Plugins”

Luego le damos click a la solapa de “Advanced” y se abrirá una ventana en donde tenemos que subir el archivo que descargamos anteriormente:

Ahora vamos a:

http://localhost:8080/manager/html

Volvemos a ingresar el usuario y la contraseña

Nos vamos a donde dice Hudson y le damos click a “Recargar”

Luego nos aparecerá en la parte de arriba de la pagina un mensaje que nos indica que Hudson se recargo exitosamente:

Ahora Hudson ya estará enlazado con Trac.

PROYECTOS EN HUDSON

Para crear un proyecto en Hudson vamos a:

http://localhost:8080/hudson/

y le damos click al link que dice “New Job”, aparecerá una página en donde debemos poner el nombre del trabajo y su tipo:

Luego ingresamos el nombre del proyeto.

En trac website ponemos:

http://localhost/trac

Luego escogemos la opción de subversión.

Y en repository URL ponemos:

http://localhost/svn/practica1

El error que vemos es porque no hemos autenticado a ningun usuario, por lo que le damos clisk a “enter credential”, nos pedirá el usuario y la contraseña del usuario creado en subversión:

Finalmente le damos click a “ok”.

Si hemos hecho todo bien, veremos una página así:

UUID DE MI DISCO DURO:

Para ver el UUID de el disco duro hay que ejecutar el siguiente comando:

# vol_id /dev/nuestro_disco_duro