igayoso’s life

Configuración y primeros pasos con subversion (svn)

Primer manual grande que posteo, voy a intentar ponerlos aquí directamente, pero creo que cuando tenga ganas los iré subiendo a algún sitio en PDF, pero si alguien le corre prisa que me lo pida y se lo mandaré sin problema

Configuración servidor subversion

Instalamos el subversion, en este ejemplo ya tenemos el apache2 instalado y configurado, así que le meteremos únicamente el paquete de de svn:

# apt-get install subversion subversion-tools libapache2-svn

Ahora reiniciamos el servidor de apache2 para que cargue los módulos de svn y dav:

# /etc/init.d/apache2 restart

Ahora configuramos un sitio nuevo en apache2.

Abrimos el fichero de configuración del módulo de apache2 de svn:

# vim /etc/apache2/mods-enabled/dav_svn.conf

Y lo dejamos algo así como:

DAV svn

SVNPath /var/lib/svn

AuthType Basic
AuthName “Subversion Repository”
AuthUserFile /etc/apache2/dav_svn.passwd
Require valid-user

AuthzSVNAccessFile /etc/apache2/dav_svn.authz

SVNPath -> Contendrá la ruta donde hemos configura el sitio para svn
AuthType -> Autentificación básica de apache2
AuthName -> El nombre que saldrá a la hora de autentificarse
AuthUserFile -> El fichero que contiene los usuarios y contraseñas de apache2 para autentificarse
Require valid-user -> Para entrar a este sitio, se pone esta directiva para que requiera autentificación
AuthzSVNAccessFile -> Para que una vez autentificado (o no), podramos controlar lo que puede hacer cada usuario

Creamos el sitio de svn en nuestra máquina. Deberemos crearlo donde hemos especificado anteriormente en la configuración de svn en apache2, en la directiva SVNPath:

# svnadmin create /var/lib/svn

Ahora creamos la contraseña de apache2 para un usuario en concreto, en la ruta que hemos especificado antes mediante la directiva AuthUserFile:

# htpasswd -mc /etc/apache2/dav_svn.passwd sistemas

Con el flag m forzamos la encriptación en MD5 y con el flag c creamos un fichero nuevo. Si quisiéramos modificar (añadir, cambiar, eliminar…) quitaríamos el flag c para que lo hiciera con un fichero ya creado.

Modificamos el fichero de autentificación de svn, para tener un control sobre cada usuario. Dependiendo de cada usuario, grupo o todos especificaremos unos permisos. También podríamos controlarlo por carpetas. Editamos el fichero que hemos especificado anteriormente mediante la directiva AuthzSVNAccessFile:

# vim /etc/apache2/dav_svn.authz

Y lo dejamos así para que el usuario que hemos creado antes pueda leer y escribir. También hemos configurado que todos los usuarios puedan leer:

[/]
* = r
sistemas = rw

Si quisiéramos hacer grupos, los podríamos especificar de la siguiente manera, dejando el fichero con algo parecido a esto:

[groups]
admin = sistemas, igayoso, idiego
[/]
admin = rw

Con este ejemplo, crearíamos un grupo llamado admin., que estarían los usuarios: sistemas, igayoso e idiego, que tendríamos que haber creado previamente. Este grupo tendría permisos de lectura y escritura y nadie más podría ni leer, ni escribir.

Reiniciamos apache2 de nuevo para que coja las últimas configuraciones que hemos metido:

# /etc/init.d/apache2 restart

Si ahora vamos a la máquina en cuestión y a la localización que hemos puesto, en este caso:

http://localhost/svn

Sigue leyendo….

Una vez que nos hayamos autentificado con los datos que hemos metido antes, deberíamos de ver lo que tenemos dentro del svn que hemos creado, que de momento es nada, por lo tanto vamos a crear un proyecto con sus respectivas carpetas. Para crear este proyecto vamos a crear la siguiente estructura para luego importarla a svn:

