Día del Software Libre Guanajuato 16 Noviembre 2013

Hola a todos,

El próximo sábado 16 de Noviembre celebraremos el día del Software Libre en nuestro estado Guanajuato , la ciudad sede será en Irapuato, Gto.

sfd2

Estamos solicitando aun la participación de ponentes y así mismo de patrocinadores.

La entrada a nuestro evento es libre.

Nuestro sitio web es: http://diadelsoftwarelibre.com/wpress/16-de-noviembre-sfdgto-2013/

Registro de Asistentes: http://diadelsoftwarelibre.com/wpress/pre-registro/

Registro de Ponentes: http://diadelsoftwarelibre.com/wpress/abierto-el-call-4-papers/

Como llegar al evento: http://diadelsoftwarelibre.com/wpress/como-llegar-al-evento/

Wiki Oficial de nuestro evento: http://wiki.softwarefreedomday.org/2013/Mexico/Guanajuato/Comunidad-de-Software-Libre-Guanajuato

Email de contacto: sfdgto@gmail.com

Los esperamos !!!

Saludos

Firefox OS @ Linux Mint 13

Para poner en marcha Firefox OS  hay que hacer lo siguiente:

La gente de Mozilla recomienda usar una distribución de Linux con gcc 4.6 o Mac OS X (Mountain Lion) ya que distros con gcc 4.7 como Ubuntu 12.10 pudiesen ser incompatible al momento de compilar los fuentes de Firefox OS.

También necesitas un teléfono compatible o en caso de no contar con un teléfono compatible se puede usar un emulador (arm / x86) el cual vamos a construir para realizar nuestras pruebas con Firefox OS.

En el sitio de Mozilla se menciona que solo los dispositivos con Android 4 (aka Ice Cream Sandwich) están soportados.

Para Linux es necesario instalar los siguientes programas y para no compilar los fuentes y dependencias puedes usar un gestor de paquetes e instalar los programas rápido.

$ sudo apt-get install autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib git ia32-libs lib32ncurses5-dev lib32z1-dev libgl1-mesa-dev libx11-dev make

Necesitas instalar el programa Android Debug Bridge (ADB), instala el SDK de Android y posteriormente establece un par de variables de entorno como se muestra a continuación:

jacob@puerkita /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G $ cat /etc/profile.d/android.sh
 #!/bin/bash
export SDK_HOME=/home/jacob/Downloads/android/android-sdk-linux
 export ANDROID_TOOLS=$SDK_HOME/tools
 export PATH=$SDK_HOME/platform-tools:$ANDROID_TOOLS:$PATH

A continuación es necesario configurar ccache , ccache agiliza por ejemplo una re-compilación “cacheando” el resultado de previas compilaciones, los lenguajes soportados con C, C++, Objective C/C++

El valor por omisión para ccache es de 1GB , la compilación de Firefox OS satura muy rápido la cache de ccache , para dar un poco de mas espacio en disco usa el siguiente comando:

$ ccache --max-size 2GB

Ahora necesitamos obtener el codigo de FirefoxOS y para ello necesitamos clonar el repositorio de B2G usando Git.

$ git clone git://github.com/mozilla-b2g/B2G.git

Una vez terminado el proceso anterior debes cambiarte al directorio B2G

$ cd B2G

A continuación necesitamos saber con cual dispositivo se va instalar FirefoxOS o en el caso que solo quieras desarrollar pruebas puedes usar el emulador, en mi caso use un emulador para arm.

$ ./config.sh emulator

Las opciones de dispositivos soportados y emuladores es:

- galaxy-s2 – galaxy-nexus – nexus-s – nexus-s-4g – otoro – unagi – pandaboard – emulator – emulator-x86

Para compilar e instalar Firefox OS y una vez que te has situado en el directorio B2G , es escribir el siguiente comando:

./build.sh

Un punto interesante es que si tu computadora tiene mas de un core por procesador puedes aprovecharte de ello , por ejemplo para realizar el proceso de compilación de Firefox OS en paralelo puedes usar la siguiente opción, si tienes mas cores puedes usarlos, solo recuerda dejar algo de recursos para que tu puedas seguir trabajando mientras se compila Firefox OS ya que de lo contrario se puede quedar congelada tu computadora mientras el proceso termina.

