Archivo por años: 2011

Cronopete 1.3.0

Acabo de lanzar una revisión de urgencia de Cronopete; se trata de la versión 1.3.0. Esta corrige un fallo que quedó bastante escondido: si intentamos usar un disco externo formateado en NTFS, Cronopete falla al detectarlo y se cierra. Esta nueva versión funciona correctamente, y muestra el cuadro de diálogo que permite formatear la unidad en ReiserFS o Ext4.

Como de costumbre, está disponible en la sección de programas de mi página web.

A disfrutarla.

Ubuntu 11.10 + Gnome 3 + Compiz = problemas

Así es: ayer actualicé a la última Ubuntu y los problemas empezaron casi inmediatamente. Después de cambiar a Gnome Clásico (como explicaba en la entrada anterior), lo primero que hice fue cambiar metacity por compiz, para disfrutar de animaciones y demás. Tras varias pruebas, la manera más directa que encontré fue lanzarlo «a mano», creando una entrada en los programas a lanzar en el inicio. Así, fui a Aplicaciones -> Otras -> Aplicaciones al inicio, escogí Añadir, y creé esta entrada:

El parámetro –replace (ojo, con dos guiones al principio) es el que hace que compiz mate a metacity y se ponga en su lugar.

Con esto parecía todo listo, pero surgió el problema de verdad: como ya comenté, se ha cambiado levemente la forma en que se añaden, modifican y eliminan los elementos a los paneles: antes bastaba con pulsar el botón derecho del ratón, pero ahora hay que pulsar ALT+Botón derecho. Por desgracia, Compiz se adueña por defecto de esa combinación de teclas, por lo que, con él activo, no podremos modificar los paneles.

Para solucionarlo hay que instalar el paquete compizconfig-settings-manager (que aparecerá en Aplicaciones -> Otras), ir a la opción Mover ventana, y cambiar la combinación Iniciar movimiento de ventana. Yo la puse a Super+Botón izquierdo.

La razón de que interfiera es que se utiliza la misma combinación de tecla para mover una ventana pulsando en cualquier parte de ella, y para mostrar el menú contextual de dicha ventana. Por eso, a pesar de que en la configuración aparece el botón izquierdo, afecta también al uso del botón derecho.

Cronopete 1.2.0

Acabo de lanzar la versión 1.2.0 de Cronopete. Los cambios son pequeñitos; de hecho, sólo hay uno importante: ahora, en los backups, las carpetas conservan su fecha de modificación (los archivos ya lo conservaban).

No es un cambio radical, ni una supercorrección, pero sí será interesante de cara a la versión 2.0.0, que incorporará la interfaz de recuperación de archivos. En ese caso, será más cómodo para el usuario si las carpetas también conservan las fechas correctas.

Como de costumbre, está disponible en la página de Cronopete.

Cronopete 1.1

Acabo de lanzar una nueva versión de Cronopete con algunos cambios menores. El principal es que ahora permite cambiar cada cuanto se hace una copia. Por defecto sigue en una hora (que es lo recomendable), pero se puede subir hasta doce horas. Otros cambios son, por ejemplo, que ahora el menú aparece debajo de la barra del panel de Gnome (como debe ser), y no encima; además, corrige una pequeña deriva de cinco minutos en el instante en que debería hacer la copia (por su culpa, en la versión 1.0 las copias se hacían cada 65 minutos).

Como de costumbre, se puede bajar en la página de cronopete.

El fracaso de Gnome-Shell y Unity (y como solucionarlo)

Llevo un mes aproximadamente probando Ubuntu 11.10, y la verdad es que no me gustan nada las interfaces que nos esperan en ella. Me refiero, como ya habréis supuesto, a Gnome-Shell y a Unity.

No niego que son muy bonitas y novedosas (especialmente Gnome-Shell). Tampoco niego el ingente trabajo que hay detrás. El problema, bajo mi punto de vista, es que les falta ergonomía.

Veamos a qué me refiero. Si en Gnome-Classic (el Gnome de toda la vida) quiero lanzar una aplicación que no tenga en un lanzador rápido, tengo que hacer estos movimientos con el ratón (parto de la mitad de la pantalla porque intento mostrar trayectorias promedio; la línea roja es el recorrido del ratón, y los puntos gordos representan cada click):