carreteras
trunk
tags
branches

carreteras -> es el nombre del proyecto, podríamos poner el que queramos, incluso ninguno y crear las otras carpetas únicamente, pero lo creamos de esta forma para tenerlo todo un poco mejor organizado
trunk –> es la última versión que hay, sea estable o inestable
tags -> cambios más comunes en módulos, librerías…
branches -> versiones estables que hemos ido haciendo con una o diferentes ramas

Por ejemplo, en este caso vamos a crear la estructura en /tmp para luego borrarla, ya que una vez que esté importada en svn no hará falta, ya que al importar cosas dentro de svn, lo pasa a formato Berkley Database (por defecto), así que no será necesario tenerlo, por lo tanto:

# mkdir /tmp/carreteras /tmp/carreteras/trunk /tmp/carreteras/branches /tmp/carreteras/tags

Y para ver que una vez importado lo podremos ver desde la WEB que hemos comprobado y configurado antes, crearemos un fichero:

# echo “Hello world” > /tmp/carreteras/trunk/index.html

Ahora vamos a importar todas las carpeta y ficheros a svn, esto se hace con el comando:

# svn import origen destino –m “Mensaje”

El origen es local, así que lo especificaremos como una ruta en Linux; el destino en este caso es local también, así que lo especificaremos con file:///ruta/donde/esta/svn; y por último con el flag m, especificaremos un mensaje que quedará guardado en el log de svn que podremos ver en un futuro:

# svn import /tmp/carreteras/ file:///var/lib/svn/carreteras -m “Primera importación de ficheros y carpetas” (1)

Puede que nos salga una ventana con el nano que nos informará de los cambio que se van a hacer a la hora de hacer el commit, como en este caso no hemos hecho ningún cambio y únicamente vamos a importar unos ficheros y carpetas saldrá vacío. Para salir del nano pulsar CTRL + x y luevo darle a la c para continuar y que haga la importación, debería salir una cosa como esta:

AÃ±adiendo /tmp/carreteras/trunk
AÃ±adiendo /tmp/carreteras/trunk/index.html
AÃ±adiendo /tmp/carreteras/branches
AÃ±adiendo /tmp/carreteras/tags

Commit de la revisiÃ³n 1.

Con esto pasamos a la revisión 1, ya que cada vez que importemos algo hará un commit por si hubiera algún conflicto del contenido, por que tendría que ser solucionado antes de importar algo. Ahora podremos ver que ha añadido las carpetas y el fichero, en la WEB de antes y que ha cambiado la revisión.

Como esta WEB es dav y por subversion, únicamente podremos ver el contenido y/o descargarlo, ya que no interpreta HTML o PHP, esto lo tendríamos que hacer a través de un cliente svn o con un script a la hora de hacer el commit, que veremos más adelante.

(1)Es posible que a la hora de importar carpetas o ficheros de un problema de permisos como este:

Execute: Import
Error: Error while performing action: Cant create directory /var/lib/svn/db/transactions/1-1.txt: Permission denied

Esto es porque hemos creado el svn como root, por lo tanto le vamos a dar permisos de propiedad a apache2, al usuario www-data, por lo tanto:

# chown –R www-data.www-data /var/lib/svn

Configuración y uso de un cliente subversion

Ahora vamos a configurar un cliente para poder trabajar con el servidor de subversion que hemos configurado antes. Primero instalamos los paquetes de subversion en el cliente:

# apt-get install subversion subversion-tools

Haremos un checkout, que lo que hacemos es descargarnos todo el proyecto a nuestra máquina local, nos situaremos en un directorio donde queramos guardar la copia local y haremos el checkout:

# cd /home/sistemas/proyectos
# svn checkout http://svn/svn

Al haber puesto autentificación en el svn, nos pedirá que nos autentiquemos, al hacerlo correctamente importará a local lo que haya en el svn, que nos saldrá algo así como:

Usuario: sistemas
Clave de ’sistemas’:
A svn/carreteras
A svn/carreteras/trunk
A svn/carreteras/trunk/index.html
A svn/carreteras/branches
A svn/carreteras/tags
RevisiÃ³n obtenida: 1

Ahora en el directorio donde hemos el checkout estará las carpetas y ficheros que hemos creado anteriormente. También veremos la revisión que hemos hecho el checkout, en este caso la revisión 1.

Añadir un fichero/carpeta

Ahora dentro de esta carpeta podremos hacer las modificaciones oportunas para luego hacer un commit, en este caso vamos a crear un fichero y llamarle style.css:

# touch /home/sistemas/proyectos/svn/carreteras/trunk/style.css

Como es un fichero nuevo, deberemos indicarle a svn que tenemos que añadirlo, ya que el solito no lo hace. Pasa lo mismo a la hora de eliminarlo o cambiarle el nombre/extensión (es lo mismo que crear y eliminar). Por lo tanto vamos a añadir el fichero de estilos:

# svn add /home/sistemas/proyectos/svn/carreteras/trunk/style.css

Y ahora hacemos el commit. Podemos hacer de directorio en concreto o de todo el árbol, todo depende de donde estemos situados, por ejemplo para hacer únicamente de la carpeta trunk nos situaremos en esa carpeta y haremos el commit (recordar que el flag m era para poner un mensaje y comentar que cambios ha habido en esta revisión):

# cd /home/sistemas/proyectos/svn/carreteras/trunk/
# svn commit –m “Hemos creado una hoja de estilos llamada style.css”

Y nos diría una cosa como esta:

AÃ±adiendo trunk/style.css
Transmitiendo contenido de archivos .
Commit de la revisiÃ³n 10.

Hay que hacerlo siempre en la carpeta en la que hemos hecho algún tipo de cambio. Este commit lo hará en sus subcarpetas, pero no en las anteriores, así que por ejemplo si hubiéremos estado en otra carpeta que no incluyera estos cambios no hubiera hecho nada.

Si quisiéramos hacer un simple cambio en un fichero bastaría con hacerlo y ejecutar un commit, abrimos el fichero, introducimos alguna línea y hacemos el commit:

# vim /home/sistemas/proyectos/svn/carreteras/trunk/style.css

Configuramos algún estilo dentro del fichero, en este caso únicamente he puesto un comentario:

#######################################
# Esto es la hoja de estilos
#######################################

Lo guardamos y hacemos el commit estando dentro de la carpeta donde está el fichero que hemos modificado o una anterior que lo incluya:

# cd /home/sistemas/proyectos/svn/carreteras/trunk/
# svn commit –m “Modificamos la hoja de estilos con un comentario”

Si todo ha salido bien saldría una cosa como esta:

Enviando trunk/style.css
Transmitiendo contenido de archivos .
Commit de la revisiÃ³n 11.

Como vemos ha aumentado la revisión en un número. Cada vez que hagamos algún tipo de cambio aumentará esta revisión. En cualquier momento podemos volver atrás a alguna de estas revisiones.

Eliminar fichero/carpeta

Ahora vamos a procedes a eliminar un archivo, en este caso la hoja de estilos. Como borrando y haciendo un commit no se podría, ya que no es una modificación en el contenido de algún fichero, debemos eliminar primero de hacer el commit, por lo tanto:

# svn rm /home/sistemas/proyectos/svn/carreteras/trunk/style.css
# svn status

Ahora podemos ver el estado de nuestra versión local, en este caso pone una D porque este fichero ha sido eliminado o creado y no forma parte de la revisión aún, por lo tanto debemos indicárselo a svn haciendo un commit:

# svn commit –m “Eliminamos la Hoja de estilos”

Y nos saldrá una cosa parecida a esto:

Eliminando trunk/style.css

Commit de la revisiÃ³n 12.