./build.sh -j2

Dentro del directorio B2G hay un archivo de texto plano oculto el cual puedes editar para añadir opciones de compilación , por ejemplo si mueves hacia otra computadora o de directorio todo tu código de Firefox OS puedes indicar o también puedes establecer el numero de cores a usar , un punto interesante es que puedes definir que tipo de emulador vas a generar es decir basado en arm o x86, en mi caso DEVICE_NAME=emulator

$ cat .config
MAKE_FLAGS=-j2
GECKO_OBJDIR=/media/bsdfreedisk/all/Downloads/FirefoxOS/B2G/objdir-gecko
DEVICE_NAME=emulator
DEVICE=generic
LUNCH=full-eng

En lo que termina puedes ir a tomar una o mejor dicho varias tazas de café ;)

Una vez que ha terminado el proceso puedes iniciar el emulador y antes de eso solo mencionar que hay 2 clases de emuladores , el primero basado en arm y el segundo sobre X86 siendo este mas rápido que arm , se recomienda usar arm .

Para iniciar el emulador :

Verifica si está corriendo ADB (Android Debugger)
el adb que viene dentro de Firefox OS (b2g) está en la siguiente dirección:

$B2G/out/host/<platform>/bin (Linux)
$B2G/out/host/darwin-x86/bin (Mac OS X)

jacob@puerkita /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G $ ps aux | grep adb
jacob     9754  0.0  0.0  14104   920 pts/2    S+   19:07   0:00 grep --colour=auto adb

Iniciar ADB server:

jacob@puerkita /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G $ out/host/linux-x86/bin/adb start-server
* daemon not running. starting it now on port 5037 *
* daemon started successfully *

Comprobar que ADB está corriendo:

jacob@puerkita /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G $ ps aux | grep adb
jacob    11428  0.0  0.0  20016   660 pts/0    Sl   19:44   0:00 adb fork-server server

Por omisión solo 512 MB de memoria ram y partición de disco son usados para cambiar estos parámetros puedes editar el script “run-emulator.sh”, en mi caso establecí 1GB de ram y disco.

export PATH=$PATH:$TOOLS_PATH
${DBG_CMD} $EMULATOR \
   -kernel $KERNEL \
   -sysdir $B2G_HOME/out/target/product/$DEVICE/ \
   -data $B2G_HOME/out/target/product/$DEVICE/userdata.img \
   -memory 1024 \
   -partition-size 1024 \
   -skindir $B2G_HOME/development/tools/emulator/skins \
   -skin HVGA \
   -verbose \
   -gpu on \
   -qemu $TAIL_ARGS

recordar que es un imagen que corre en Qemu, para especificar un dns para que tu emulador pueda resolver dominios en internet puedes añadir las opciones dentro del mismo script como lo hice yo, por ejemplo:

if [ "$DEVICE" = "generic_x86" ]; then
    EMULATOR=$TOOLS_PATH/emulator-x86
    KERNEL=$B2G_HOME/prebuilts/qemu-kernel/x86/kernel-qemu
else
    EMULATOR=$TOOLS_PATH/emulator
    KERNEL=$B2G_HOME/prebuilts/qemu-kernel/arm/kernel-qemu-armv7
    TAIL_ARGS="$TAIL_ARGS -cpu cortex-a8 -dns-server 10.128.128.128"

A continuación puedes lanzar el emulador

./run-emulator.sh

Básicamente esto es lo que se está ejecutando a traves del script “run-emulator.sh”

jacob     7585 94.5 11.6 1771812 434480 pts/1  Rl+  18:15  36:50 /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G/out/host/linux-x86/bin/emulator64-arm -kernel /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G/prebuilts/qemu-kernel/arm/kernel-qemu-armv7 -sysdir /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G/out/target/product/generic/ -data /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G/out/target/product/generic/userdata.img -memory 512 -partition-size 512 -skindir /media/bsdfreedisk/all/Downloads/FirefoxOS/B2G/development/tools/emulator/skins -skin HVGA -verbose -gpu on -qemu -cpu cortex-a8

Algunas capturas de pantalla:

Las personas y sus contraseñas (I)

Solo comparto una nota que escribí en el sitio de Hacking México , la idea es compartir los conocimientos con todos los demás a quien le pueda ser útil.

