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.

Demo de Mufly

   Hace unos meses os presentaba el Proyecto Mufly. El tiempo va pasando y sigo implementando nuevas funcionalidades y mejorándolo poco a poco. Hace una semana publiqué en el blog del proyecto un post en el que contaba que he puesto online una demo para que todo el mundo lo quiera probar. Tenéis toda la información en este post.

   Como este blog tiene algo más de difusión que el blog del proyecto, os pongo aquí la url para el que quiera pueda probar Mufly y darme su opinión:
http://mufly.dyndns.org:8080/

   Espero comentarios...

Mufly: Contabilidad doméstica programada en GWT

   Hace unos meses comentaba que había descubierto Google Web Toolkit y que estaba desarrollando una aplicación con GWT. Hoy os presento Mufly. Es una aplicación que estoy desarrollando para llevar los gastos de casa y que ya está sustituyendo desde enero de 2009 a otra que venía usando desde el 2004.
   La principal novedad y en lo que he centrado el desarrollo es en el uso de etiquetas (o tags). Así, en lugar de tener una transacción y asociarla a la categoría Ropa, por ejemplo, la puedo etiquetar con varias etiquetas como Ropa e Iván. También he implementado la funcionalidad de dividir transacciones (split). El concepto es muy simple y la mejor manera de explicarlo es por medio de un ejemplo. Por ejemplo: Vas a unos grandes almacenes y compras comida, ropa y un regalo. Cuando introduces estos datos en Mufly sólo debes añadir una transacción: Compra en grandes almacenes, el precio 120€ y las etiquetas (por ejemplo las 3 siguientes: regalo, comida, ropa). Entonces, hacemos el split de la transacción para detallar la compra. Alguna comida 60€, Ropa (pantalones y camisas) 40€ y Libro de GWT 20€. Es decir, sirve para desglosar un único gasto.

   El proyecto Mufly está alojado en Google Code y está liberado con licencia GPLv3. El idioma principal tanto de la web como de la aplicación es el inglés porque quiero que llegue a más gente. No obstante, en el wiki tengo traducido al español la página principal. También he creado hace unas semanas un blog en el que iré contando las novedades. Los post están escritos primero en inglés y luego en español para que cualquiera pueda preguntar sus dudas, contar sugerencias,...

   Y respecto al desarrollo, liberé la versión 0.2 en diciembre y estoy trabajando en la siguiente versión. En ella me he centrado sobre todo en la internacionalización de la aplicación además de en distintas mejoras internas y organización del código. De esta manera, cuando la libere estará disponible también en español y en francés (gracias Alex por la traducción). Respecto a esto es muy sencillo implementar nuevos idiomas, simplemente hay que traducir un archivo de recursos y al realizar la conversión de Java a Javascript, GWT generará las páginas correspondientes a los idiomas que utilicemos.

   Os animo a que la probéis y me dejéis vuestro feedback tanto aquí como en el blog de proyecto. Sólo necesitáis un MySQL y Tomcat para desplegar la aplicación y seguir las instrucciones de instalación del Wiki del proyecto.

Google Web Toolkit, o donde Java se convierte en Ajax

   Desde siempre me ha gustado programar, especialmente en Java. Mi principal problema es que siempre me he centrado en el back office y nunca me he preocupado por las interfaces de usuario. Así, si en algún momento se me ocurría hacer alguna aplicación para algo en concreto, al final desistía porque no iba a ser capaz de hacer una interfaz de usuario decente.

   Hace unos meses que he descubierto Google Web Toolkit y me parece increíble. Para el que no lo conozca son unas librerías de Google para programar aplicaciones web 2.0 pero todo desde Java. Tanto el desarrollo como la depuración la hacemos desde Eclipse y cuando queremos desplegar nuestra aplicación lo que se hace automáticamente es convertir ese código Java a Javascript (Ajax). Además, tenemos la ventaja de que se crean automáticamente distintas versiones de la aplicación para los distintos navegadores y no nos tenemos que preocupar de esos pequeños hacks que siempre hay que hacer para que funcione en internet explorer, firefox, opera... Cuando nos conectamos a la web que hemos creado, ésta detecta automáticamente el navegador utilizado y nos sirve la web necesaria.

   La manera que recomiendo para comenzar con GWT es ir a la Developer's Guide y seguir paso a paso el tutorial que Google ha creado. Es todo muy intuitivo y fácil de seguir y se explica cómo crear una aplicación de ejemplo desde cero. Además se empieza con lo más básico y poco a poco se va añadiendo nueva funcionalidad.

   Yo le he cogido el gustillo y estoy desarrollando una aplicación web de la que hablaré en próximos posts.