Como veis también ha aumentado la revisión.

Actualizar revisión local

Habrá veces que habrán hecho nuevas revisiones, pero nuestra revisión local no estará actualizada a la última versión, por lo tanto deberemos actualizarla con el siguiente comando:

# svn update

Y nos dirá la revisión actual y los cambios que se han hecho referentes a nuestra revisión local:

A loquesea.php
Actualizado a la revisiÃ³n 13.

La A significa add, es decir que ha sido añadido y por último nos dice la revisión que se ha descargado a local.

Guardar versiones de trunk a tags/branches

Una vez que hemos hecho los cambios oportunos en nuestra versión de trunk, vamos a hacer una versión para que quede como “estable” en las ramas (branches), también podríamos guardarlo en tags, ya que se hace del mismo modo. Por lo tanto vamos a crear la versión 0.0 de dicha WEB:

# svn copy http://svn/svn/carreteras/trunk http://svn/svn/carreteras/branches/0.0

De nuevo nos abrirá nano para mostrarnos los cambios que se irán a realizar, pulsamos CTR + x y luego la c para continuar, entonces hará un commit para comprobar si hay conflictos y hará la rama nueva.

Todo esto se haría de la misma forma, cambiando las rutas para futuras versiones o tags.

Solucionar conflictos entre ficheros/carpetas

Si se produce algún cambio a la vez o si intentas hacer un commit con una revisión vieja, habrá un conflicto que deberemos solucionar a mano. Por lo tanto imaginemos que alguien ha cambiado el fichero loquesea.php que está dentro de trunk. Yo pensaba que tenía la última versión, pero no es así, por lo tanto modifiqué el fichero e intenté hacer un commit con el siguiente resultado:

# echo “Hola, modificando fichero” >> /home/sistemas/proyectos/svn/carreteras/trunk/loquesea.php
# cd /home/sistemas/proyectos/svn/carreteras/trunk/
# svn commit –m “Modificando el fichero loquesea.php para probocar un conflicto”

Enviando trunk/loquesea.php
svn: FallÃ³ el commit (detalles a continuaciÃ³n):
svn: Su archivo o directorio ‘loquesea.php’ estÃ¡ probablemente desactualizado
svn: The version resource does not correspond to the resource within the transaction. Either the requested version resource is out of date (needs to be updated), or the requested version resource is newer than the transaction root (restart the commit).

Por lo tanto ahora deberemos actualizar nuestra versión local con:

# cd /home/sistemas/proyectos/svn/carreteras/trunk/
# svn update

Nos saldrá la actualización de la revisión y del fichero:

C loquesea.php
Actualizado a la revisiÃ³n 16.

Si hacemos un listado del directorio, veremos que ahora hay un montón de ficheros:

# ls –la /home/sistemas/proyectos/svn/carreteras/trunk/

total 36
drwxr-xr-x 4 root root 4096 2008-08-26 19:04 .
drwxr-xr-x 6 root root 4096 2008-08-26 18:52 ..
-rw-r–r– 1 root root 3297 2008-08-26 18:17 index.php
-rw-r–r– 1 root root 2548 2008-08-26 18:52 license.txt
-rw-r–r– 1 root root 106 2008-08-26 19:04 loquesea.php
-rw-r–r– 1 root root 5 2008-08-26 19:04 loquesea.php.mine
-rw-r–r– 1 root root 0 2008-08-26 19:04 loquesea.php.r15
-rw-r–r– 1 root root 66 2008-08-26 19:04 loquesea.php.r16
drwxr-xr-x 6 root root 4096 2008-08-26 19:04 .svn
drwxr-xr-x 14 root root 4096 2008-08-26 18:06 system

loquesea.php -> contendrá una mezcla del fichero que has modificado junto a la última revisión
loquesea.php.mine -> la modificación que has hecho tu
loquesea.php.r* -> las versiones en conflicto

