Como tenían varias formas de evitar que puedas descargar de forma automática todos estos ficheros, que a su vez están hosteados en MediaFire, he tenido que tirar de curl y parsear un montón para llegar a hacer la lista de descargas, aquí os dejo el script hecho en bash, también la lista para ejecutarlo y por último la app que he usado para descargar de MediaFire.

cookie=”./cookie” #Creamos una cookie para que podamos loguearnos en la WEB
useragent=’Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; es-ES; rv:1.9.1.2) Gecko/20090729 Firefox/3.5.2′ #Falseamos un UA y que no de mucho cante en los LOGs de la WEB
sid=`awk ‘/sid/ { print $7}’ $cookie` #Necesitamos un id que se crea con la cookie para seguir los enlaces a la descarga
canciones=”$1″ #Cogemos por parámetro la WEB de las canciones, en este caso será por letra y página
user=”usuario_de_la_web” #Tendremos que tener un usuario/contraseña válido para hacer login
passwd=”passwd_del_user”

echo “Haciendo Login…”
#Con esta línea, lo que hacemos con curl es loguearnos en la WEB, que en realidad corre un foro phpBB por debajo (si no me equivoco), para ellos curl creará una cookie y cogerá las variables que hemos declarado arriba para el UA, user y password. El redirect da igual, porque en realidad no lo hará, únicamente es para crear la cookie con el login correcto
curl http://ultrastar-es.org/foro/ucp.php?mode=login -d login=Identificarse -d password=$passwd -d redirect=..//canciones.php?letra=A -d username=$user -A “$useragent” -b ${cookie} -c ${cookie} –silent

echo “Pillando todas las caciones..”
#Con el primer bucle, saco los IDs de las canciones, para luego seguir el link y que me lleve al link final de MediaFire. Para ello, uso la cookie creada anteriormente y el UA. Parseo el código de la WEB para únicamente sacar el ID
for ncancion in `curl $canciones -b ${cookie} -c ${cookie} -A “$useragent” | awk ‘/amp;id/ { print }’ | awk ‘{ FS=”amp;id=”; RS=”\” title=”;  print $2 }’ | grep -ve ^$`
do
#Por último, sacando los IDs de cada canción, lo que hago es seguir el link de la WEB y que me lleve a la página de descarga de MediaFire para poder parseala. Una vez parseada, saco únicamente el link y lo meto dentro de un fichero llamado listado.txt, con él ya podré descargar todos los ficheros.
`curl -L -A “$useragent” -b ${cookie} -c ${cookie} “http://ultrastar-es.org/canciones.php?op=descargar&id=$ncancion&sid=$sid” | awk ‘FS=”"” { print $2 };’ | grep -ve ^$  >> ./listado.txt `
done

Ahora ya tentemos un fichero de texto llamado listado.txt, que contendrá todos los links de descaga de MediaFire. Lo que haremos ahora será usar algún programa que automatice el proceso de descarga, ya que si no tendríamos que hacerlo a mano uno por uno y no valdría para nada este script.

Después de probar JDownloader y no poder hacer nada porque no funcionaba muy bien el tema del captcha, aunque es un bug conocido y están reparándolo, encontré Tucan, un proyecto español y muy alpha, que esta vez el error estaba a la hora de crear carpetas, que en las que incluía ‘/’ daba error y cerraba el programa (he creado una entrada en su bugtrack). Finalmente encontré plowshare, otro proyecto libre y español que lo hace todo desde la consola, así que finalmente me decanté por él.

Para instalarlo, tenéis que seguir la instrucciones de su WEB y con el listado ya creado, ejecutar:

plowdown listado.txt

Tardará lo suyo, porque MediaFire limita mucho el ancho de banda, así que paciencia

Si tenéis alguna duda, poneros en contacto conmigo

Comenzaremos instalando el trac vía apt-get:

# apt-get install trac

Creamos el entorno para que trabaje trac. Esto se compondrá de un directorio donde irá guardando todos los datos:

# trac-admin /etc/trac/pruebas initenv

Nos hará varias preguntas para configurar trac, en las que responderemos:

Creating a new Trac environment at /etc/trac/pruebas2