Rápido y directo.

Veamos ahora lo que hay que hacer en Gnome-Shell:

La cosa ya no es tan sencilla: no sólo hay que ir adelante y atrás por la pantalla, sino que hay que buscar de izquierda a derecha y de arriba a abajo entre los iconos, lo que es más lento que buscar únicamente de arriba a abajo en el menú de Gnome-Classic.

Finalmente, Unity:

Aquí se añade complejidad a mayores, porque demasiado a menudo hay que expandir los resultados (Ver X resultados más).

Los defensores de estos entornos probablemente dirán que es posible teclear parte del nombre de la aplicación, y ésta quedará seleccionada, pero eso no soluciona nada, porque obliga a levantar la mano del ratón, teclear, y volver a agarrarlo: pérdida de tiempo e incomodidad.

Además, en Gnome Shell tampoco disponemos de iconos en el escritorio, lo que también lía de mala manera a los que ya estamos acostumbrados a trabajar con un escritorio clásico. A fin de cuentas, el problema real es el cambio brutal en la forma de trabajar: el hombre es un animal de costumbres, por lo que si le cambias todo su entorno, no se siente cómodo.

Afortunadamente hay formas de resolverlo…

Cambiar a Gnome-Classic

Gnome3 incluye un port del escritorio clásico a GTK3, por lo que la solución más sencilla para mantener nuestro escritorio de toda la vida consiste en utilizar éste. Además, nos permite seguir utilizando Compiz.

Para cambiar a este entorno, primero tenemos que instalar los paquetes gnome-session-fallback y gnome-tweak-tool. Una vez hecho, salimos de la sesión y volvemos a entrar, escogiendo Gnome Classic como entorno:

Entramos en nuestra sesión y veremos el escritorio de toda la vida, pero sin iconos. Para resolverlo, arrancamos gnome-tweak-tool y marcamos las siguientes opciones:

La primera opción activa el escritorio con iconos, la segunda muestra el icono Equipo, la tercera la carpeta personal, y la quinta la papelera. A mayores se puede marcar la sexta, si te gusta que aparezcan las unidades montadas en el escritorio. Y con esto ya tenemos nuestro Gnome de toda la vida, con la única diferencia de que para activar el menú de las barras superiores e inferiores (el que nos permite añadir nuevos elementos, y moverlos) hay que mantener pulsada la tecla ALT a la vez (bueno, y que los elementos de éstas no se colocan donde uno los deje, sino alineados a la izquierda, centro o derecha, lo que es mucho más cómodo).

Adaptar Gnome Shell

La segunda opción consiste en adaptar Gnome Shell al estilo que queremos. Para ello, empezamos por instalar gnome-tweak-tool, y la usamos para activar las mismas opciones que en el caso anterior. Con ello ya tendremos de nuevo iconos en el escritorio.

Ahora llega la segunda parte, que consiste en instalar la extensión que incorpora un menú de aplicaciones a Gnome Shell. Por desgracia, a la hora de escribir este artículo todavía no conseguí hacerla funcionar, así que se agradece cualquier ayuda. Probablemente cuando Gnome Shell 3.2 sea ofical, sea más fácil (actualmente Ubuntu 11.10 incluye Gnome Shell 3.1, que es una versión en desarrollo).

Por supuesto, hay más extensiones que harán que Gnome Shell se parezca aún más a Gnome Clásico. Como siempre, todo es cuestión de ir probando.

Adaptar Unity

Para hacer lo mismo con Unity, basta con seguir las (algo liosas) instrucciones para instalar un menú de aplicaciones en Unity. Hasta ahí llego, porque la verdad es que me gusta tan poco que lo he usado una semana escasa.

Backup con manzana a las finas unidades externas

Hace unos años, Apple presentó Time Machine, un programa de copia de seguridad que, por fin, hacía no sólo sencillo, sino también divertido, hacer backups regulares de tus datos.

Pronto surgieron varios clones para Linux, tales como Flyback, Time Vault, o el cómodo Dejá Dup, pero ninguno me convencía, así que decidí hacer yo uno propio. Y ya puestos, decidí hacerlo lo más parecido posible al Time Machine original.