Colaborando en un proyecto de Software Libre

   Así dicho, con el título del post parece que estoy colaborando en el desarrollo del kernel de Linux o algo similar. Nada más lejos de la realidad. A un amigo, Jose, le apetecía cacharrear un poco con las APIs de Google, y aprovechando que trabaja con Java, Spring, Hibernate y MySQL se hizo una pequeña aplicación Java para sincronizar sus contactos de Gmail (y toda su información asociada) a una base de datos local MySQL utilizando dicha tecnología. Además, decidió publicar el código en Google Code, en donde Google proporciona un SVN para subir el código, un Wiki e incluso un gestor de incidencias. El resultado lo podéis ver en la web del proyecto GDataUtils (así es como lo llamó). El proyecto está liberado con la GPLv3.

   Como sabe que a mi me gustan estas cosas y tenía ganas de que me enganchara, me contó en un par de horas cómo funciona Hibernate y Spring y cómo configurarlo para que yo pudiera comenzar la parte de la sincronización de Google Calendar (aprovechando que ya conocía un poco el API de Google Calendar).

   Para el que no lo conozca o haya programado en Java picándose a mano las queries contra la base de datos, utilizar Spring + Hibernate es simplemente magnífico. Todo son objetos y por ejemplo insertar en una tabla es crear un objeto que representa a esa tabla, hacer set() de los campos y salvar ese objeto. Automágicamente nuestro objeto se salva en la base de datos. Las búsquedas también son muy simples y si todo lo haces bien en el código java no verás ni una sola sentencia sql. Es realmente cómodo programar así, y aunque en un principio cuesta acostumbrarse y hay bastante fallos debido a la configuración de Spring y Hibernate, una vez que le coges el truco el desarrollo es muy rápido.

   Respecto al código, la parte de sincronización de los contactos (desde Google a la base de datos Local) la terminó Jose hace tiempo y funciona muy bien. Además se guarda un log con todas las modificaciones que se realizan por si es necesario volver atrás. Respecto a mi parte de la sincronización de los calendarios y eventos, está casi terminada aunque todavía sin log. El problema es que tengo este proyecto parado desde hace algún tiempo puesto que ahora estoy centrado en otro que os contaré en breve.

   Por supuesto la aplicación al estar programada en Java es multiplataforma. De hecho Jose programa desde Windows y yo desde Linux y ninguno de los dos hemos tenido problemas con el código del otro.

   Si alguno se anima a probarlo os doy los pasos que debéis seguir para configurar todo. El entorno de desarrollo, como no podía ser de otra forma es Eclipse, aunque recomiendo instalar EasyEclipse puesto que incluye un montón de plugins y configuraciones que nos harán la vida más fácil.

Instalar MySql 5: Desde linux es tan sencillo como hacer $ sudo apt-get install mysql-server-5.0 mysql-client-5.0.

Instalar ant: En EasyEclipse ya está incluído.

Crear en mysql un esquema que se llame gdata (o como queramos) y que esté vacío.

Configurar el repositorio SVN del proyecto y hacer el checkout. En la web del proyecto tenéis información sobre cómo configurar el repositorio. Además, podéis navegar por la estructura de directorios y archivos y ver los últimos cambios que se han hecho.

Editar el archivo config/hibernate.properties y cambiar los parámetros de la conexión a mysql.

Editar el archivo config/SpringConfiguration.xml y añadir el nombre de usuario (con @gmail.com) y password para poder acceder a la cuenta de Google. Esta información sólo se utiliza para conectarse a Google y obtener los contactos. No se almacena en ningún sitio y por supuesto nosotros no tenemos acceso a ella. De todas formas el código está ahí para que veáis lo que se hace con esa información. Ventajas de publicar el código :-P.

Ejecutar la tarea ant createSchema que se encarga de crear las tablas necesarias en la base de datos.

Ejecutar la tarea ant distrib: Creará el directorio target en el que se encuentra la aplicación ya compilada y lista para su ejecución.

En target/distrib ejecutar la tarea ant SyncFromGData.

Y listo, mirar la base de datos y examinar la copia de tus contactos.

   Dicho así, la verdad es que parece muy complicado (a mi me lo pareció la primera vez), pero luego, una vez que lo haces ves que es sencillo. Además, la mayoría de las tareas sólo es necesario ejecutarlas una vez. Puedes lanzar sucesivamente la sincronización puesto que comprueba si los datos ya se han descargado para no duplicarlos. Además, también actualiza los cambios que hagamos en los contactos.

   Si queréis ejecutar la sincronización de calendarios y eventos el proceso es similar (muchos pasos no hay que repetirlos) y sólo tendréis que cambiar la última tarea ant por la de GoogleCalendar.

   Aunque todo esto así parezca que no es útil y que no tiene mucho sentido, a mi me ha servido para conocer Spring y Hibernate, me ha abierto un mundo nuevo que desconocía y me he actualizado porque como he dicho alguna vez me quedé en Java 1.4.2 y hacía bastante que no programaba en serio.

   Lo realmente interesante de todo es que está realizado completamente con software libre: Google proporciona el SVN para el código, Spring, Hibernate, MySql, Eclipse... Todo es software libre. Además en mi caso, con Linux, hasta el sistema operativo. Lo único que quedaba era Java y hace ya algún tiempo que Sun lo liberó con licencia GPLv2.

   Si alguien se anima a desarrollar la sincronización de GoogleReader, GoogleNotebook,... lo que sea, que me lo diga y vemos cómo empezar.