Trac will first ask a few questions about your environment
in order to initalize and prepare the project database.

Please enter the name of your project.
This name will be used in page titles and descriptions.

Project Name [My Project]>carreteras

Aquí le diremos el nombre que tendrá nuestro proyecto en trac, en este caso carreteras.

Please specify the connection string for the database to use.
By default, a local SQLite database is created in the environment
directory. It is also possible to use an already existing
PostgreSQL database (check the Trac documentation for the exact
connection string syntax).

Database connection string [sqlite:db/trac.db]>[Pulsamos enter]

Ahora nos preguntará donde queremos y que motor de base de datos queremos usar, dejamos la opción por defecto, es decir, pulsamos enter sin más.

Please specify the type of version control system,
By default, it will be svn.

If you don’t want to use Trac with version control integration,
choose the default here and don’t specify a repository directory.
in the next question.

Repository type [svn]> [Pulsamos enter]

Podremos usar trac con un proyecto de svn ya hecho, si es este el caso y usamos svn pulsaremos enter para que marque la opción por defecto.

Please specify the absolute path to the version control
repository, or leave it blank to use Trac without a repository.
You can also set the repository location later.

Path to repository [/path/to/repos]> /home/sistemas/proyectos

Lo que configuraremos ahora será, solo en el caso de que vayamos a usar trac con un proyecto de svn y será el directorio del repositorio de svn a trabajar, en este caso /home/sistemas/proyectos

Por último nos preguntará el directorio de plantillas, donde ha sido instalado trac, en este caso está en el directorio por defecto, así que daremos al enter para acabar de configurar el entorno:

Please enter location of Trac page templates.
Default is the location of the site-wide templates installed with Trac.

Templates directory [/usr/share/trac/templates]> [Pulsamos enter]

Arrancar el servidor de trac

En modo standalone

Ahora ya tendremos configurado el entorno, ahora vamos a lanzar el servicio de forma “standalone” para ver a tiempo real los accesos, luego lo mandaremos en modo demonio y lo meteremos en el inicio del sistema, para que arranque cuando arrancamos la máquina.

# tracd –port 8000 /etc/trac/pruebas

Si no ha habido ningún problema, arrancará nuestro servidor de trac, con el entorno que hemos configurado en el paso anterior, por lo tanto para ver trac en la WEB, abriremos un navegador e iremos al puerto de trac:

http://localhost:8000/carreteras

Veremos que trac está funcionando en este puerto y para el proyecto y entorno que hemos creado.

En modo demonio

Ahora vamos a ejecutar trac como demonio, para que no tengamos que tenerlo siempre ejecutado en una consola, por lo tanto meteremos el flag d y lo ejecutaremos:

# tracd –d –port 8000 /etc/trac/pruebas

Por ultimo vamos a meterlo como demonio en el arranque del sistema. Creamos un script que arranque el trac en modo demonio, como hemos hecho a lo último y lo metemos en un fichero dentro de /etc/init.d:

# vim /etc/init.d/tracd

Y metemos dentro la línea de ejecución:

tracd –d –port 8000 /etc/trac/pruebas

Le damos permisos de ejecución:

# chmod a+x /etc/init.d/tracd

Y por ultimo lo metemos en los rc:

# update-rc.d -f tracd defaults

Como hemos puesto por defecto, lo meterá en todos los arranques del sistema (0-6). Por ultimo probaremos si se arranca bien, ejecutando:

# /etc/init.d/tracd start

Si quisiéramos que al hacer stop/restart también funcionara, tendríamos que modificar el script que hay en init.d para que lo hiciera, como no es nuestro caso, lo dejaremos así de momento.

Usando el mod_python

Según la recomendación de trac, una forma de usarlo, de la manera más rápida y/o cómoda es con mod_python, un módulo de apache2 para que funcione python en él, por lo tanto vamos a instalarlo y configurarlo, primero instalamos los paquetes necesarios:

# apt-get install libapache2-mod-python libapache2-mod-python-doc

Activamos el módulo en apache2, por si no lo hace él solo a la hora de instalar:

# a2enmod mod_python