Por lo tanto, dependiendo de lo que queramos hacer, deberemos abrir unos u otros ficheros y finalmente poner en el loquesea.php la versión que queremos conservar, por ejemplo queremos mezclar tanto la versión que hemos hecho nosotros como la que hay nueva, por lo tanto abrimos el fichero loquesea.php y quitamos las líneas que nos indican los cambios, tal que:

# vim /home/sistemas/proyectos/svn/carreteras/trunk/loquesea.php

Saldria algo así como:

<<<<<<< .mine hola ======= Ã±kdlsjgfaÃ±sljfaÃ±sljfÃ±lasdjfaÃ±skdljf asdf as f asdfsafasdfasdf>>>>>>> .r16

Por lo tanto borramos lo referente a las versiones, quedando:

hola

Ã±kdlsjgfaÃ±sljfaÃ±sljfÃ±lasdjfaÃ±skdljf
asdf
as
f
asdfsafasdfasdf

Guardamos el fichero y resolvemos el conflicto con este fichero:

# cd /home/sistemas/proyectos/svn/carreteras/trunk/
# svn resolved loquesea.php

Nos dirá algo así como:

Se resolvió el conflicto de ‘loquesea.php’

Y por ultimo hacemos el commit:
# cd /home/sistemas/proyectos/svn/carreteras/trunk/
# svn commit -m “Resolviendo el conflicto”

Y ahora no debería darnos ningún problema:

Enviando trunk/loquesea.php
Transmitiendo contenido de archivos .
Commit de la revisión 17.

Ver los logs de las revisiones

Podemos ir viendo información sobre las revisiones que se han hecho. También se puede usar para ver los comentarios que hemos ido haciendo con los commit:

# svn log

Y nos saldrá algo como:

————————————————————————
r15 | sistemas | 2008-08-27 13:20:15 +0200 (miÃ©, 27 ago 2008) | 1 line

Pruebas2
————————————————————————
r13 | sistemas | 2008-08-27 13:03:34 +0200 (miÃ©, 27 ago 2008) | 1 line

————————————————————————
r12 | sistemas | 2008-08-27 12:59:28 +0200 (miÃ©, 27 ago 2008) | 1 line

Borramos el css
————————————————————————
r11 | sistemas | 2008-08-27 12:53:16 +0200 (miÃ©, 27 ago 2008) | 1 line

Modificamos la hoja de estilos
————————————————————————
r10 | sistemas | 2008-08-27 12:48:23 +0200 (miÃ©, 27 ago 2008) | 1 line

Anadido styles.css
————————————————————————
r9 | sistemas | 2008-08-27 12:41:15 +0200 (miÃ©, 27 ago 2008) | 1 line

Importacion del codigo base de Code Igniter
————————————————————————
r1 | root | 2008-08-27 11:57:22 +0200 (miÃ©, 27 ago 2008) | 1 line

————————————————————————
Automatizar el proceso de subida a un FTP cuando hacemos commit

Cuando realizamos commit, la tarea más ardua a la hora de trabajar con svn para proyectos WEB es que al tener codificado todo el contenido usando Berkley Database (por defecto), no podremos ver a priori los datos WEB, por lo tanto podremos hacer a mano que exporte los datos y luego subirlos a un FTP, para verlos desde un servidor WEB, el problema es que cuando hacemos mucho commit, la tarea se hace muy pesada, por lo tanto vamos a automatizar este proceso.

Cuando hemos creado el repositorio svn, dentro de la carpeta que hemos creado, existe una carpeta llamada hooks, que contiene plantillas de scripts para realizar tareas, una vez que se hagan otras; me explico, por ejemplo existe una plantilla para cuando se realizan los commit llamada post-commit.tmpl. Para empezar deberemos renombrarla y quitarle la extensión .tmpl:

# mv /var/lib/svn/hooks/post-commit.tmpl /var/lib/svn/hooks/post-commit

