La Integración Continua es una metodología propuesta inicialmente por Martin Fowler consistente en la realización de continuas integraciones automáticas de un proyecto, de forma que sea posible detectar fallos tan rápido como sea posible.

Con Apache Continuum tendremos un sitio centralizado para la construcción de nuestros proyectos, así como para la gestión de las releases que vayamos generando.

Asimismo, seguiremos ampliando la infraestructura que hemos ido creando con Apache Archiva y Sonar.

Instalación

En primer lugar debemos descargarnos el paquete que queremos instalar. Para ello, vamos a la página de descargas y nos descargamos el archivo “apache-continuum-1.3.6.war”.

Creamos los directorios necesarios para Continuum dentro de Tomcat6 y copiamos el archivo .war:

icesoft> sudo su -
root> mkdir /var/lib/tomcat6/continuum
root> cd /var/lib/tomcat6/continuum
root> cp ~icesoft/Descargas/apache-continuum-1.3.6.war  .
root> mkdir -p data/{work,build,release,deploy}
root> mkdir repository
root> chown tomcat6:tomcat6 -R data repository
root> cd ~tomcat6/.m2
root> ln -s /var/lib/tomcat6/continuum/repository
root> chown tomcat6:tomcat6 -R repository

Con esto, hemos creado los directorios de trabajo para Continuum en el directorio base (/var/lib/tomcat6/continuum), hemos creado un directorio donde Continuum almacenará el repositorio Maven que utilizará durante las compilaciones y, por último, hemos enlazado a dicho directorio desde el directorio base de Maven para el usuario tomcat6 (directorio ~tomcat6/.m2).

Configuración

La configuración es prácticamente idéntica a la de Apache Archiva, por lo que seguiremos los mismos pasos.

Configuración de la base de datos

Creamos una base de datos en MySQL llamada “continuum” y creamos un usuario con privilegios sobre la misma:

mysql> create database continuum;
mysql> grant all privileges on continuum.* to continuum identified by 'continuump4ss';
mysql> flush privileges;

Configuración de Tomcat6

Debemos disponer un archivo de contexto para Continuum dentro de Tomcat6, para lo cual, creamos el archivo “/var/lib/tomcat6/conf/Catalina/localhost/continuum.xml” con el siguiente contenido:

<?xml version="1.0" encoding="UTF-8"?>
<Context path="/continuum"
    docBase="${catalina.base}/continuum/apache-continuum-1.3.6.war">

<Resource name="jdbc/users" auth="Container" type="javax.sql.DataSource"
    username="continuum"
    password="continuump4ss"
    driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/continuum?autoReconnect=true" />

<Resource name="jdbc/continuum" auth="Container" type="javax.sql.DataSource"
    username="continuum"
    password="continuump4ss"
    driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/continuum?autoReconnect=true" />

<Resource name="mail/Session" auth="Container"
    type="javax.mail.Session"
    mail.smtp.host="localhost"/>

</Context>

Además, aprovechamos que, en la instalación de Archiva, habíamos incluido las propiedades appserver.home y appserver.base en el archivo catalina.properties de Tomcat6.

Con esto, ya podríamos reiniciar Tomcat, aunque antes, debemos crear un archivo de configuración de Continuum en el directorio de configuración de Tomcat6 y poner al usuario tomcat6 como su propietario:

root> cd /var/lib/tomcat6/conf
root> cat <<- _EOF_ > continuum.conf
<?xml version="1.0" encoding="UTF-8"?>
<continuum-configuration />
_EOF_
root> chown tomcat6:tomcat6 continuum.conf

De esta forma, cuando salvemos la configuración de Continuum desde la web, ésta se almacenará en este archivo. También podríamos establecer directamente la configuración que queremos según los directorios que hemos creado previamente, dejando el archivo de este modo:

<?xml version="1.0" encoding="UTF-8"?>
<continuum-configuration>
  <baseUrl>http://localhost:8080/continuum</baseUrl>
  <buildOutputDirectory>/var/lib/tomcat6/continuum/build</buildOutputDirectory>
  <deploymentRepositoryDirectory>/var/lib/tomcat6/continuum/deploy</deploymentRepositoryDirectory>
  <workingDirectory>/var/lib/tomcat6/continuum/work</workingDirectory>
  <releaseOutputDirectory>/var/lib/tomcat6/continuum/release</releaseOutputDirectory>
</continuum-configuration>

Reinicio de Tomcat6

