domingo, 29 de diciembre de 2013

Instalación de Redmine en Debian 7




A la hora de gestionar proyectos existen multitud de herramientas y opciones disponibles. Algunas son gratis, otras no, unas ofrecen la posibilidad de instalarlas en tus propios servidores, otras se contratan "en la nube".
Redmine es una de las que permiten instalarlo en tus propios servidores. Se trata de un gestor de proyectos escrito con Ruby on Rails, es multiplataforma y soporta múltiples bases de datos. Además es software libre con licencia GPLv2.
Entre sus características destaca el soporte multi-proyecto, sistema de roles y permisos muy flexible y personalizable, gestión de tareas, wikis, foros, subida de archivos y documentos, notificaciones por email y por RSS,...

Llevo casi 4 años utilizando Redmine en el día a día del trabajo (además de administrándolo) y después de instalarlo varias veces de cero y actualizarlo entre versiones otras tantas por fin me he decidido a juntar todas mis notas y escribir un tutorial actualizado.

Partimos de una Debian 7 64 bits recién instalada sin nada adicional a excepción de OpenSSH. Toda la instalación se realizará con un usuario no root en su home, aunque algunos comandos requieren el uso de sudo. Aunque Redmine viene configurado por defecto para utilizar MySQL, en mi caso lo voy a instalar utilizando Postgresql.

Instalación de Postgresql 9.3