El resultado es Cronopete, un clon de Time Machine para Linux. El nombre lo tomé de El anacronópete, una novela de viajes en el tiempo escrita por Enrique Gaspar y Rimbaud ocho años antes de la célebre La máquina del tiempo, de H.G. Wells.

Al igual que el programa original, Cronopete hace una copia completa del disco cada hora, y conserva todas las copias que pueda para poder volver atrás si es necesario y recuperar un documento en cualquier momento de su historia.

Cada copia del árbol de directorios se conserva en una carpeta propia, cuyo nombre es la fecha y hora en que se realizó. También, al igual que el original, copia realmente sólo los archivos que han cambiado, y se limita a hacer un enlace a la copia anterior para aquellos archivos que no han cambiado, lo que permite acelerar el proceso y consumir muchísimo menos disco.

También para ahorrar espacio, las copias se guardan en una progresión exponencial: para las últimas 24 horas se guarda una por cada hora; para el último mes, una copia diaria; y después, una copia semanal hasta que se llena el disco.

También he copiado al milímetro la interfaz. Al lanzar Cronopete, éste aparece de esta manera en la barra de notificaciones, exactamente igual que Time Machine:

Icono principal de Cronopete

Y esta es la interfaz principal:

Interfaz de cronopete

Todavía no tiene la interfaz para restaurar los ficheros de manera «bonita», por lo que para hacerlo hay que ir al disco externo y copiarlos «a mano», aunque dado que los archivos están guardados «tal cual», sin ningún tipo de empaquetado ni compresión, esto no supone ninguna dificultad. Sin embargo, ya estoy investigando la biblioteca clutter para implementarla también.

Las primeras pruebas de Cronopete las había escrito en C, con la intención de usar Python para la interfaz, pero no lo acababa de ver porque necesitaba mucha fiabilidad para un programa de este tipo, así que al final decidí probar Vala. Y, como comenté en su momento, me enamoré: la gestión automática de memoria como en Python es una delicia, y encima tengo el rendimiento y el bajo consumo de recursos de C, además de azúcar sintáctico como para abastecer una pastelería durante un año.

Enlace directo a la página de descargas: Cronopete.

DBus en Vala

Actualizado Estoy trabajando en un nuevo proyecto, escrito íntegramente en Vala, y la verdad es que cuantas más cosas aprendo sobre él, más me gusta.

Lo último que descubrí fue como trabajar con DBus en Vala, y resulta que es extremadamente sencillo y elegante, aunque tuve que investigar bastante hasta encontrar como hacer algunas cosas, pues los ejemplos que vienen en la página tratan de como trabajar con un servidor hecho por uno mismo, cuando yo necesitaba acceder a un servicio del sistema.

Así pues, y sin más dilación, veamos como se puede usar DBus para obtener una lista de los discos duros conectados por USB al ordenador, y como formatearlos.

Lo primero que vemos es que toda esa información la gestiona el demonio UDisk, el cual exporta una serie de funciones y objetos a través de DBus para que cualquier programa pueda acceder a ellos. Si echamos un vistazo a la documentación de la API, vemos que se exporta el método EnumerateDevices, el cual nos devuelve un array de objetos.

¿Y como accedemos a este método del objeto UDisk desde Vala? Pues con este código:

[DBus (name = "org.freedesktop.UDisks")]
interface UDisk_if : GLib.Object {
    public abstract ObjectPath[] EnumerateDevices() throws IOError;
}

UDisk_if udisk = Bus.get_proxy_sync<UDisk_if> (BusType.SYSTEM, "org.freedesktop.UDisks","/org/freedesktop/UDisks");
var retval = udisk.EnumerateDevices();

Aquí vemos que primero definimos una interfaz con todos los métodos a los que vamos a querer acceder (en este caso sólo uno), sacando de la documentación los parámetros y demás, y le añadimos antes una cabecera con el nombre del objeto. Luego, creamos un proxy síncrono, conectándonos a través del bus del sistema (BusType.SYSTEM), al servidor UDisk (org.freedesktop.UDisks) y pedimos acceso al objeto deseado (/org/freedesktop/UDisks). Finalmente, llamamos al método deseado, almacenando el resultado en una nueva variable.