Una vez hecha la configuración, reiniciamos Tomcat6:

sudo /etc/init.d/tomcat6 restart

Y accedemos a la página principal de Continuum (http://hostname:puerto/continuum). En nuestro caso, http://localhost:8080/continuum.

Al acceder a esta página, al igual que nos pasó con Archiva, se generan las tablas en base de datos y se nos pide la creación de un usuario administrador:

Apache Continuum - Create Admin User

Una vez creado el usuario, nos aparecerá la página de configuración:

Apache Continuum - General Configuration

Llegados a este punto, ya podemos iniciar nuestro camino con la integración continua y desplegar nuestros proyectos Maven2 con Continuum, aunque primero es necesario añadir nuestras “instalaciones”.

Creación de Instalaciones

Una vez logados, pulsamos sobre “Installations”; a continuación, sobre el botón “Add” y estando seleccionado “Tool” como Installation Type, pulsamos de nuevo sobre el botón “Add”.

Apache Continuum - Installation

Debemos asegurarnos de seleccionar el check de “Create a Build Environment with the Installation name”. De este modo, tendremos un entorno de construcción basado en esta instalación.

Además de las versiones de Java disponibles, debemos indicar dónde tenemos Maven2 y Ant instalados. Lo más sencillo, es descargarnos el .tar.gz de las páginas de descarga de cada uno de ellos y descomprimirlo en un directorio, por ejemplo, /opt.

Habiendo instalado Maven2 y Ant, dejaríamos las instalaciones de este modo:

Apache Continuum - Installations

Y pulsando sobre el enlace “Build Environments”, vemos cómo han quedado nuestros entornos de construcción:

Apache Continuum - Build Environments

En el siguiente post, veremos cómo utilizar Apache Continuum en nuestros proyectos.

Sonar es una herramienta open source que nos permite comprobar la calidad de nuestro código. Como en su propia página indican, cubre 7 ejes principales:

7 ejes

Además, cuenta con múltiples plugins.

Instalación

Sonar, al igual que Apache Archiva y Apache Continuum (ya lo veremos más adelante), puede utilizarse independientemente así como incluido en un contenedor de aplicaciones. Asimismo, puede utilizar una base de datos Derby u otra según le indiquemos.

Nuestra instalación la realizaremos sobre un contenedor de aplicaciones y utilizando MySQL como gestor de base de datos.

Creación de la base de datos

El siguiente paso es la creación de la base de datos en MySQL:

mysql -u root -p
mysql> create database sonar;
mysql> grant all privileges on sonar.* to sonar identified by 'sonarp4ss';
mysql> exit;

Descarga y descompresión del software

Nos bajaremos el software a partir de esta dirección. En nuestro caso, hemos descargado el archivo sonar-2.2.zip.

A continuación descomprimiremos el software. Hay que tener en cuenta que Sonar almacena la ruta física a partir de la cual hemos generado el archivo war, por lo que esta ruta no se debe eliminar posteriormente (Sonar la utilizará para obtener los plugins que utilizaremos,…).

cd /srv
sudo mkdir -p webapps/wars
cd webapps
sudo unzip ~icesoft/Descargas/sonar-2.2.zip
sudo mv sonar-2.2 sonar

Generación del archivo .war

Es necesario, en este punto, modificar la configuración de Sonar antes de generar el archivo war. Para ello, editamos el archivo conf/sonar.properties y comentamos las líneas de configuración de base de datos Derby y descomentamos las de MySQL:

#sonar.jdbc.url:             jdbc:derby://localhost:1527/sonar;create=true
#sonar.jdbc.driverClassName: org.apache.derby.jdbc.ClientDriver
#sonar.jdbc.validationQuery: values(1)

sonar.jdbc.url:              jdbc:mysql://localhost:3306/sonar?useUnicode=true&characterEncoding=utf8
sonar.jdbc.driverClassName:  com.mysql.jdbc.Driver
sonar.jdbc.validationQuery:  select 1

También es necesario modificar la configuración del nombre de usuario y contraseña de acceso:

sonar.jdbc.username:         sonar
sonar.jdbc.password:         sonarp4ss

Por último, aunque no necesario, descomentamos la línea de JDBC datasource, por si quisiéramos configurar los parámetros de conexión de base de datos mediante JNDI:

sonar.jdbc.jndiName:         jdbc/sonar

Ahora, debemos generar el archivo war a desplegar en Tomcat:

cd /srv/webapps/sonar/war
sudo ./build-war.sh
sudo cp sonar.war /srv/webapps/wars/sonar-2.2.war
cd /srv
chown -R tomcat6:tomcat6 webapps

Configuración en Tomcat6

Únicamente queda disponer el archivo de la aplicación para que Tomcat arranque Sonar, por lo que debemos disponer el siguiente archivo “sonar.xml” en el directorio /var/lib/tomcat6/conf/Catalina/localhost:

<?xml version="1.0" encoding="UTF-8"?>
<Context path="/sonar" docBase="${catalina.base}/wars/sonar-2.2.war">

<Resource name="jdbc/sonar" auth="Container" type="javax.sql.DataSource"
    username="sonar"
    password="sonarp4ss"
    driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/sonar?autoReconnect=true;useUnicode=true;characterEncoding=utf8" />

</Context>

Instalación de plugins

Como comentaba al principio, podemos instalar diversos plugins a Sonar. Para ello, dispondremos el archivo .jar correspondiente en el directorio “/srv/webapps/sonar/extensions/plugins”, rearrancaremos Tomcat y ya estarían disponibles.

Acceso a Sonar

Con estos pasos, ya podríamos acceder a la web de Sonar (http://hostname:8080/sonar), visualizando lo siguiente:

Sonar

Configuración de Maven

Por último, sólo nos queda configurar Maven para que apunte a la base de datos de Sonar cuando se ejecute el plugin de Maven de Sonar. Tendremos que añadir el siguiente profile a nuestro archivo ~/.m2/settings.xml:

        <profile>
            <id>sonar</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <sonar.jdbc.url>
                  jdbc:mysql://localhost:3306/sonar?useUnicode=true&amp;characterEncoding=utf8
                </sonar.jdbc.url>
                <sonar.jdbc.driver>com.mysql.jdbc.Driver</sonar.jdbc.driver>
                <sonar.jdbc.username>sonar</sonar.jdbc.username>
                <sonar.jdbc.password>sonarp4ss</sonar.jdbc.password>

                <sonar.host.url>http://hostname:8080</sonar.host.url>
            </properties>
        </profile>

Así, para ejecutar el plugin de Maven2, teclearíamos el siguiente comando:

mvn sonar:sonar

Si tenemos Maven3, sería así:

mvn sonar3:sonar

Configuración con MySQL

En primer lugar, debemos disponer de un sistema de base de datos MySQL ya instalado. Si no lo tenemos instalado, debemos ejecutar el siguiente comando:

$ sudo apt-get install mysql-server-5.1 mysql-client-5.1

A continuación, creamos una base de datos y un usuario exclusivos para Archiva:

$ mysql -u root -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 73
Server version: 5.1.41-3ubuntu12.3 (Ubuntu)

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> create database archiva;
Query OK, 1 row affected (0.07 sec)

mysql> use archiva;
Database changed

mysql> grant all privileges on archiva.* to archiva identified by 'archivapass';
Query OK, 0 rows affected (0.02 sec)

mysql> exit
Bye

Con este paso, tenemos una base de datos “archiva” y un usuario “archiva” con todos los permisos hacia la misma.

Por último, necesitamos indicar a Archiva que se conecte con esta nueva tabla, pero previamente debemos instalar el driver JDBC de MySQL:

$ sudo su -
# apt-get install libmysql-java
# cd /usr/share/tomcat6/lib
# ln -s ../../java/mysql-connector-java.jar

Editamos la configuración de Archiva en Tomcat6 (archivo “/var/lib/tomcat6/conf/Catalina/localhost/archiva.xml”), comentando las entradas correspondientes a la conexión de base de datos Derby e incluyendo la conexión a MySQL. El archivo quedaría como éste:

<?xml version="1.0" encoding="UTF-8"?>
<Context path="/archiva"
         docBase="${catalina.base}/archiva/apache-archiva-1.3.1.war">

<!--
<Resource name="jdbc/users" auth="Container" type="javax.sql.DataSource"
    username="sa"
    password=""
    driverClassName="org.apache.derby.jdbc.EmbeddedDriver"
    url="jdbc:derby:${catalina.base}/archiva/database/users;create=true" />

<Resource name="jdbc/archiva" auth="Container" type="javax.sql.DataSource"
    username="sa"
    password=""
    driverClassName="org.apache.derby.jdbc.EmbeddedDriver"
    url="jdbc:derby:${catalina.base}/archiva/database/archiva;create=true" />
-->

<Resource name="jdbc/users" auth="Container" type="javax.sql.DataSource"
    username="archiva"
    password="archivapass"
    driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/archiva?autoReconnect=true" />

<Resource name="jdbc/archiva" auth="Container" type="javax.sql.DataSource"
    username="archiva"
    password="archivapass"
    driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/archiva?autoReconnect=true" />

<Resource name="mail/Session" auth="Container"
    type="javax.mail.Session"
    mail.smtp.host="localhost"/>

</Context>

Para terminar la instalación, debemos crear el directorio .m2 en el directorio del usuario tomcat6, de forma que Archiva la procese (y para que también podamos editarla desde la página de administración Archiva):

$ sudo mkdir ~tomcat6/.m2
$ sudo chown tomcat6:tomcat6 -R ~tomcat6/.m2

Ahora podemos reiniciar Tomcat y utilizar Apache Archiva como nuestro servidor de repositorio.

Conexión a Apache Archiva – Creación de usuario administrador

La primera vez que nos conectamos a Apache Archiva, éste genera las tablas necesarias en la base de datos y nos solicita la creación del usuario administrador:

Apache Archiva - Create Admin User

Una vez creado el usuario, nos aparecerá la página de búsqueda:

Apache Archiva: Search

Configuración de Repositorios

Una vez finalizada la instalación y configuración “base”, debemos incluir algunos repositorios de Maven 2 para que Archiva actúe de “proxy” hacia ellos, de forma que nosotros nos conectemos únicamente a Archiva y sea éste el que se encargue de descargar los archivos que necesitemos de los repositorios externos.

Para ello, desde la página de búsqueda, vista anteriormente, pulsaremos sobre el botón de “Repositories”. Aquí nos aparecerán los repositorios manejados (“Managed Repositories”) por defecto:

• Archiva Managed Internal Repository.
• Archiva Managed Snapshot Repository.

y dos repositorios remotos:

• Central Repository.
• Java.net Repository for Maven 2.

Lo primero que debemos hacer es modificar la configuración de los directorios dos repositorios manejados, de forma que los directorios estén bajo “/var/lib/tomcat6/archiva/repositories”. Para ello, sobre cada uno, pulsamos en el botón “Edit” y modificamos el parámetro:

Apache Archiva: Admin: Edit Managed Repository

Una vez actualizados, pulsaremos sobre el botón “Add” en el apartado de “Remote Repositories”, añadiendo nuevos repositorios remotos:

Apache Archiva: Admin: Add Remote Repository

Y así, añadimos los siguientes repositorios:

• Codehaus: http://repository.codehaus.org/.
• JBoss: http://repository.jboss.org/maven2/. Actualización (02/08/2010): JBoss ha dispuesto otro repositorio: http://repository.jboss.org/nexus/content/groups/public/.
• IBiblio: http://mirrors.ibiblio.org/pub/mirrors/maven2/.
• Spring: http://s3.amazonaws.com/maven.springframework.org/release.

quedando del siguiente modo:

Apache Archiva: Administration - Repositories

Configuración de conexiones de los repositorios

Una vez que hemos añadido los repositorios remotos, hemos de indicar para qué paquetes Java utilizaremos cada uno de estos repositorios. Pulsamos sobre el enlace “Proxy Connectors” y a continuación sobre el botón “Add”. Éste es el ejemplo para añadir el repositorio de Codehaus:

Apache Archiva: Admin: Add Proxy Connector

Nótese que hemos indicado el paquete “org/codehaus/**” en la “White List”, es decir, estamos indicando que se utilizará este repositorio remoto únicamente para descargar “artefactos” / librerías que cumplan este formato (cuyo groupId sea éste o esté compuesto por éste).

La configuración completa de todos los repositorios remotos, así como edición del repositorio “Java.net Repository for Maven 2″ para añadirle en la “White List” el paquete “javolution/**” es ésta:

Apache Archiva: Administration - Proxy Connectors

Configuración de Maven2 para conexión con Archiva

Una vez que tenemos Apache Archiva funcionando, podemos configurar Maven2 para que lo utilice como repositorio de todos los paquetes necesarios en nuestros desarrollos, para lo cual, editamos nuestro archivo de configuración de Maven2 situado en nuestro directorio “.m2″ de nuestro usuario, dejándolo de este modo:

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<!--
    <localRepository/>
    <interactiveMode>true</interactiveMode>
    <usePluginRegistry/>
    <offline>false</offline>
    <pluginGroups/>
    <servers/>
-->
    <mirrors>
        <mirror>
            <id>internal</id>
            <name>Archiva Managed Internal Repository</name>
            <url>http://hostname:8080/archiva/repository/internal</url>
            <mirrorOf>*</mirrorOf>
        </mirror>
    </mirrors>
<!--
    <proxies/>
    <profiles/>
    <activeProfiles/>
-->
</settings>

* Este archivo se muestra a modo de ejemplo ya que, en realidad, únicamente hace falta añadir la parte relativa a “mirror”; el resto, debe configurarse en función de las necesidades de cada usuario.
** Se debe sustituir la palabra “hostname” por el nombre o IP del servidor real de Apache Archiva.

Esto nos permite disponer en un único sitio de todas las dependencias en nuestros proyectos. Por ejemplo, en un proyecto en el que participé, necesitábamos 2 jar de Oracle WebLogic Server. Para ello, cada uno de nosotros tuvimos que instalarlos vía Maven en nuestros respectivos equipos. Sin embargo, si hubiéramos tenido un repositorio Archiva disponible, podríamos haber instalado los jar en este repositorio y, con esto, serían accesibles desde nuestros equipos a la hora de desarrollar.

Instalación

En primer lugar, debemos descargarnos Apache Archiva, para ello, iremos a la página de descarga. En este punto, dependiendo de nuestras necesidades, podríamos descargarnos:

• Si vamos a ejecutar Archiva de forma independiente, nos descargaremos los paquetes .tar.gz (para Unix/Linux) o .zip (para Windows).
• Si por el contrario, vamos a ejecutar Archiva bajo un contenedor de aplicaciones, nos descargaremos el paquete .war.

Archiva de forma independiente

Ésta es la forma más rápida para disponer de esta herramienta. Para instalarlo ejecutaríamos los siguientes pasos:

1. Descomprimir el paquete:

   $ tar xzf apache-archiva-1.3.1-bin.tar.gz

2. Arrancar Archiva:

   $ cd apache-archiva-1.3.1/bin
   $ ./archiva start
   

Con estos simples pasos, ya tendríamos arrancada una instancia de Apache Archiva en el puerto 8080 utilizando un contenedor Jetty.

Archiva bajo Tomcat6

A partir de aquí, explicaré cómo configurar Apache Archiva en un Tomcat 6.0 en un servidor Ubuntu. Estos puntos serán iguales o muy parecidos en otras distribuciones GNU/Linux.

Suponemos que tenemos ya instalado un servidor Tomcat6, si no, lo instalamos:

$ sudo apt-get install tomcat6

Creamos la estructura de directorios de Apache Archiva dentro de Tomcat:

$ sudo su -
# cd /var/lib/tomcat6
# mkdir archiva
# cd archiva
# cp ~icesoft/Descargas/apache-archiva-1.3.1.war .
# mkdir database
# mkdir repositories
# chown tomcat6:tomcat6 database repositories

Modificamos el archivo de configuración de Tomcat para incluir unas propiedades necesarias para Archiva:

cd /var/lib/tomcat6/conf

cat <<- _EOF_ >> catalina.properties
# Archiva
appserver.home=\${catalina.home}
appserver.base=\${catalina.base}
_EOF_

Creamos el archivo de configuración de la instancia de Archiva en Tomcat, para ello, creamos el archivo

/var/lib/tomcat6/conf/Catalina/localhost/archiva.xml

con el siguiente contenido:

<?xml version="1.0" encoding="UTF-8"?>
<Context path="/archiva"
         docBase="${catalina.base}/archiva/apache-archiva-1.3.1.war">

<Resource name="jdbc/users" auth="Container" type="javax.sql.DataSource"
    username="sa"
    password=""
    driverClassName="org.apache.derby.jdbc.EmbeddedDriver"
    url="jdbc:derby:${catalina.base}/archiva/database/users;create=true" />

<Resource name="jdbc/archiva" auth="Container" type="javax.sql.DataSource"
    username="sa"
    password=""
    driverClassName="org.apache.derby.jdbc.EmbeddedDriver"
    url="jdbc:derby:${catalina.base}/archiva/database/archiva;create=true" />

<Resource name="mail/Session" auth="Container"
    type="javax.mail.Session"
    mail.smtp.host="localhost"/>

</Context>

Por último, es necesario enlazar las librerías Java que necesita Apache Archiva.

# apt-get install sun-javadb-core
# cd /usr/share/tomcat6/lib
# ln -s ../../java/activation.jar
# ln -s ../../java/derby.jar
# ln -s ../../java/gnumail.jar
# ln -s ../../java/gnumail-providers.jar

Con todos estos pasos, ya podemos arrancar Tomcat

$ sudo /etc/init.d/tomcat6 start

y acceder a Apache Archiva: http://<hostname>:8080/archiva.

Con esta configuración, Archiva utilizará una base de datos JavaDB (Derby). En la siguiente entrada, pondré cómo configurar Archiva para que utilice MySQL como gestor de base de datos.

Entendemos como control de versiones a la gestión de las distintas versiones (o revisiones) de los componentes que mantenemos de un determinado proyecto / producto u otro tipo de elemento susceptible de versionado.

Puede verse una definición más completa en Control de versiones.

Software

Para dar soporte al control de versiones hay disponibles múltiples herramientas, tanto comerciales, como de libre distribución, como:

• Comerciales:
  • Microsoft Visual SourceSafe.
  • PVCS Version Manager.
• Gratuitas (GPL y/o Open Source):
  • CVS.
  • Subversion.

De estas herramientas, utilizaré Subversion, por ser open source y disponer de mejores características que CVS.

Instalación

En primer lugar, instalamos la aplicación:

apt-get install subversion

Para otros sistemas operativos, será necesario descargar los clientes desde la página principal de Subversion.

Una vez instalada, creamos el grupo y el usuario sobre los que correrá el servicio:

groupadd svn
adduser -c "SVN Owner" --home /srv/svn --ingroup svn --firstuid 100 --lastuid 200 \
--disabled-login --shell /bin/false svn

Configuración

Ahora generamos el repositorio:

install -v -m 0755 -o svn -g svn -d /srv/svn/repositories
svnadmin create --fs-type fsfs /srv/svn/repositories
chown -R svn:svn /srv/svn/repositories

Con el repositorio creado, el siguiente paso es la configuración de Subversion como demonio, creando el archivo /etc/init.d/svnserve:

#!/bin/sh
# start/stop svn (Subversion) server

set -e
NAME=svnserve
DESC="Subversion server"
DAEMON=/usr/bin/$NAME
PARAMS="-d -T -r /srv/svn/repositories"
DAEMONUSER=svn
test -x $DAEMON || exit 0
. /lib/lsb/init-functions

start_it_up()
{
log_daemon_msg "Starting $DESC" "$NAME"
start-stop-daemon --start --quiet --chuid $DAEMONUSER:$DAEMONUSER \
--exec $DAEMON -- $PARAMS
log_end_msg $?
}

shut_it_down()
{
log_daemon_msg "Stopping $DESC" "$NAME"
start-stop-daemon --stop --retry 60 --quiet --oknodo --exec $DAEMON
log_end_msg $?
}

case "$1" in
start)
start_it_up
;;
stop)
shut_it_down
;;
restart)
shut_it_down
start_it_up
;;
*)
echo "Usage: /etc/init.d/$NAME {start|stop|restart}" >&2
exit 1
;;
esac

exit 0

Ahora sólo queda crear los enlaces simbólicos necesarios en la estructura /etc/rcx.d para que el servicio se arranque y se pare automáticamente al arrancar y parar el servidor. Para ello se ejecutará el siguiente comando:

update-rc.d svnserve defaults

A continuación configuramos el servicio (usuarios):

cat < /srv/svn/repositories/conf/passwd
[users]
root = root
iCesofT = bar
_EOF_

cat < /srv/svn/repositories/conf/svnserve.conf
[general]
anon-access = none
auth-access = write

password-db = passwd

realm = Subversion Repository
_EOF_

chmod 770 /srv/svn/repositories

(Cambiar las contraseñas a las contraseñas deseadas)

Creación de un proyecto

Ahora podemos importar un proyecto de ejemplo, para lo cual, primero creamos la estructura base:

cd /tmp
mkdir -p project/{branch,tags,trunk}
cd project/trunk
mkdir dir{1,2,3}

Ahora importamos dicha estructura:

cd /tmp
svn import project svn://host/project -m "Initial release"

Y, para comenzar a trabajar sobre este proyecto, hacemos check-out:

cd
mkdir scm
cd scm
svn checkout svn://host/project/trunk project