Creamos dentro de apache2 la localización para entrar a él vía WEB, por lo tanto editamos el fichero por defecto del virtualhost (o el que vayamos a usar) e introducimos las siguientes líneas:

# vim /etc/apache2/sites-enable/000-default

<Location /trac>
SetHandler mod_python
PythonInterpreter main_interpreter
PythonHandler trac.web.modpython_frontend
PythonOption TracEnv /etc/trac/carreteras
</Location>

Hay veces que se arma líos con las rutas y los estilos, por si acaso meteremos este alias en apache2 para que sepa bien dónde está:

# vim /etc/apache2/sites-enable/000-default

Alias /trac/css “/usr/share/trac/htdocs/css”
<Location /trac/css>
SetHandler None
</Location>

Para finalizar, tenemos que reiniciar apache2 para que coja estás nuevas localizaciones y rutas, por lo tanto:

# /etc/init.d/apache2 restart

Y si ahora vamos a la nueva dirección para entrar en trac, que en este caso no hará falta entrar a través del puerto 8000, ya que no lo hemos configurado así, iremos:

http://localhost/trac

Configurar los permisos en trac por usuario

Dentro de trac podremos crear usuarios para que puedan crear tickets, corregirlos, cerrarlos, etc… para ello usaremos contraseñas de apache2 y en este caso aprovecharemos las que usamos en svn/dav y así tenerlas todas en el mismo sitio. El directorio de login dentro de trac está en:

/trac/login

Por lo tanto vamos a crear una nueva localización y darle permisos con contraseñas de apache2:

# vim /etc/apache2/sites-enable/000-default

<Location /trac/login>
AuthType Basic
AuthName “Trac Login”
AuthUserFile /etc/apache2/dav_svn.passwd
Require valid-user
</Location>

Ahora ya podremos hacer autentificarnos, dentro de trac en el apartado login, usando la autentificación de apache2 que también usamos para el svn/dav.

Si quisiéramos usar otro fichero de contraseñas, únicamente tendríamos que crearlo con htpasswd y meterlo en el Location.

Configuración de un plugin: webadmin

En este apartado vamos a matar dos pájaros de un tiro, por una parte vamos a mostrar como configurar e instalar un plugin de trac y para ello, usaremos el webadmin, que es una forma fácil de configurar nuestros proyectos en trac sin usar la consola con el comando trac-admin.

Lo primero que vamos a hacer es instalar un paquete necesario para python:

# apt-get install python-setuptools

Una vez instalado, nos bajaremos el código del webadmin y haremos un fichero .egg, que será el plugin comprimido, bajamos el código:

# cd /tmp
# svn export http://svn.edgewall.com/repos/trac/sandbox/webadmin/

El código lo tendremos dentro de la carpeta webadmin, ahora vamos a usar python para crear el .egg:

# cd webmin
# python setup.py bdist_egg

Ahora que ya lo tenemos, lo metemos dentro de la carpeta plugins de nuestro entorno. El .egg estará en la carpeta dist:

# cp dist/* /etc/trac/carreteras/plugins/

Para casi finalizar, meteremos dentro del entorno este plugin, editando el fichero trac.ini y añadiendo unas líneas:

# vim /etc/trac/carreteras/conf/trac.ini

[components]
webadmin.* = enabled

Para finalizar daremos permisos a uno o más usuarios para poder usar este plugin, para ello usaremos trac-admin:

# trac-admin /etc/trac/carreteras/ permission add sistemas TRAC_ADMIN

En este caso damos permisos en el apartado TRAC_ADMIN al usuario sistemas, que está dentro de los usuarios que pueden acceder a login y hemos configurado previamente.

Reiniciaremos apache2 y estará todo configurado:

# /etc/init.d/apache2 restart

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

Mas pruebas
————————————————————————
r8 | sistemas | 2008-08-27 12:38:57 +0200 (mié, 27 ago 2008) | 1 line

Pruebas1
————————————————————————
r7 | sistemas | 2008-08-27 12:34:03 +0200 (mié, 27 ago 2008) | 1 line

————————————————————————
r6 | sistemas | 2008-08-27 12:33:03 +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.