En los repos de Debian no está la última versión por lo que lo mejor es utilizar un repo oficial. En la actualidad ya se ha publicado la versión 9.3.2 y será ésta la que utilicemos.

  • Añadir el repo de Postgres
  • sudo vi /etc/apt/sources.list.d/pgdg.list
    
    # Postgresql
    deb http://apt.postgresql.org/pub/repos/apt/ wheezy-pgdg main
    
  • Añadir clave de verificación
  • wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
    
  • Actualizar los paquetes e instalar postgresql-9.3
  • sudo apt-get update
    sudo apt-get install postgresql-9.3
    
  • Damos permisos para conectarnos a las bases de datos
  • sudo vi /etc/postgresql/9.3/main/pg_hba.conf
    
    # Cambiar la siguiente línea:
    local   all             postgres                                peer
    
    # por:
    local   all             postgres                                trust
    
  • Reiniciar el servidor para que aplique los cambios:
  • sudo /etc/init.d/postgresql restart
    
  • Crear la base de datos
  • $ psql -U postgres
    psql (9.3.2)
    Type "help" for help.
    
    postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'my-secret-password' NOINHERIT VALID UNTIL 'infinity';
    postgres=# CREATE DATABASE redmine WITH ENCODING='UTF8' OWNER=redmine;
    

    Instalación de paquetes adicionales

    Para poder compilar las gemas de ruby que instalaremos más tarde necesitamos una serie de paquetes. Algunos son los mínimos para poder compilar cualquier fuente: gcc, make,... y otros son necesarios para las gemas.
    sudo apt-get install build-essential
    
    Instalar librería necesaria para utilizar Postgresql desde una aplicación Ruby on Rails
    sudo apt-get install libpq-dev
    

    Instalación de Apache

    Para poder servir el Redmine una vez instalado vamos a utilizar apache.
    Instalar apache2 y habilitar los módulos necesarios:
    sudo apt-get install apache2 libapache2-mod-fcgid libapache2-mod-proxy-html libfcgi-dev
    
    sudo a2enmod rewrite
    sudo a2enmod proxy_http
    sudo a2enmod proxy
    

    Instalación de ImageMagick

    Para la generación de pdfs y pngs Redmine utiliza ImageMagick, por lo que si queremos utilizar esta funcionalidad deberemos instalarlo junto con las librerías necesarias.
    $ sudo apt-get install imagemagick libmagickwand-dev libmagickcore-dev
    

    Instalación de Ruby

    Ahora ya podemos instalar Ruby. Utilizaremos la versión 1.9.3.
    sudo apt-get install ruby1.9.3
    

    Instalación de Redmine

    Por fin, después de haber instalado todas las dependencias podemos empezar con la instalación de Redmine.
  • Descargar la última versión disponible. En el momento de escribir este artículo es la versión 2.4.2
  • wget http://www.redmine.org/releases/redmine-2.4.2.tar.gz
    tar zxvf redmine-2.4.2.tar.gz
    ln -s redmine-2.4.2 redmine
    cd redmine
    
    La creación del enlace simbólico no es necesaria pero es una buena práctica. Además nos sirve en el futuro para actualizar la versión sin tener que tocar la configuración del Apache.
  • Crear el archivo de configuración de la base de datos a partir del que viene de ejemplo y editarlo
  • cp config/database.yml.example config/database.yml
    vi config/database.yml
    
    production:
      adapter: postgresql
      database: redmine
      host: localhost
      username: redmine
      password: "my-secret-password"
      encoding: utf8
    
    Importante quitar mysql de los environments de develop y test porque sino luego intentará instalar las dependencias y fallará. Poner "postgresql" en todos aunque no se configure nada más. Sólo vamos a usar el environment de producción.
  • Añadir una gema que luego utilizaremos para que se instale junto con el resto.
  • echo 'gem "fcgi"' > Gemfile.local
    
  • Instalar gema de postgresql
  • sudo gem install pg
    
  • Instalar gestor de gemas
  • sudo gem install bundler
    
  • Instalar todas las dependencias de Redmine
  • sudo bundle install --without development test
    
  • Crear las tablas de la base de datos
  • RAILS_ENV=production rake db:migrate
    
  • Crear los datos iniciales (recomendado en inglés)
  • RAILS_ENV=production rake redmine:load_default_data
  • Crear directorios y dar permisos
  • mkdir -p tmp tmp/pdf public/plugin_assets
    chmod -R 755 files log tmp public/plugin_assets
    
  • Generar el session store secret
  • rake generate_secret_token
    Y listo, ahora sólo falta probar que todo funciona correctamente. Para ello, ejecutamos el servidor web embebido (no utilizar en producción).
    $ ruby script/rails server webrick -e production
    => Booting WEBrick
    => Rails 3.2.13 application starting in production on http://0.0.0.0:3000
    => Call with -d to detach
    => Ctrl-C to shutdown server
    [2013-12-28 11:05:17] INFO  WEBrick 1.3.1
    [2013-12-28 11:05:17] INFO  ruby 1.9.3 (2013-11-22) [x86_64-linux]
    [2013-12-28 11:05:17] INFO  WEBrick::HTTPServer#start: pid=25214 port=3000
    
    Nos conectamos con el navegador a http://localhost:3000 y nos logamos con admin/admin.

    Configuración de Apache

    Para servir el Redmine para poder utilizarlo en producción vamos a utilizar Apache junto con fcgi.
  • Desde el directorio redmine copiamos el archivo htaccess y de fcgi a partir de las plantillas.
  • cp public/htaccess.fcgi.example public/.htaccess
    cp public/dispatch.fcgi.example public/dispatch.fcgi
    chmod +x public/dispatch.fcgi
    
  • Editar el archivo de configuración de entornos para utilizar el de producción por defecto
  • vi config/environment.rb
    
    # Añadir la siguiente línea al principio del archivo
    ENV['RAILS_ENV'] ||= 'production'
    
  • Añadir el nuevo virtual host al apache
  • sudo vi /etc/apache2/sites-enabled/000-default
    
    <VirtualHost *:80>
        ErrorLog /var/log/apache2/redmine-error-log
        CustomLog /var/log/apache2/redmine-access-log combined
    
        ServerName redmine.my-domain.com
        ServerAdmin admin@my-domain.com
        DocumentRoot /home/ivan/redmine/public
        ProxyPreserveHost On
    
        <Directory "/home/ivan/redmine/public/">
            Options Indexes ExecCGI FollowSymLinks
            Order allow,deny
            Allow from all
            AllowOverride all
        </Directory>
    </VirtualHost>
    
  • Dar permisos de escritura al usuario de apache a algunos archivos y directorios
  • sudo chown -R www-data:www-data files log tmp public/plugin_assets
  • Reiniciar apache
  • sudo /etc/init.d/apache2 restart
    Y listo, si todo va bien deberíamos poder conectarnos a nuestro nuevo Redmine con el dominio que hayamos definido en nuestro virtual host, en este caso http://redmine.my-domain.com.

    Bola extra: Actualizar una versión antigua de Redmine

    Como he comentado al principio del artículo, llevo utilizando Redmine casi 4 años (empecé en la versión 0.9.6) y he actualizado de versión en bastantes ocasiones. El proceso de actualización es muy simple.

  • Instalar la nueva versión como hemos hecho hasta ahora y comprobar que todo funciona correctamente.
  • Parar apache y hacer una copia de seguridad de nuestra base de datos actual (espero que además hagas copias periódicas).
  • sudo /etc/init.d/apache2 stop
    pg_dump -U postgres redmine > db_redmine.sql
    
  • Después de instalar la nueva versión de redmine, en lugar de crear todas las tabla en la base de datos, lo que tenemos que hacer es ejecutar la migración de las mismas.
  • rake db:migrate RAILS_ENV=production
    
    Esto lo que hace es ejecutar todas las migraciones desde la versión que teníamos instalada hasta la versión actual para que el modelo de datos sea el adecuado.
  • Si tenemos plugins instalados, ejecutar sus migraciones.
  • rake redmine:plugins:migrate RAILS_ENV=production
  • Copiar los archivos subidos del directorio files del redmine antiguo al nuevo.
  • Limpiar cache y sesiones.
  • rake tmp:cache:clear
    rake tmp:sessions:clear
    
  • Finalmente reiniciar apache y logarnos de nuevo. Luego, en el menú Administration -> Information podemos comprobar que la migración se ha realizado correctamente y estamos con la versión adecuada:


    Para el que no esté muy seguro sobre las actualizaciones, decir que en todas las actualizaciones de estos años no he tenido ningún problema y todas han funcionado a la perfección. En esta última actualización he pasado directamente de la versión 1.4.4 a la 2.4.2. Han sido cinco versiones mayor (2.0, 2.1, 2.2, 2.3 y 2.4) y 27 versiones en total de diferencia entre ambas y cero problemas :-)
  • domingo, 27 de octubre de 2013

    Codemotion 2013

    El pasado fin de semana tuvo lugar la segunda edición de Codemotion en el que participé, además de como representante de Madrid-GUG, como ponente.

    Para el que no lo conozca, Codemotion es un evento por y para las comunidades. Es un punto de encuentro en el que nos reunimos todas las comunidades: Groovy, Java, Python, Ruby, Php,... A lo largo de dos días, 8 tracks y más de 100 charlas se han reunido en el Campus Sur de la Universidad Politécnica de Madrid más de 1500 personas para hablar y disfrutar de su pasión.

    En cuanto a las charlas, las del viernes me parecieron más flojas que las del sábado, aunque también es cierto que el viernes hubo muchas charlas de patrocinadores que no me llamaban tanto la atención. La organización fue muy buena teniendo en cuenta el número de asistentes y todo lo que había que coordinar.

    Para los que estén interesados en mi charla, a continuación teneis las slides y el código fuente de las demos se encuentra disponible en mi github.

    lunes, 5 de agosto de 2013

    Leído: Programming Grails



    Ya se sabe, vacaciones, más tiempo libre, estar en la playa casi sin conexión a internet,... qué mejor forma de aprovechar el tiempo que leyendo :-)

    Libro escrito por otro de los Core Developer de Grails, Burt Beckwith y como él mismo cuenta en la introducción, orientado a desarrolladores con experiencia en Grails que quieren conocer con más detalle cómo funciona la magia del framework y cómo se integra con Groovy, Spring y Hibernate. Si no conoces Grails este no debería ser tu primer libro porque no cuenta los distintos artefactos y cómo funciona el framework, sino que se mete directamente en sus tripas.

    Para empezar en el capítulo 1 damos un repaso a Groovy, lenguaje en el que se basa Grails. Se explica de una manera sencilla las particularidades del lenguaje y lo que lo diferencia de Java. Además se explican las colecciones, mapas, closures e incluso se habla un poco de meta-programación. El siguiente capítulo explica con detalle los 16 plugins core de una aplicación Grails: controllers, codecs, filters, urlMappings,... Da un punto de partida de cómo funcionan y deja con ganas de ponerte con el IDE a mirar con más detalle.
    El resto de capítulos habla de la capa de Persistencia, la relación con Spring, con Hibernate, la externalización de la configuración... y distintos "gotchas" a tener en cuenta y que más de una vez seguro que te han ocurrido y no sabías por qué.

    El libro me ha dejado un sabor un poco agridulce. Por una parte algunos capítulos como la parte de Spring, Hibernate o los Plugins me han gustado mucho y he aprendido bastante. Por otra parte otros como el de los plugins core de Grails hay que leerlos con el IDE abierto para ir analizando las distintas clases e interfaces que van explicando, puesto que si no se entiende nada. Tendré que volver a releerlos delante del ordenador para seguir profundizando en las tripas del framework.
    Por último, alguno de los últimos capítulos como el relacionado con los entornos Cloud o cómo actualizar las aplicaciones me han parecido un poco de relleno.

    Aún así, me parece un libro imprescindible si ya llevas tiempo con el framework y quieres conocer más cómo funciona under the hood.

    jueves, 25 de julio de 2013

    Leído: The Definitive Guide to Grails 2

    Aunque ya llevo varios años trabajando con Grails siempre está bien mantenerse al día con las actualizaciones de los libros existentes a las últimas versiones del framework. El libro está escrito por Graeme Rocher y Jeff Brown, Grails Team Leader y Core Developer de Grails respectivamente, lo que implica que ambos conocen bien las tripas del framework y saben de lo que hablan.

    Durante 12 capítulos van explicando la esencia del framework y los pilares en los que se basa, principalmente Spring y Hibernate y Groovy como lenguaje de programación. Así, vamos viendo como empezar instalándolo y creando nuestra primera aplicación, las clases de dominio, los controladores, las vistas, los servicios hasta la internacionalización, GORM o el desarrollo de plugins. Los capítulos están bien estructurados y cuentan con buenos ejemplos con los que van explicando las particularidades de cada tipo de artefacto del framework. También incluyen en cada capítulo un apartado en el que se explica como testear el tipo de artefacto que se está explicando. Creo que habría sido mejor que los ejemplos de los tests hubiesen sido con Spock en lugar de con Junit, aunque mientras Grails no incluya Spock por defecto, tiene sentido no tener que instalar dependencias adicionales para hacer los tests. Yo sin embargo, siempre recomiendo a cualquiera que trabaje con Grails (e incluso con Java) que utilice Spock para realizar los tests puesto que conseguirá que sus tests sean mucho más explícitos, expresivos y fáciles de mantener que con Junit.

    Para finalizar comentaré que aunque la gran mayoría de lo que he leído lo conocía, siempre viene bien refrescar conceptos y reforzar algunas partes del framework que son algo más complejas. También he aprendido algún truco nuevo que seguro que utilizo dentro de poco en algún proyecto. En definitiva, un libro interesante para cualquiera que se quiera iniciar en Grails y también para desarrolladores que lleven tiempo trabajando con el framework.

    domingo, 7 de abril de 2013

    Leído: Seven Databases in Seven Weeks



    Con este artículo empiezo una serie en el blog en los que iré contando mi opinión sobre distintos libros técnicos que voy leyendo. Uno de mis propósitos para este año es lograr sacar tiempo para leer 5 ó 6 libros técnicos y, a ser posible, que no estén relacionados unos con otros ni estén centrados en un campo específico.

    Así, empezamos con Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement. A lo largo del libro hemos visto distintas bases de datos de distintos paradigmas. Desde las clásicas relacionales, hasta las modernas NoSQL con sus distintas variantes: orientadas a documentos, clave-valor, basada en columnas hasta las orientadas a grafos.

    El libro no pretende ser una guía del DBA para cada una de esas bases de datos ni tampoco un manual de instalación de cada una de ellas, sino que directamente nos va mostrando distintas características de cada una a través de diversos ejemplos. También se centra en los distintos criterios que debemos tener en cuenta a la hora de elegir una u otra y destaca sus puntos fuertes y deficiencias.

    Las bases de datos que se muestran, en el mismo orden de aparición son:
    - PostgreSQL: Se trata de una de las base de datos opensource relacionales más potentes que existen en la actualidad. Aunque personalmente llevo utilizándola varios años, aprendí muchas cosas de tipos nativos, array n-dimensionales y búsquedas full text search.
    - Riak: Entra dentro de la categoría de clave-valor aunque añade conceptos muy interesantes como un completo interfaz REST y enlaces entre campos de distintas relaciones.
    - HBase: Es una base de datos orientada a columnas. Aunque inicialmente parece una base de datos relacional tal cual, ya en la introducción nos indican claramente que no es la típica base de datos que utilizaremos para nuestro pequeño catálogo de productos, sino que debemos tener muchos gigabytes o terabytes de datos para aprovecharla realmente. Al estar diseñada para un gran volumen de datos, el escalado es muy fácil de implementar. Otras cosas interesantes son el versionado automático de columnas y la compresión nativa de datos.
    - MongoDB: Probablemente sea una de las bases de datos NoSQL más conocidas en la actualidad. El hecho de que sitios como Foursquare estén implementados con MongoDB le ha dado mucha fama. MongoDB encaja en la categoría de bases de datos orientadas a documentos, donde su principal característica es ser schemaless, es decir, no obligar a tener un esquema definido en las colecciones. Los documentos son JSON y entre sus principales características destacan la replicación de los datos y el sharding de grandes colecciones.
    - CouchDB: Al igual que MongoDB, CouchDB es una base de datos orientada a documentos JSON y con interfaz REST. Una de sus principales características es que está diseñada para funcionar desde en un teléfono Android, en un pc hasta en un Datacenter.
    - Neo4J: Se trata de una base de datos orientada a grafos. Es ideal para modelar tipos de relaciones de amistad, gustos,... Su principal lema es "si puedes dibujarlo como cajas y líneas en una pizarra, entonces puedes almacenarlo en Neo4J". Me ha impresionado porque es un nuevo paradigma de bases de datos para mí y sirve para cambiar el chip.
    - Redis: La base de datos clave-valor por excelencia. Además posee numerosas operaciones para realizar todo tipo de operaciones: rankings ordenados, listas,...

    Para terminar, añadiré que la lectura del libro es amena y cómoda. Cada capítulo está dividido en "3 días" y al final de cada día se incluyen una serie de ejercicios para practicar y afianzar lo aprendido. En mi caso, los ejercicios no los he podido hacer porque me llevarían demasiado tiempo (del que no dispongo). Aún así, estoy contento con lo aprendido a lo largo del libro que me ha servido para conocer otro tipo de bases de datos para utilizar en el futuro si los problemas a resolver lo requieren.

    sábado, 2 de marzo de 2013

    Descargando torrents desde un QNAP (y II)

    Este artículo continua justo donde acabó el anterior. Como comentaba al final del mismo, el principal problema de TV Torrent RSS es la gestión de filtros. Por cada nueva serie que añado en la web Show RSS tengo que entrar en el NAS y añadir el nuevo filtro en el archivo de properties de TvRss.
    Por suerte, se trata de un proyecto open source en el que el código fuente se encuentra disponible. Está desarrollado en Java, así que por este lado no tenía ningún problema adicional.
    Me puse manos a la obra, lo descargué, empecé a analizarlo y hacer algunas pruebas y lo modifiqué para eliminar toda la funcionalidad de los filtros que no necesitaba. De paso me decidí por aligerar ("bamedizar" que decimos por Kaleidos) el código. Así, bajé de las 22 clases Java iniciales a sólo 7 :-), eliminando el soporte de envío de emails y toda la lógica para poder utilizar los filtros que ya no es necesaria. Además, al no tener que comprobar para cada .torrent todos los filtros para ver si hay que descargarlo o no, la ejecución ahora es mucho más rápida.
    También aproveché para añadir la librería log4j ya que el logging se estaba haciendo simplemente con println, eliminé las librerías que no eran necesarias y reorganicé el resto. Finalmente actualicé el archivo ant que se utiliza para la construcción del proyecto.

    El resultado está publicado en mi cuenta de Github junto con las instrucciones para ejecutarlo. Ahora simplemente lanzo un script todos los días por medio del crontab y mi nueva versión de TvRss se descarga todos los archivos incluyendo versiones proper, repacks, en 720p, en calidad normal y todo sin tener que hacer nada adicional.

    domingo, 27 de enero de 2013

    Ponente en Greach 2013 e impresiones

    El pasado viernes 25 de Enero empezó la 2ª Edición de Greach que en esta ocasión ha durado dos días. Este año he tenido la suerte de asistir como ponente y dar una charla con el título Todo lo que me hubiera gustado saber cuando empecé a desarrollar con Grails. Al principio estaba muy nervioso pero al final todo salió muy bien. De hecho, mucha gente me comentó después que les había gustado mucho la charla y que habían aprendido unas cuantas cosas. ¡Muchas gracias a todos!

    Respecto al resto de las charlas, mis comentarios:
    1.- Keynote Groovy 2.0 update: Cedric Champeau fue el encargado de la Keynote de apertura. En esta ocasión Guillaume Laforge no pudo venir aunque conectamos con él via chat y anunció la publicación de Groovy 2.1.0 en la Keynote. La keynote fue muy parecida a la que vi en diciembre en el Grails Exchange de Londres.
    2.- Road to Grails 3.0: Graeme Rocher fue el encargado de contarnos la novedades que vendrán en las próximas versiones de Grails.
    3.- Hybrid mobile app in minutes, not days: Charla por Fabrice Matrat, Sebastien Blanc y Corinne Krych que crearon en 45 minutos un pequeño clon de Foursquare con el plugin html5 mobile scaffolding. La charla fue muy interesante y la parodia que hicieron durante la presentación fue muy divertida. "Hello, Mr.very-very-rich man" :-P
    4.- Test motherFucker... Test!!!: Mario García nos contó qué plugins utiliza él durante los tests de sus aplicaciones Grails y cual es la aproximación que realiza a la hora de testear la aplicación.
    5.- Cómo crear una plataforma de libros electrónicos: Roberto Martin y Alberto Vilches nos contaron su experiencia real en una plataforma de libros electrónicos, los problemas que han ido encontrando y cómo los han superado.
    6.- vert.x - Effortless asynchronous application development for the modern web and enterprise: Aunque inicialmente la charla la iba a dar Stuart Williams, al final no pudo asistir y fue su compañero Stéphane Maldini el que la dio. No estuvo mal aunque me esperaba un poco más.
    7.- Buscando (y encontrando) la pareja ideal. Taller de desarrollo de aplicaciones Web con Grails 2: Taller para el desarrollo de una aplicación Grails por parte de Fernando Redondo. Aunque muchas cosas ya las sabía, aprendí algún pequeño truco.
    8.- A GPars Programming Workshop: Taller de lujo con Russel Winder sobre GPars. Aunque fue un taller la verdad es que no hubo demasiado tiempo para programar.
    9.- From big-GORM-centered into a cloud of fast nodes: Jorge Uriarte nos contó cómo han adaptado la plataforma TicketBis desde una "simple" aplicación Grails con tomcat, mysql, terracotta,... a una más moderna con Redis y nodos "ligeros" para poder seguir creciendo y soportando la carga.
    10.- Testing the Grails Spring Security Plugins: Interesante charla de Burt Beckwith en la que nos mostraba distintas alternativas para probar Spring Security.
    11.- Building a scalable API with Grails: Tanausú Cerdeña nos contó cual fue el proceso de creación y las distintas decisiones de diseño que tomaron en la creación del API de Geosophic.

    Como veis, dos días muy intensos llenos de Groovy/Grails y demás tecnologías.

    No quiero terminar sin dar la enhorabuena a Alberto Vilches por el gran trabajo de estos últimos meses y por arriesgar tanto para dar lo mejor a todo el mundo: Cambio de ubicación a un hotel en pleno centro de Madrid en lugar de en las afueras, dos días de conferencias en lugar de uno, aumento del precio de 10€-20€ a 90€-120€ (si compraba en early-bird o no), comida excelente en el restaurante del hotel,... Creo que ha sido magnífico y todos hemos quedado encantados. ¡Kudos!

    Ah, y finalmente, por si hay algún interesado, las slides de mi charla:

    ACTUALIZADO: Ya está disponible el video, aunque es una pena que los primeros 2-3 minutos de la presentación no estén.

    miércoles, 16 de enero de 2013

    Descargando torrents desde un QNAP (I)

    Hace tiempo conté mi estrategia de backup en casa. Tengo montado un servidor debian con un raid 1 y unos scripts personalizados de rsync para realizar la sincronización y copia de los datos.

    Adicionalmente tenía un portátil un tanto antiguo con ubuntu con el que descargaba series por medio de bittorrent y alguna otra cosa con amule. Hace unos meses decidí que quería mejorar un poco toda esta infraestructura con un NAS. Así, después de mucho mirar compré un Qnap TS-412 y un par de discos de 2 TB. Con los dos discos he creado un raid 1 y ahora tengo ahí toda mi información, fotos, series, música,...

    El qnap tiene un linux embebido con mucha funcionalidad y que es fácilmente ampliable y personalizable. Para las descargas utilizo Transmission que se puede instalar desde el gestor de software incluído. Transmission funciona perfectamente pero tiene un pequeño problema, no permite configurar un feed rss desde el que descargar los torrents. Esto es un gran problema para mí porque para descargar mis series favoritas utilizo Show RSS. Una vez registrado en la web eliges tu series de la lista y puedes generar un feed rss personalizado en donde se publicarán automáticamente los torrents de las series según estén disponibles.

    Así que con este problemilla me puse a buscar una solución. Como no soy el único que tiene estos problemas estuve probando distintas alternativas que encontré en diversos foros, pero o no funcionaban correctamente o no me terminaban de convencer. Finalmente encontré TV Torrent RSS Downloader que casi cubre mis necesidades. Es una pequeña aplicación hecha en Java en la que configuras uno o varios feeds rss y unos filtros y descarga los archivos adjuntos. Después de hacer una pruebas en local todo funcionó a la perfección, pero hay había un problema ¿cómo instalo java en el qnap?

    Después de bucear un poco por la web de Sun Oracle llegué a la web de descargas del JRE para Linux ARM y tras unas pruebas de ensayo-error descargué la versión correcta para mi arquitectura: ARMv5 Linux – Headless EABI, SoftFP, Little Endian. La instalación es tan sencilla como descomprimir el archivo y configurar el path correctamente y comprobar que el ejecutable funciona:
    $ ./java -version
    java version "1.6.0_38"
    Java SE Embedded Runtime Environment (build 1.6.0_38-b05, headless)
    Java HotSpot(TM) Embedded Client VM (build 20.13-b02, mixed mode)
    

    Ahora con java instalado es tan sencillo como ejecutar:
    $ java -jar tvrss.jar
    

    Y los .torrents de cada serie se iran descargando automáticamente al directorio que hayamos especificado en el archivo de configuración. Una vez funcionando las descargas de los .torrents de cada serie, si configuramos la ruta de descarga al directorio watched de transmission, los archivos se añadirán y se pondrán a descargar automáticamente.

    Con todo funcionando podemos configurar un script .sh que se ejecute a la hora que queramos y descargue automáticamente todos los torrents. Por ejemplo:

    $ cat tvrss.sh 
    #!/bin/bash
    
    JAVA_HOME=/share/MD0_DATA/software/java/ejre1.6.0_38
    APP_DIR=/share/MD0_DATA/software/transmission_scripts/tvrss
    LOG_FILE=$APP_DIR/torrents.log
    
    cd /share/MD0_DATA/software/transmission_scripts/tvrss
    $JAVA_HOME/bin/java -jar $APP_DIR/tvrss.jar >> $LOG_FILE
    

    Con esto solucionamos el problema de la descarga de los archivos .torrent y el añadirlos a Transmission, pero como comenté antes, la versión original de TV Torrent tiene un pequeño problema: los filtros. Por cada serie que queramos descargar es necesario añadir un filtro nuevo en el archivo de configuración para que ésta se descargue. Además, si en el feed rss publican una nueva versión, las típicas versiones PROPER o REPACK que corrigen problemas de sincronización o similar, éstas tampoco serán descargadas.

    La solución en el siguiente artículo :-)