Editamos el fichero y únicamente dejamos una línea que llame a otro script:

# vim /var/lib/svn/hooks/post-commit

Y quedará tal que:

/usr/share/subversion/hook-scripts/svn2ftp

Ahora creamos el siguiente fichero, con el siguiente contenido:

# vim /usr/share/subversion/hook-scripts/svn2ftp

Y metemos dentro:

######### INICIO SCRIPT ####################
#!/usr/bin/php5
/**
* SVN FTP synchronization post-commit hook
* @author Moises Macia
* @modificated Israel Gayoso igayoso<!@!>gmail.com
* @license MIT
* @version 0.1.1
*/

$SVN_PRJ = “carreteras”;
$SVN_DIR = “/var/lib/svn”;
$EXPORT_DIR = “/tmp/export”;
$FTP_HOST = “ftp.algo.es”;
$FTP_USER = “ftpuser”;
$FTP_PWD = “ftp”;
$FTP_DIR = “ejemplos.algo.es”;
$NSUB = strlen($SVN_PRJ . “/trunk/”);

//get changed files from last commit
exec(”svnlook changed $SVN_DIR”, $files);

if(count($files) > 0)
{
system(”svn export –quiet file:///” . $SVN_DIR . “/” . $SVN_PRJ . “/trunk/ ” . $EXPORT_DIR);

$ftp_id = ftp_connect($FTP_HOST);
$login_status = @ftp_login($ftp_id, $FTP_USER, $FTP_PWD);

if((!$ftp_id) || (!$login_status))
die(”Fallo al conectar al FTP $FTP_SERVER\n”);

ftp_chdir($ftp_id,$FTP_DIR);

foreach ($files as $line)
{
echo “$line\n”;
preg_match(”/^([AUD]{1})(\s+)(” . $SVN_PRJ . “\/trunk.*)/”, $line, $match);
$svn_code = $match[1]; //file state code
$file_path = substr($match[3], $NSUB);
switch($svn_code)
{
case ‘U’: //file updated
if(is_file($EXPORT_DIR . “/” . $file_path))
{
$upload_status = ftp_put($ftp_id, $file_path, $EXPORT_DIR . “/” . $file_path, FTP_BINARY);
if(!$upload_status)
echo “Fallo al transmitir fichero $file_path\n”;
}
break;

case ‘A’: //file added
if(is_file($EXPORT_DIR . “/” . $file_path))
{
$upload_status = ftp_put($ftp_id, $file_path, $EXPORT_DIR . “/” . $file_path, FTP_BINARY);
if(!$upload_status)
echo “Fallo al transmitir fichero $file_path\n”;
}

if(is_dir($EXPORT_DIR . “/” . $file_path))
{
$upload_status = ftp_mkdir($ftp_id, $file_path);
if(!$upload_status)
echo “Fallo al crear el directorio $file_path\n”;
}
break;

case ‘D’: //file deleted
if(substr($file_path, -1, 1) == “/”) //if its a directory
ftp_rmdirr($ftp_id, ‘/’ . substr($file_path, 0, strlen($file_path)-1));
else //if its a plain file
ftp_delete($ftp_id, $file_path);
break;
}
}

system(”rm -rf $EXPORT_DIR”); //clean exported files
ftp_close($ftp_id);
}

function ftp_rmdirr($ftp_stream, $directory)
{
// Sanity check
if (!is_resource($ftp_stream) || get_resource_type($ftp_stream) !== ‘FTP Buffer’)
return false;

// Init
$i = 0;
$files = array();
$folders = array();
$statusnext = false;
$currentfolder = $directory;

// Get raw file listing
$list = ftp_rawlist($ftp_stream, $directory, true);

// Iterate listing
foreach ($list as $current)
{
// An empty element means the next element will be the new folder
if (empty($current))
{
$statusnext = true;
continue;
}

// Save the current folder
if ($statusnext === true)
{
$currentfolder = substr($current, 0, -1);
$statusnext = false;
continue;
}

// Split the data into chunks
$split = preg_split(’[ ]‘, $current, 9, PREG_SPLIT_NO_EMPTY);
$entry = $split[8];
$isdir = (substr($split[0],0,1) === ‘d’) ? true : false;

// Skip pointers
if ($entry === ‘.’ || $entry === ‘..’)
continue;

// Build the file and folder list
if ($isdir == true)
$folders[] = $currentfolder . ‘/’ . $entry;
else
$files[] = $currentfolder . ‘/’ . $entry;
}

// Delete all the files
foreach ($files as $file)
ftp_delete($ftp_stream, $file);

// Delete all the directories
// Reverse sort the folders so the deepest directories are unset first
rsort($folders);
foreach ($folders as $folder)
ftp_rmdirr($ftp_stream, $folder);

// Delete the final folder and return its status
return ftp_rmdir($ftp_stream, $directory);
}

?>
######### FIN SCRIPT ####################

Deberemos configurar las variables de inicio, si alguna de ellas hubiera sido cambiada anteriormente.

Para que funcione este script tendremos que asegurarnos de un par de cosas primero:

Que el fichero tenga permisos de ejecución y propiedad de apache2:

# chown www-data.www-data /usr/share/subversion/hook-scripts/svn2ftp
# chmod 744 /usr/share/subversion/hook-scripts/svn2ftp

Tener instalado php en el servidor y su intérprete para bash:

# apt-get install php5 php5-cli

Una vez hecho esto, deberemos exportar todo lo que tengamos porque al ser la primera vez no hay ningún fichero en el FTP, por lo tanto esto solo lo haremos la primera vez que metamos esto y solo en el caso de que ya haya ficheros, como ocurre ahora, por lo tanto:

# svn export –quiet file:///var/lib/svn/carreteras/trunk /tmp/svn

Ahora tendremos el contenido de trunk en /tmp/svn, ahora copiaremos de la forma que más nos guste (FTP, scp, etc…) a nuestro servidor WEB y una vez que tengamos los mismos datos, cambiaremos algo en el servidor y haremos un commit para comprobar que se sube bien al FTP. No nos debería dar ningún error a la hora de hacer el commit, si lo diera comprobar que las variables han sido cambiadas correctamente, los permisos y/o propietarios y por último si los paquetes están instalados.

Clientes subversion

Existes mucha variedad de clientes subversiones para todas las plataformas, así que aquí tenéis el enlace de la wikipedia donde hace una comparación de los clientes, muestra la última versión, licencia, etc…

Lista en Wikipedia

TO-DO

Cosas que se podrían añadir o mejor a este manual:

Usar SSL para conectarse al servidor de svn
Hacer el script un poco más legible y más escalable, a parte de crear otros para subirlos por scp, cp, etc…
Añadir screenshoots o vídeos al manual
Explicar el acceso por ssh a subversion
Explicar muchas más opciones a la hora de actualizar, realizar commit, volver a una revisión, etc…

Creador
El autor de este manual es Israel Gayoso Pérez, para cualquier duda, problema o aclaración no dudes en ponerte en contacto a través del apartado contacto del blog.

Licencia
Este documento se distribuye bajo una licencia Creative Commons by nc-sa, excepto el script para la sincronización de ficheros entre SVN y FTP que está liberado bajo una licencia MIT.

Post relacionados:

Tags: how-to, manual, subversion, svn

Esta entrada fue posteada el 26 de Agosto del 2009 a las 12:13 y está en la categoría Técnico. Categorías: Técnico. Post Tags: how-to, manual, subversion, and svn. Puedes seguir los comentarios de esta entrada en el feed RSS 2.0. Puedes dejar una respuesta, o un trackback desde tu WEB.

Configuración y primeros pasos con subversion (svn)

Post relacionados:

Deja una respuesta

Páginas

Archivos

Categorías

Ahora