¿Alguna duda?

Usando el API de Google Calendar: Alarmas por SMS

   Hace un tiempo descubrí Google Calendar, y aunque no lo utilizo mucho tiene una característica que me llamó la atención desde el principio. Una vez que defines una cita o evento, puedes asociarle un recordatorio para que te avise por email o con un pop-up si tienes la web abierta; hasta aquí ninguna novedad. Lo realmente novedoso es que también permite avisarte por medio de un SMS al móvil y además, en el caso de España es gratis. Sólo hay que asociar a nuestra cuenta de google nuestro número de teléfono móvil y después de una verificación de identidad podemos añadir el aviso por sms como recordatorio de las citas.

   Teniendo esto en mente pensé que sería realmente útil poder enviar alarmas al móvil con el estado de los servidores de casa. Así, si normalmente tenemos alguna tarea programada en crontab que nos avisa por email cuando termina mal, algún monitor de los servicios, espacio en los filesystems,... podríamos añadir una llamada a un programa adicional que introdujese un evento en nuestro calendario de google para que nos llegara el aviso por medio de un sms al móvil y así estar informados en todo momento del estado de nuestras máquinas :-).

   Pues dicho y hecho, me puse a buscar y lo que encontré no pudo ser mejor. Google proporciona un acceso completo a su API, con ejemplos, foros, y además disponible desde varios lenguajes de programación (Java, .Net, PHP y Python). De todos estos, el que más conozco y con el que más he trabajado (aunque ya haga tiempo que no lo toco demasiado) es Java. Además, tiene la ventaja de que al ser multiplataforma podría monitorizar también máquinas windows.

   Me instalé Eclipse y la máquina virtual de Sun 1.5 (ojo que esto es importante, no funciona con la 1.4.2) por medio de un simple apt-get. De la web de google descargué las librerías cliente para java y me puse a probar alguno de los ejemplos. La verdad es que el código es muy sencillo y está muy bien explicado. Hay ejemplos de autenticación, consulta de los eventos del calendario entre determinadas fechas, alta de eventos, borrado, actualización...

   Después de realizar un par de pruebas tenía un esqueleto que funcionaba aunque había que afinar. Examinando con más detalle las clases con Eclipse y con unas pocas pruebas posteriores terminé la versión 0.1 que permite insertar un evento en nuestro calendario y recibir un aviso por sms en 1 minuto. Aspectos a tener en cuenta del código:

Para conseguir que llegue el aviso dentro de un minuto lo que hago es poner la hora de comienzo del evento dentro de 6 minutos y la notificación por sms 5 minutos antes. Aunque por código es posible fijar el recordatorio dentro de 1 minuto, luego, cuando se envía la petición se nos muestra un error diciendo que no es válida.

Parece que la clase DateTime de Google no se lleva muy bien con la clase Date. Al principio creé un objeto con la hora actual para asignarselo al comienzo del evento, pero una vez asignado, la fecha que ponía era de dos horas antes!. Lo resolví creando un TimeZone para "Europe/Madrid" y utilizándolo en la creación de dicho objeto. Luego hablando con un compañero y comentándole esas 2 horas de diferencia (yo pensé que debería ser sólo una por eso de que estamos en zona GMT+1), me dijo que, con el cambio a horario de verano hemos pasado "automáticamente" a GMT+2. En fin, misterio aclarado. Gracias Jose!.

El programa recibe como parámetros el usuario, el password y el texto que queremos enviar. Aunque a priori no hay limitación en la longitud del texto, al móvil sólo nos llegarán los primeros 57 caracteres.

Después de construir la petición y enviarla, por la consola aparece un error. Según he investigado parece como si la versión que utilizo de las librerías de google fuera antigua, aunque realmente estoy trabajando con la última. En principio no afecta al funcionamiento, aunque queda un poco "feo".

Adicionalmente, es necesario descargar las librerías mail.jar del API JavaMail y activation.jar del Framework de Sun JavaBeansActivation.

   Y ya, sin más divagaciones, el código:

/*
 * Programa para el envío de alarmas por SMS al móvil por medio del API Google Calendar
 * 
 * Iván López Martín
 * http://lopezivan.blogspot.com
 * 
 */

import java.net.URL;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.TimeZone;