Las contraseñas son claves que nos permiten obtener y controlar el acceso a los sistemas y sus recursos. Si algún atacante consigue obtener estás claves puede tomar acciones con consecuencias, quizá, graves.

Las contraseñas deben ser tratadas como tu cepillo de dientes es decir debe usarse con frecuencia, no debe compartirse y debe cambiarse regularmente.

¿Cómo seleccionar contraseñas?

Deberá ser lo mas extensa posible, al menos 14 caracteres y no menos de 8 caracteres.

Es conveniente la combinación de letras, números y símbolos , cuanto más diversos sean los tipos de caracteres puede ser más difícil adivinar la contraseña.

Por ejemplo podrías definir una contraseña en base a una frase que se te ocurra como el siguiente ejemplo:

"Linus Torvalds el creador del Kernel de Linux en los 90s"

Nuestra posible contraseña puede ser:

"LTecdKLel90s"

¿Cómo administro las contraseñas?

Es muy común que las personas guarden sus contraseñas en una hoja de papel de cuaderno viejo, un archivo de texto, debajo del teclado es decir en lugares obvios, es importante señalar que puede ser sencillo encontrar estos elementos y dar con las contraseñas.

Para administrar las contraseñas y no dejar por todos lados nuestras claves a tajo y destajo podemos hacer uso de algunas aplicaciones de software diseñadas para este fin, vamos a mencionar un par de programas que nos permitan almacenar una gran cantidad de contraseñas.

