Últimas noticias

A continuación dejo un pequeño ejemplo de como se pueden capturar señales con Python:

import signal
import time
import sys

def signal_handler(sig, func=None):
    print 'SignalHandler. Saliendo...'
    sys.exit(0)

if __name__=='__main__':
    signal.signal(signal.SIGTERM, signal_handler)

    print 'Esperando 15 segundos...'
    time.sleep(15)
    print 'Finalizado'

La idea es muy simple, el programa espera 15 segundos y finaliza. Si se envía la señal SIGTERM (señal 15) el proceso terminará sin esperar. Veamos como se ejecuta de forma normal:

$ python test.py 
Esperando 15 segundos...
Finalizado

Y aquí podemos ver cómo se capturan las señales y se finaliza antes el proceso:

$ python test.py &
[1] 8172
Esperando 15 segundos...
$ kill -15 8172
SignalHandler. Saliendo...
[1]+  Hecho                   python test.py
$

Hoy me he encontrado con el siguiente problema, necesito montar dos interfaces virtuales sobre una tarjeta Wifi Atheros. Una de estas interfaces debe estar en modo Station (en modo cliente, como suelen funcionar las tarjetas en los portátiles) y otra en modo Ad-Hoc.

Para ello tengo instalado madwifi y funcionando perfectamente. Tras mucho pelear, me he dado cuenta que es importante el orden de creación de las interfaces virtuales. Madwifi sólo permite una interfaz en modo Station sobre una tarjeta física, y una vez creada una, ya no se permite crear más y nos encontramos con el siguiente error:

# wlanconfig ath create wlandev wifi0 wlanmode adhoc
wlanconfig: ioctl: Input/Output error

Por tanto, si vamos a crear un VAP es necesario dejar la Station para la última.

Hace unos días conseguí una placa de evaluación LPC1343 de NXP, descargué LPCXpresso y todo iba bien. Tras trabajar algunos días con ella, me he encontrado el siguiente error al intentar flashear:

Error launching Debug\blinky.axf
02:Failed on connect: Ee(07). Bad ACK returned from status - wire error.

En esta última versión de Ubuntu, 11.10, por defecto trae instalado LightDM. Por defecto viene activa la cuenta de invitado, y a veces no es deseable. Para deshabilitarla es necesario editar el fichero /etc/lightdm/lightdm.conf y añadirle el parámetro allow-guest=false.

Iba a instalar Bacula en Ubuntu y me he encontrado con que intenta instalar todas las dependecias de MySQL (cerca de 30MB). Cómo estoy utilizando PostgreSQL, no necesito instalar todas estas dependencias. Para ello:

# apt-get install bacula-common-pgsql bacula-director-pgsql bacula-server bacula

Gitosis es básicamente una herramienta que nos permite gestionar los accesos a repositorios Git. Esto lo realiza a través de SSH, gestionando el fichero authorized_keys del usuario gitosis.

Instalación

Para su instalación, bastará con ejecutar lo siguiente:

$ sudo apt-get install git-core gitosis

dependiendo de la versión de Ubuntu/Debian disponible, el paquete que contiene Git se puede llamar git o git-core.

Una vez instalado, vamos a dar acceso al administrador. Para ello, supongamos un usuario con permisos de administración llamado user.

$ sudo -H -u gitosis gitosis-init < /home/user/.ssh/id_user.pub
Initialized empty Git repository in /srv/gitosis/repositories/gitosis-admin.git/
Reinitialized existing Git repository in /srv/gitosis/repositories/gitosis-admin.git/

Ahora, desde el cliente, vamos a probar la conexión SSH:

$ ssh gitosis@miservidor.com

Si todo ha ido bien, tenemos el acceso al servidor, así que ya podemos cerrar la conexión SSH.

Añadir repositorios y usuarios

Lo primer es clonar el repositorio de administración. A través de él podremos controlar los repositorios y los usuarios de forma simple y sencilla.

$ git clone gitosis@miservidor.com:gitosis-admin.git
Cloning into gitosis-admin...
remote: Counting objects: 5, done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 5 (delta 0), reused 5 (delta 0)
Receiving objects: 100% (5/5), done.

Aquí tenemos disponibles dos elementos claves:

• gitosis.conf: Fichero de configuración
• keydir: directorio con las claves públicas de los usuarios que tienen acceso

Vamos a crear otro repositorio nuevo llamado miproyecto, para ello editamos gitosis.conf:

[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = user

[group miproyecto]
writable = miproyecto
members = user member1 member2

Y añadimos las claves de los usuarios member1 y member2:

$ cd gitosis-admin
$ cp ~/member1.pub keydir/
$ cp ~/member2.pub keydir/

Ahora vamos a subir los cambios al servidor:

$ git add keydir gitosis.conf
$ git commit -m 'miproyecto con member1 y member2'
$ git push

Creando nuevos repositorios

Hasta ahora, hemos indicado a gitosis que habrá un nuevo repositorio y los usuarios que tienen acceso a él. Ahora vamos realmente a crear el repositorio. Todo esto se hace desde el lado del cliente:

$ git init miproyecto.git
Initialized empty Git repository in /home/member1/miproyecto.git/.git/
$ cd miproyecto.git/
$ git remote add origin gitosis@miservidor.com:miproyecto.git

Si tratamos de subir los cambios al servidor, nos indicará que el repositorio está vacío.

$ git push origin master
Initialized empty Git repository in /srv/gitosis/repositories/miproyecto.git/
error: src refspec master does not match any.
error: failed to push some refs to 'gitosis@miservidor.com:miproyecto.git'

Así que vamos a crear algo de contenido:

$ echo "" > README
$ git add README
$ git commit
[master (root-commit) 0dcec56] Initial commit
 1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 README
$ git push origin master
Initialized empty Git repository in /srv/gitosis/repositories/miproyecto.git/
Counting objects: 3, done.
Writing objects: 100% (3/3), 215 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To gitosis@miservidor.com:miproyecto.git
 * [new branch]      master -> master

Y con esto todo listo :)

Ahora vamos a ver como podemos acceder a una base de datos SQLite a través de JDBC. Para ello, voy a hacer uso de del driver JDBCSQlite, así que lo primero que vamos a hacer es descargarlo:

$ wget -c http://files.zentus.com/sqlitejdbc/sqlitejdbc-v056.jar

Después podemos hacer uso del siguiente código de ejemplo para ver que todo funciona:

import java.sql.* ;

class SQLiteJDBCTest {
    private static String DATABASE = "base_de_datos.db";
    private static String TABLE = "TablaDeLaBaseDeDatos";

    public static void main(String args[]) {
        try {
            // Load the database driver
            Class.forName("org.sqlite.JDBC");

            // Get a connection to the database
            Connection conn = DriverManager.getConnection("jdbc:sqlite:" + DATABASE);

            // Print all warnings
            for(SQLWarning warn = conn.getWarnings(); warn != null; warn = warn.getNextWarning()) {
                System.out.println("SQL Warning:");
                System.out.println("State: " + warn.getSQLState());
                System.out.println("Message: " + warn.getMessage());
                System.out.println("Error: " + warn.getErrorCode());
            }

            // Get a statement from the connection
            Statement stmt = conn.createStatement() ;

            // Execute the query
            ResultSet rs = stmt.executeQuery("SELECT * FROM " + TABLE);

            // Close the result set, statement and the connection
            rs.close();
            stmt.close();
            conn.close();
        }
        catch(SQLException se) {
            System.err.println("SQL Exception:");

            // Loop through the SQL Exceptions
            while(se != null) {
                System.err.println("State: " + se.getSQLState());
                System.err.println("Message: " + se.getMessage());
                System.err.println("Error: " + se.getErrorCode());

                se = se.getNextException();
            }
        }
        catch(Exception e) {
            System.err.println(e.toString());
        }
    }
}

Lo único que habrá que modificar son las variables de clase DATABASE y TABLE. Una vez hecho esto, bastará con compilar y ejecutar para asegurarnos que todo funciona:

$ javac SQLiteJDBCTest.java
$ java SQLiteJDBCTest 
java.lang.ClassNotFoundException: org.sqlite.JDBC

Es importante recordar, que para que esto funcione debemos añadir el driver que descargamos al principio al classpath:

$ java -cp .:sqlitejdbc-v056.jar SQLiteJDBCTest

Mondrian es un servidor OLAP software libre escrito en Java. Mondrian permite a los usuarios de negocio analizar grandes cantidades de datos en tiempo real. Los usuarios exploran los datos de negocio mediante la extracción y tabulación cruzada de información, mediante consultas analíticas complejas.

Además está preparado para ser desplegado en servidores de aplicaciones (en concreto he usado Tomcat), ya que está incluido un archivo WAR.

La idea es bastante sencilla. Partimos de un path como entrada en uno de los parámetros en un ShellScript y necesitamos saber el último componente. Por ejemplo:

Entrada: /un/path/cualquiera
Valor que buscamos: cualquiera

Una posible solución es ésta:

#!/bin/bash