Es importante recalcar que cualquier método que se defina puede emitir, siempre, una excepción de tipo IOError, por lo que siempre se debe añadir al final de la definición la coletilla throws IOError. De no hacerlo se producirá un error de compilación. También comentar que dado que esta función sólo devuelve un parámetro, la he escrito en formato resultado metodo(parametros); sin embargo, también es perfectamente válida la sintaxis void metodo (parametros,…, out resultado). Esta segunda forma es obligatoria cuando un método devuelve más de un resultado. Con esa sintaxis, la interfaz tendría esta forma:

[DBus (name = "org.freedesktop.UDisks")]
interface UDisk_if : GLib.Object {
    public abstract void EnumerateDevices(out ObjectPath[] path) throws IOError;
}

En retval tenemos ahora un array de objetos ObjectPath, cada uno de tipo Device, representando una unidad extraíble. ¿Y ahora, qué? Pues ahora vamos a imprimir el punto de montaje de cada uno de ellos. Si miramos la documentación del objeto Device, vemos que dicha información se almacena como una propiedad, así que definimos nuestra interfaz así:

[DBus (name = "org.freedesktop.UDisks.Device")]
interface Device_if : GLib.Object {
    public abstract string IdLabel { owned get; }
    public abstract string[] DeviceMountPaths { owned get; }

    public abstract void FilesystemUnmount(string[] options) throws IOError;
    public abstract void FilesystemCreate(string type, string[] options) throws IOError;
    public abstract void PartitionModify (string type, string label, string[] options) throws IOError;
    public abstract void FilesystemMount(string type, string[] options, out string mount_path) throws IOError;
}

Ponemos { owned get; } en lugar de {owned get; set; } porque los campos son de sólo lectura. También he añadido los cuatro métodos necesarios para poder formatear una partición, aunque en el ejemplo no los voy a utilizar.

Ahora llega el momento del código que accede a los datos, que es éste:

Device_if device2;
foreach (ObjectPath o in retval) {
    device2 = Bus.get_proxy_sync<Device_if> (BusType.SYSTEM, "org.freedesktop.UDisks",o);
    GLib.stdout.printf("Disco %s montado en:n",device2.IdLabel);
    foreach (string s in device2.DeviceMountPaths) {
        GLib.stdout.printf("    %sn",s);
    }
}

Así, primero recorremos la lista de objetos que obtuvimos con la anterior llamada (en retval), y creamos un proxy síncrono para cada uno de ellos, contra el servidor de UDisk (él es quien nos dio la lista de objetos, por lo que estos tienen que estar en él). Luego imprimimos la etiqueta simplemente leyendo la propiedad del objeto, y por último imprimimos todos los puntos de montaje (una misma partición puede estar montada en varios sitios a la vez).

Actualización: Uno de los problemas que tuve fue que la llamada a FilesystemCreate (que formatea la unidad especificada) tarda varios segundos en ejecutarse, lo que hacía que la GUI se quedase colgada. La primera solución que encontré fue ejecutarla en un thread aparte, y usar espera activa para detectar cuando terminó, pero era muy poco elegante. La solución definitiva consiste en realizar llamadas asíncronas a DBus, explicadas en el tutorial de Vala. La idea consiste en añadir la palabra reservada async en la definición de la función en la clase, con lo que la llamada a DBus será no-bloqueante, y definir un callback anónimo.

[DBus (name = "org.freedesktop.UDisks.Device")]
interface Device_if : GLib.Object {
  [...]
  public abstract async void FilesystemCreate(string type, string[] options) throws IOError;
  [...]
}

  // Llamamos a la función, añadiéndo como último parámetro
  // una función anónima que se ejecutará al terminar la
  // ejecución
  device2.FilesystemCreate.begin(format,options, (obj,res) => {
    try {
      // La llamada a .end recoge los valores devueltos (de haberlos)
      // y dispara cualquier excepción que se haya producido
      device2.FilesystemCreate.end(res);
      return;
    } catch (IOError e) {
      // Captura de excepciones (en este caso, fallo durante el formateo)
    }
  });