import com.google.gdata.client.calendar.CalendarService;
import com.google.gdata.data.DateTime;
import com.google.gdata.data.Person;
import com.google.gdata.data.PlainTextConstruct;
import com.google.gdata.data.extensions.EventEntry;
import com.google.gdata.data.extensions.Reminder;
import com.google.gdata.data.extensions.When;


public class EnviaSMS {

   public static void main(String[] args) {
      
      // Comprobamos los argumentos necesarios: usuario, password y texto del mensaje
      if (args.length < 3) {
         System.err.println("Uso: EnviaSMS <usuario> <password> <texto>");
         return;
      }

      String userName = args[0];
      String userPassword = args[1];
      String sms = "";
      // El máximo son 57 caracteres
      for(int i=2; i<args.length; i++) {
         sms = sms + args[i] + " ";   
      }
      sms = sms.trim();
         
      try {
         URL feedUrl = new URL("http://www.google.com/calendar/feeds/" + userName + "/private/full");
              
         CalendarService myService = new CalendarService("EnviaSMS");
              
         // Nos autenticamos en google Calendar
         myService.setUserCredentials(userName, userPassword);

         // Creamos el evento
         EventEntry myEntry = new EventEntry();
         myEntry.setTitle(new PlainTextConstruct(sms));

         Person author = new Person(userName, null, userName);
         myEntry.getAuthors().add(author);
           
         // Definimos la zona horaria
         TimeZone tz = TimeZone.getTimeZone("Europe/Madrid");

         Calendar cal = GregorianCalendar.getInstance();
         cal.add(Calendar.MINUTE, 6);
         DateTime startTime = new DateTime(cal.getTime(), tz); //6m
           
         cal.add(Calendar.MINUTE, 1);
         DateTime endTime = new DateTime(cal.getTime(), tz); //7m 
           
         // Definimos la hora de comienzo y de fin del evento         
         When eventTimes = new When();
         eventTimes.setStartTime(startTime);
         eventTimes.setEndTime(endTime);
         myEntry.addTime(eventTimes);
              
         // Añadimos el recordatorio sólo como SMS y que avise 5 minutos antes
         Reminder reminder = new Reminder();
         reminder.setMinutes(new Integer(5));
         reminder.setMethod(Reminder.Method.SMS);
         myEntry.getReminder().add(reminder);
   
         // Enviamos la petición para insertar el evento en el calendario
         EventEntry insertedEntry = (EventEntry)myService.insert(feedUrl, myEntry);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

   Para la ejecución desde la línea de comandos, he creado un pequeño script:

ivan@doraemon:~$ cat enviaSMS.sh 
#!/bin/sh
#################################
# Iván López Martín             #
# http://lopezivan.blogspot.com #
#################################
SMS_HOME=/home/ivan/workspace/GoogleCalendar

CLASSPATH=$SMS_HOME/lib/activation.jar:$SMS_HOME/lib/gdata-calendar-1.0.jar:$SMS_HOME/lib/gdata-client-1.0.jar:$SMS_HOME/lib/mail.jar:$SMS_HOME/bin

java -classpath $CLASSPATH EnviaSMS $@

ivan@doraemon:~$ ./enviaSMS.sh usuario@gmail.com password "Visita el blog de Iván López. http://lopezivan.blogspot.com"

   En nuestro calendario de google aparece el nuevo evento con las opciones que hemos indicado:

   Y un minuto después, en el móvil el sms:


   Como ya he dicho, se trata de la versión 0.1, aunque me parece que no la voy a modificar mucho más porque lo único que necesito es el envío de los sms. No voy a borrar los eventos del calendario, ni actulizarlos, ni consultarlos desde el programa,...

   Cualquiera es libre de modificar el código, usarlo y mejorarlo siempre que por favor respete el comentario del autor y el enlace a este blog. Además, si lo mejoras por favor házmelo saber para poder actulizar este artículo.

   Que lo disfrutéis...

Luchas de robots

El otro día descubrí por casualidad robocode. Se trata de un framework en Java para la creación de robots (agentes) que luchan entre sí. Los robots tienen movimientos básicos (ir hacia delante, hacia atrás), pueden girar el cañón a derecha e izquierda, disparar, reaccionar cuando reciben un disparo, cuando aciertan...
La programación de los robots en java es muy sencilla y se pueden ir probando poco a poco en el entorno gráfico que trae. Así podemos enfrentar nuestras creaciones a otros robots de ejemplo que se incluyen o descargar algunos de internet. Además, es muy fácil de configurar todo en un entorno de desarrollo como eclipse para programar de una forma más rápida y sencilla nuestros robots.
Existen multitud de páginas como esta en la que podemos encontrar información, algoritmos de movimiento, tácticas de búsqueda,...
Creo que es una buena forma de aprender/mejorar/practicar nuestros conocimientos de Java e incluso hacer pequeñas competiciones con los amigos.