KeePassX (http://www.keepassx.org/)

KeePassX está disponible para Linux , Windows y Mac OS X.

Tenemos 2 métodos para conseguir que funcione KeePassX en nuestra computadora con Ubuntu/Mint Linux

La manera mas sencilla es usar el manejador de paquetes Synaptic o bien desde el Centro de Descargas de Software de Ubuntu Linux.

Una vez instalado, desde el dash de Ubuntu Linux lo ejecutamos como se muestra en la siguiente imagen:

Los detalles de como añadir las contraseñas se dejan como ejercicio para el lector y/o para una segunda nota.

Otro método es instalar mediante la compilación del código fuente

A continuación vamos a compilar el código fuente en una distribución Linux como Ubuntu/Linux Mint y es necesario hacer lo siguiente:

0. Descargar el codigo fuente de la pagina oficial de KeePassX

1. Descomprimir el código fuente.

$ tar -xzvf keepassx-0.4.3.tar.gz

2. Leer los archivos de texto que especifican los pasos a seguir para la correcta instalación de nuestra aplicación , vamos a necesitar qmake para Qt4 y para instalarlos en Ubuntu/Mint hacemos lo siguiente:

Primero realizamos una búsqueda para encontrar qmake

$ sudo apt-cache search qmake

Los resultados que arroja la búsqueda es:

qt4-qmake - Qt 4 qmake Makefile generator tool
qconf - Nice configure script for your qmake-based project

Ahora solo instalamos el paquete “qmake” a través de apt-get

$ sudo apt-get install qt4-qmake

Una vez instalado , especificamos donde queremos instalar nuestra aplicación una vez que consigamos compilarla , pero antes debemos instalar ciertas dependencias de software:

$ sudo apt-get install libqt4-dev-bin
$ sudo apt-get install libqt4-dev

Compilar nuestro código :

$ qmake-qt4 PREFIX=/usr/local
Project MESSAGE: See 'INSTALL' for configuration options.
Project MESSAGE: Install Prefix: /usr/local
Project MESSAGE: *** Makefile successfully generated.
Project MESSAGE: *** Start make now.
$ sudo make install

Una vez compilado KeePassX puedes ejecutarlo de la misma manera como lo comente en el método de instalación anterior.

Lunes , Octubre 1 2012

Un día como cualquier otro , el fin de semana la pase al frente de la computadora compilando un par de programas tratando de corregir errores ,algunos los corregí otros quedaron peor , eso me dice que debo leer, leer y entender más código fuente..al paso de las horas no llegue a nada y para mitigar mi decepción salí a tomar aire al mismo tiempo que recordé que el carro estaba sucio , no tenia la mas mínima intención de personalmente lavarlo, ¿ resultado ? , lo lleve a lavar y no quedo tan mal.

Hoy en el trabajo pendientes aquí y allá ..compilar y configurar Samba en el cluster de computo , hacer pruebas enviando datos desde un instrumento de secuenciación Illumina MiSeq , en la bitácora del trabajo anteriormente ya había documentado un esquema muy general pero al parecer todo marcho como se supone debe funcionar, más tarde me avisaron que Galaxy estaba fallando …demonios !! es error con Python y Sqlite3.

 

 

Nginx upload module

pues nada que Facebook tiene la culpa pues cada ves menos uso el blog para escribir…en fin.

En días pasados estuve trabajando con Galaxy para análisis de datos etc y etc, si bien es cierto que para usar Galaxy en modo “pro” , por así llamarlo, es necesario configurar e instalar una serie de dependencias por ejemplo PostgreSql, un servidor ProFtpd para usuarios virtuales, un servidor web y proxy como Nginx..etc y etc, sin embargo un problema que sucede es que al compilar Nginx, mi ejemplo:

./configure –prefix=/usr –with-http_ssl_module –with-http_perl_module –conf-path=/etc/nginx/nginx.conf –error-log-path=/var/log/nginx/nginx_error.log –pid-path=/var/run/nginx/nginx.pid –lock-path=/var/lock/nginx/ –http-log-path=/var/log/nginx/nginx_access.log –add-module=/home/jacob/Downloads/bio/galaxy/nginx_upload_module-2.2.0 ; make

al compilar Nginx con el modulo para “uploads” en Linux Mint 13 hay un error y el error no es mas que el uso de una variable “sin uso” ya que gcc está tratando todos los warnings como error, la solución es muy sencilla , yo escogería alguna de estás opciones que seguro no son las únicas..

  1. Eliminas la variable.
  2. Editas el archivo “Makefile” y eliminas “-Werror”  al menos para la parte donde compila el fuente en cuestión.
  3. Inicializas a un valor nulo o en una sentencia haces uso de la variable , verifica con calma lo que sucede en el codigo fuente y listo.

La opción #1 no la recomiendo mucho puede que en alguna otra parte del código de Nginx haga referencia y te lleves sorpresas, cuestión de revisar.

El error:

/home/jacob/Downloads/bio/galaxy/nginx_upload_module-2.2.0/ngx_http_upload_module.c:1681:18: error: variable ‘result’ set but not used [-Werror=unused-but-set-variable]

¿ un parche ? hice uno pero no tiene ningún sentido , pierdes menos tiempo en editar el fuente o el archivo Makefile.

easyRAE iniciando..

Nada ,ahora que nuestra comunidad Mono Hispano ha regresado …

Hace varios años desarrolle una aplicación, para el escritorio de Linux, que permite consultar el diccionario de la Rea Academia Española  , también hay una versión que empece a probar para jugar un poco con el iPhone 3G/Monotouch al menos con el emulador.

La aplicación genera una base de conocimiento de tal manera que los usuarios interesados pudiesen buscar y encontrar el significado, localmente en su computadora , de alguna palabra muy rápido.

La ultima versión permite al usuario generar, exportar e importar una base de conocimiento (BC) la cual el usuario estará generando dinamicamente al momento de consultar al diccionario de la Real Academia Española. El usuario se encargara de subir  su base de conocimiento en un servidor a través de a aplicación easyRAE, algo parecido a MonoDoc, la base de conocimiento se actualizara cada que el usuario decida subir sus actualizaciones y estará disponible para su descarga como archivo compreso y permitirá alimentar a la aplicación easyRAE de mas usuarios.

Básicamente como se muestra en la figura anterior, 5 consultas generan un total de 90KB de consultas descargadas, 1000 consultas generan 17.57 M sin compresión. Una base de conocimiento, con compresión, de 1000 consultas, da un total de 1.9 M

En la versión 0.2 era posible usar easyRAE por linea de comandos

* opciones para la linea de comandos:

- – word : consulta la base de datos de la Real Academia Española.

- – disable-ui : deshabilita la interfaz GtkSharp

- – help : muestra la ayuda.

Ejemplo de uso:

$easyRAE  – – word estilo  – – disable-ui

Esto permite consultar la palabra estilo en el diccionario de la RAE