Latest entries

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}

Programando en una tarea asíncrona, AsyncTask, me he encontrado con el siguiente error:

Can't create handler inside thread that has not called Looper.prepare()

La solución es muy sencilla:

public class MiAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        Looper.prepare();
        ...
    }
}

Acabo de terminar un script realizado en Python que comprueba actualizaciones de seguridad para Ubuntu Server y en caso de que tener instalado algún paquete, se enviará un mail a la dirección de correo indicada. Este script está pensado principalmente para administradores de sistemas, que como yo, no están dedicados a esta tarea y no disponen de mucho tiempo.

El equipo de Ubuntu utiliza un RSS para publicar las actualizaciones de seguridad, http://www.ubuntu.com/usn/rss.xml. Así que el script se conecta, parsea las entradas del RSS, selecciona los paquetes que son específicos para la versión de Ubuntu instalada, se comprueba si el paquete está instalado y se envía un mail con el listado de paquetes.

Una vez que tenemos OpenWRT instalado en nuestro router llega el momento de habilitar IPv6. Para ello, vamos a utilizar Stateless auto configuration. Para ello necesitaremos hacer uso de IPv4. Aunque todo esto se puede configurar desde LuCI (la interfaz web de administración que usa OpenWRT), usaremos SSH por comodidad.

Hasta ahora, durante el reinado de IPv4, estamos acostumbrados a utilizar DHCP para la configuración de la dirección IP de nuestros equipos. Es rara la situación en la que no haya un servidor DHCP (usalmente en el router) y sea necesario configurar la IP de forma manual.

IPv6 ofrece un mecanismo nuevo: Stateless auto configuration o configuración automática sin estado. De esta forma, los propios dispositivos generan su propia dirección IP.

Tengo en casa un par de routers Comtrend CT-5361 que regalaban antiguamente compañías como Telefónica o Jazztel. Llevo ya unos meses trasteando con IPv6 y me he decidido a montar una red local. Para ello voy a utilizar este router:

Ya que el firmware que traen estos dispositivos no trae soporte para IPv6, he decidido instalar OpenWRT. OpenWRT es una distribución de Linux enfocada a routers.