if [ $# -ne 1 ]
then
    echo "Usage: $0 path"
    exit -1
fi

path=$1
path_base=${path%/*}
name=${path##*/}

if [ $path_base = $name ]
then
    path_base=`pwd`
fi

echo "$path_base/$name"

Actualización (5/11/11):

Otra opción para los que no se quieran complicar la vida me la envía @dvelezyx vía Twitter:

basename `pwd`

Esta mañana contaba cómo extraer el esquema y datos de un archivo MS Access y ahora voy a poner un pequeño script que nos permita volcar todo el contenido directamente en una base de datos SQLite:

#!/bin/bash
MDB=fichero_access.mdb
DB=fichero_sqlite.db
TMPFILE=tmp.sql

echo "Extracting the schema"
mdb-schema $MDB > $TMPFILE
sed -e "s/^DROP TABLE\(.*\);/DROP TABLE IF EXISTS\1;/" -e "s/DateTime (.*)/DateTime/" $TMPFILE > schema.sql
echo "Creating SQLite DB"
sqlite3 $DB < schema.sql

echo "Extracting tables"
tables=`mdb-tables $MDB`
echo ""

for table in $tables
do
	echo "Table: $table"
	mdb-export -I -S $MDB $table > $TMPFILE
	echo "PRAGMA journal_mode = MEMORY;" > table_$table.sql
	sed -e "s/\(.*\)/\1;/" $TMPFILE >> table_$table.sql

	sqlite3 $DB < table_$table.sql
done

rm -f $TMPFILE

Hoy me he encontrado con un fichero .mdb del que necesito la información que contiene. Tengo que hacer uso, tanto de la estructura como las tuplas de información que contiene cada una de las tablas.

Tras un rato de buscar, he encontrado MDB Tools. Éstas son un conjunto de herramientas que nos permiten trabajar con estos archivos desde la línea de comandos. Así que he hecho este pequeño scrpit:

#!/bin/bash
DATABASE=archivo_access.mdb
mdb-schema $DATABASE > schema.sql
tables=`mdb-tables $DATABASE`

for table in $tables
do
    mdb-export -I -S $DATABASE $table > table_$table.sql
done

Estos días estamos empezando con Git en la empresa y estamos haciendo pruebecitas con repositorios y trabajo con varios usuarios. Cada uno está trabajando en un lenguaje distinto y en un sistema operativo distinto, por lo que es necesario excluir todos los ficheros compilados, para evitar que el tamaño del repositorio crezca desmesuradamente.

Para ello podemos crear un fichero .gitignore en la raíz del proyecto que tenga las reglas de los ficheros a excluir:

#
# Fuentes compiladas
#
*.class
*.dll
*.exe
*.[oa]
*.so
*.pyc

#
# Ficheros generados por el SO
#
.DS_Store?
ehthumbs.db
Thumbs.db

Este fichero deberemos añadirlo al repositorio:

$ git add .gitignore
$ git commit -m "Git ignore"
$ git push

Esto no borra los ficheros que previamente estén dentro del proyecto, aunque coincidan con las reglas para excluirlos. Es necesario eliminarlos de forma manual:

$ git rm --cached *.pyc

Además de esto, cada repositorio local puede tener reglas particulares. Estas habrá que añadirlas al fichero .git/info/exclude.

Estos días en el trabajo estoy desarrollando unos WebServices, y para testearlos he utilizado SoapUI, pero me he encontrado con el siguiente error:

linux soapui error Exception in thread "XpcMessageLoop" java.lang.RuntimeException: 
java.io.FileNotFoundException: Library libgthread-2.0 not found at any known locations !

Para solucionarlo, basta con editar el fichero soapui.sh y descomentar la siguiente línea:

JAVA_OPTS="$JAVA_OPTS -Dsoapui.jxbrowser.disable=true"

La idea es muy sencilla: estamos desarrollando una aplicación en Java con NetBeans y hacemos uso de una o varias bibliotecas JAR externas, pero cuando generamos el archivo .jar de nuestro proyecto, dentro del directorio dist se crea un directorio llamado lib que contiene una copia de las bibliotecas. La intención es generar un único fichero .jar con todo el contenido.

Para ello vamos a modificar el fichero build.xml que contiene las reglas de compilación para Ant. Desde el directorio de nuestro proyecto, editamos el fichero nbproject/build-impl.xml. Aquí buscamos la sección -post-jar:

<target name="-post-jar">
    <!-- Empty placeholder for easier customization. -->
    <!-- You can override this target in the ../build.xml file. -->
</target>

Y la substituiremos por una como la siguiente:

<target name="-post-jar">
    <jar jarfile="dist/miproyecto-dist.jar">
        <zipfileset src="${dist.jar}" excludes="META-INF/*" />
        <zipfileset src="lib/mibiblioteca.jar" excludes="META-INF/*" />
        <manifest>
            <attribute name="Main-Class" value="es.menudoproblema.miproyecto.Main"/>
        </manifest>
    </jar>
</target>

Dónde:

• <jar jarfile="dist/miproyecto-dist.jar"> - Indica que vamos a crear un fichero .jar nuevo
• <zipfileset src="lib/mibiblioteca.jar" ... /> - Indica la biblioteca en cuestión, y podemos añadir tantos como librerías usemos
• <attribute name="Main-Class" value="es.menudoproblema.miproyecto.Main"/> - Indica la clase principal

Estos días estoy trabajando en la documentación del proyecto de fin de carrera con pdflatex y me he encontrado con lo siguiente:

! LaTeX Error: Cannot determine size of graphic in imagen (no BoundingBox).
! LaTeX Error: File `imagen' not found.

Esto hace referencia a la siguiente línea:

\includegraphics[scale=0.5]{imagen}

Para solucionar esto basta con indicar las extensiones que estamos utilizando:

\DeclareGraphicsExtensions{.png,.jpg}