Una vez que hemos hecho la llamada, podemos volver al bucle principal de GTK o llamar a la función run() de un cuadro de diálogo, y éste seguirá funcionando en paralelo a la ejecución de nuestra llamada a DBus.

Vuelve Devede

Hace hoy justo un año que lancé la última versión de Devede, así que he decidido que ya era hora de sacar una revisión con los cambios que hice en estos meses. No han sido muchos, pero sí muy necesarios, a la vista de las peticiones en la lista de correos. Además, llevaban una temporada esperando en el repositorio GIT de Devede, así que ya tocaba.

Los cambios, básicamente, se resumen en:

  • Corregido un bug en MKISOFS: en algunas versiones, utiliza una coma en lugar de un punto como separador decimal, lo que confundía a Devede. Ahora admite ambos símbolos.
  • Define la variable VIDEO_FORMAT: este cambio es necesario para las últimas versiones de SPUMUX, que exigen que el tipo de vídeo que se utiliza esté definido en dicha variable, y no sólo en el fichero XML.
  • Añadido workaround para las versiones recientes de Mencoder, mediante el uso de AC3_FIX: las últimas versiones de Mencoder tienen un fallo en la codificación AC3, por lo que es necesario activar esta opción.

Además, se ha creado una ventana de configuración (en Editar -> Configuracion) con parámetros más o menos «fijos», como donde meter los ficheros temporales y demás. De esta forma está todo más organizado.

Ahora, mi objetivo más inmediato es reemplazar Mencoder por FFmeg, para evitar de una vez por todas los cada vez mayores problemas que da este software.

Lanzado EasyWall

Acabo de lanzar un nuevo programa, llamado, en un alarde de originalidad, EasyWall. Como su propio nombre indica, se trata de un firewall que intenta ser lo más sencillo de usar posible. Para ello trae «de fábrica» varias plantillas para multitud de programas, con sus puertos predefinidos. La idea es que si instalas un programa (el aMule, por ejemplo), sólo tienes que ir a EasyWall y activar la casilla «aMule»; y listo.

Por supuesto, si simplemente fuese ésto no sería muy útil, porque muchos programas permiten cambiar sus puertos, además de que si mostramos todos los programas posibles, sería una lista interminable. Por eso, EasyWall incorpora una serie de capacidades extra:

  • Oculta las plantillas de programas que no están instalados. Para ello se puede definir una lista de ficheros en las plantillas, que hacen que si no existe ninguno de ellos, considera que dicho programa no está instalado y no muestra esa opción.
  • Permite definir qué puertos de una plantilla son modificables y cuales no. Así, si un programa tiene un puerto que siempre es fijo, y otro que es definible por el usuario, EasyWall permitirá modificar el segundo pero no el primero.
  • Permite definir un puerto en base a otro. Así, por ejemplo, en aMule, hay tres puertos configurables por el usuario, pero el tercero siempre es el primero más tres. EasyWall automatiza este tipo de casos, con lo que el usuario sólo tiene que configurar los dos puertos base, y el tercero se configurará automáticamente en base a los valores anteriores.
  • Permite automatizar también la carga de módulos para funcionalidades extra, como por ejemplo módulos necesarios para SMB/Samba, etc.
  • En caso de que no exista plantilla para algún programa concreto, el usuario puede definir sus propios rangos de puertos, para abrir y cerrar aquellos que necesite.

Las plantillas se definen con sencillos ficheros XML, por lo que es muy fácil añadir nuevos programas. Además, aunque el programa en en modo gráfico, incluye un par de funcionalidades en modo texto para permitir refrescar el firewall si se añaden o eliminan programas al sistema.

Por último, la funcionalidad se ha dividido en dos ficheros: easywall_core.py y easywall_gtk.py. El primero tiene toda la parte de bajo nivel, y el segundo es el front-end en GTK. Esta división se ha hecho así con vistas a que quien lo desee, pueda hacer fácilmente un front-end en Qt para KDE. Para ello sólo tiene que incluir el módulo easywall_core.py y utilizar sus clases y métodos para refrescar el firewall, añadir puertos, etc.

¡A disfrutarlo!