Los procedimientos descritos a continuación permiten realizar la actualización de versiones menores en los sistemas operativos basados en Scientific Linux en sus versiones 5.x y 6.x, es decir, pasar de la 5.1 a la 5.3 por ejemplo mas no para pasar de la versión 5 a la 6.

Recuerde tener suficiente espacio en /var/cache para realizar este procedimiento así como contar con copias de seguridad en caso de que algo salga mal.  Realice los siguientes pasos bajo su propia responsabilidad.

Serie 5.x

# yum remove perl.i386 gaim.i386 gaim-devel.i386
# yum clean all
# rpm -Uvh ftp://ftp.scientificlinux.org/linux/scientific/5x/i386/misc/RPMS/yum-conf-latest.SL.noarch.rpm
# yum update yum
# yum update
# yum clean all
# /sbin/reboot

• El paso #1 solamente se debe realizar bajo la arquitectura de 64 bits para remover versiones instaladas de 32 bits de estos paquetes.

Serie 6.x

# yum clean all
# yum update
# yum --releasever=6x update
# yum-conf-sl-other
# yum update
# yum clean all
# /sbin/reboot

• En el paso #3 reemplazar el valor 6x por la versión a la cual desea realizarse la instalación (6.2 por ejemplo).
• El paso #4 sólo es estrictamente necesario cuando la versión original del sistema operativo que se está actualizando es la 6.0.

Enlaces

• How To Upgrade To The Latest S.L. 5.x Release
  http://www.scientificlinux.org/documentation/howto/upgrade.5x
• How To Upgrade To The Latest S.L. 6.x Release
  http://www.scientificlinux.org/documentation/howto/upgrade.6x

Frecuentemente me encuentro con compañeros de la universidad experimentando en los servidores del nodo grid, en estos casos es común que nos distribuyamos entre diferentes computadores pero a pesar de esto sea conveniente compartir una única terminal para que todos podamos ver lo que se está experimentando y que cada uno pueda proponer e implementar sus ideas.

Para hacer esto la solución mas simple que he encontrado es utilizando el comando screen que se incluye por defecto en la mayoría de las distribuciones de Linux.

El procedimiento descrito a continuación es útil cuando todos los usuarios acceden finalmente a la terminal compartida utilizando el mismo usuario en el mismo servidor, en caso contrario es necesario realizar unas modificaciones adicionales.

Procedimiento

El usuario que va a crear la terminal compartida ejecuta el siguiente comando para iniciar la sesión de screen y nombrarla (mySharedSession en este caso).

$ screen -d -m -S mySharedSession

El siguiente paso radica en unir la terminal del usuario a la sesión compartida de screen mediante la ejecución del siguiente comando que debe ser ejecutado por todos los usuarios incluyendo al creador de la sesión ya que esta se crea inicialmente separada de su terminal actual.

$ screen -x mySharedSession

En cualquier momento es posible listar las sesiones de screen disponibles mediante la ejecución del siguiente comando.

$ screen -ls

Salir y terminar sesiones

Para salir de una sesión compartida sin destruírla es necesario ejecutar la siguiente combinación de teclas: CTRL+a d.

Para salir de una sesión destruyéndola se puede utilizar el comando exit (cierre brusco) o la combinación de teclas CTRL+a k (cierre limpio) la cual es equivalente a CTRL+a :kill.  Debe tener en cuenta que la destrucción de la sesión afecta a todos los usuarios que se encontraban conectados a ella.

Enlaces

• GNU Screen
  http://www.gnu.org/software/screen/

Una vez instalado Git y configurado para GitHub es posible empezar a crear proyectos que sean monitoreados por este software de control de versiones.

Para cada proyecto se crea un repositorio donde se almacenarán las versiones de sus archivos y las ramas que se creen con ellos.

A continuación se describirán los pasos necesarios para crear un nuevo repositorio.

Crear el repositorio en GitHub

Para crear un nuevo repositorio en GitHub se debe ingresar con la información de la cuenta del usuario que será su propietario, acceder al enlace Create a new repository e ingresar la siguiente información.

Crear un nuevo repositorio en GitHub

Crear el directorio del proyecto

Si todavía no existe un directorio para el proyecto en el sistema de archivos del equipo del desarrollador, este se debe crear en la ubicación que la se requiera.

$ mkdir /ruta/al/proyecto123
$ cd /ruta/al/proyecto123

Esta nueva ubicación se debe activar para ser monitoreada por Git de la siguiente manera.

$ git init

Agregar una descripción ampliada del proyecto

Este paso es opcional pero se recomienda hacerlo.  Es posible agregar un archivo README al proyecto cuyo contenido se mostrará junto con la descripción del proyecto en GitHub.

$ vi README

Como este archivo es nuevo debe agregarse al registro de Git.

$ git add README

De ser necesario es posible agregar en un solo paso a todos los archivos ubicados en un directorio específico.

$ git add .

Una vez agregado y registrado el archivo es necesario hacer commit de esas modificaciones.

$ git commit -m 'First commit'

Enviar las modificaciones a GitHub

Debe tenerse en cuenta que el commit realizado en el paso anterior se realiza en la base de versiones local.  Para publicar estas modificaciones en el proyecto en GitHub es necesario sincronizarlo con el repositorio remoto de la siguiente manera.

Primero es necesario asociar el repositorio local con el remoto.

$ git remote add origin git@github.com:USERNAME/PROYECTO.git

Reemplazar las palabras USERNAME y PROYECTO con el nombre de usuario GitHub de quien va a publicar y el nombre del proyecto respectivamente.

Finalmente se realiza la sincronización con el repositorio remoto.

$ git push -u origin master

Consultar la página del repositorio en GitHub

Al consultar la página del repositorio en GitHub se deberá ver el listado de archivos sincronizados y el texto de la descripción ampliada (archivo README) especificado.  Para consultar este sitio se deberá acceder al URL con la siguiente estructura.

https://github.com/USERNAME/PROYECTO

Enlaces

• Create a Repo en GitHub Help
  http://help.github.com/create-a-repo/

La carga dinámica de clases es una característica muy conocida de los lenguajes orientados a objetos que permite crear instancias de clases con solo conocer su nombre.  Esto permite a los desarrolladores crear aplicaciones que utilicen clases que sean creadas después de la aplicación sin necesidad de recompilar la misma.  También es muy útil cuando se desea generalizar la creación de un conjunto de objetos mediante el patrón de fábrica.

Gracias a la reflexión en Java y otros lenguajes como C# es muy fácil de implementar, sin embargo en Processing (derivado de Java) su implementación fue un poco mas elaborada ya que las clases que implementa el usuario son en realidad clases internas del proyecto desarrollado.

Explicación

En Processing cuando se crea un Proyecto y en él se implementan las clases A, B y C, y este se compila, internamente se crea un archivo de código fuente Java conteniendo a este código de la siguiente manera.

import processing.core.*;
// Imports del usuario
// Otros imports
public class Proyecto extends PApplet {
    class A
    {
        // ...
    }
    class B
    {
        // ...
    }
    class C
    {
        // ...
    }
    static public void main(String args[]) {
        PApplet.main(new String[] { "--bgcolor=#DFDFDF", "Proyecto" });
    }
}

Implementación

Para realizar la implementación de una versión simple del patrón de fábrica utilizando la carga dinámica de clases en Processing se supondrá que existe la clase Padre de la cual se derivan las clases Hijo1 e Hijo2 del proyecto Demostracion.

Crear un objeto donde se almacenará la instancia a crearse de manera dinámica.

Padre instance = null;

Recuperar la referencia al cargador de clases del sistema.

ClassLoader classLoader = ClassLoader.getSystemClassLoader();

Cargar la referencia de la clase a partir de su nombre (className), en este caso podría ser Hijo1 o Hijo2.  Recuerde que esta clase es realmente interna a la clase Demostracion.

Class loadedClass = classLoader.loadClass("Demostracion$" + className);

Obtener una referencia al constructor que se desea utilizar para crear la instancia.  En este caso se eligió un constructor que recibe dos parámetros: una cadena y un real.  Nótese además que todos los constructores reciben una referencia al applet de Processing, en este caso de Demostracion (que hereda a su vez de PApplet).

java.lang.reflect.Constructor constructor = loadedClass.getConstructor(new Class[] {PApplet.class, String.class, float.class});

Crear la nueva instancia utilizando el constructor obtenido en el paso anterior.  Al método newInstance se le especifican los valores de los parámetros que serán suplidos en el constructor.

instance = (Padre) constructor.newInstance(new Object[] {applet, str, flt});

Nótese como el primero de ellos, applet, hace referencia al applet de Processing que se está ejecutando.  Al no encontrar una forma mas elegante para obtener esta referencia al applet, declarar una variable global para almacenarlo.

PApplet applet;

Y obtener su valor en el procedimiento setup.

void setup()
{
    // ...
    applet = this;
    // ...
}

En el código mostrado anteriormente se deberán manejar las excepciones ClassNotFoundException y ClassCastException para poder llevar a feliz término su ejecución.

Enlaces

• Nested classes en The Java Tutorials
  http://docs.oracle.com/javase/tutorial/java/javaOO/nested.html
• Documentación de la clase PApplet de Processing
  http://processing.googlecode.com/svn/trunk/processing/build/javadoc/core/processing/core/PApplet.html
• Reflection & inner classes
  http://www.jroller.com/tomdz/entry/reflection_inner_classes
• Dynamic Class Loading and Reloading in Java
  http://tutorials.jenkov.com/java-reflection/dynamic-class-loading-reloading.html

En algunos casos es necesario iniciar una máquina virtual ya instalada desde el CDROM o en su defecto, una imagen ISO.  Por ejemplo cuando se deben realizar labores de administración o recuperación que requieran acceder al disco duro de la máquina virtual desmontado.

A continuación se muestra el procedimiento necesario para reconfigurar la máquina virtual para que monte una imagen ISO como su CDROM virtual e inicie el sistema operativo desde ella.

Procedimiento

Acceder a la consola de administración de las máquinas virtuales.

$ virsh --connect qemu:///system

Modificar la configuración de la máquina virtual (SL_57_x64_Generic en este caso) en dos partes.

virsh # edit SL_57_x64_Generic

Bajo domain/os agregue un nuevo registro boot para el cdrom.

 <boot dev='cdrom'/>

Identificar la configuración del CDROM bajo domain/devices/disk.  En mi caso se ve de la siguiente manera.

<disk type='block' device='cdrom'>
    <driver name='qemu' type='raw'/>
    <target dev='hdc' bus='ide'/>
    <readonly/>
    <address type='drive' controller='0' bus='1' unit='0'/>
</disk>

Modificar la configuración del CDROM para que se asocie con la imagen ISO deseada especificándole el valor de su respectivo source.

<source file='/b1/ISO/data_disk1.iso'/>

Una vez terminadas las labores de administración es necesario regresar la configuración a la original para evitar que la máquina continúe iniciándose desde el CDROM indefinidamente.

Modificar el contenido del CDROM (cambiar disco)

Otra tarea frecuente con respecto al manejo de medios en las máquinas virtuales será la manipulación del contenido de la unidad de CDROM.  Esto es necesario al realizar la instalación del sistema operativo o acceder información de diferentes medios/imágenes ISO.  Para hacer esto desde la linea de comando es necesario ejecutar el siguiente comando.

$ virsh attach-disk --type cdrom --mode readonly SL_57_x64_Generic /b1/ISO/data_disk2.iso hdc

Desde la versión 9.10 de Ubuntu no había actualizado el proceso de instalación de KVM y de la interfaz de red en puente que realizo en mi servidor de desarrollo.  En este caso estoy utilizando la versión 11.10 y a continuación describo el procedimiento seguido para instalar KVM utilizando el metapaquete del repositorio estándar, crear la interfaz de red e instalar una máquina virtual inicial.

Instalación de KVM con Libvirt

$ sudo aptitude install ubuntu-virt-server

Es necesario que los usuarios que vayan a interactuar con las máquinas virtuales pertenezcan al grupo de libvirtd.  En el caso de la instalación es necesario que el usuario actual termine su sesión y la inicie nuevamente para que su suscripción al grupo sea tenida en cuenta.

Creación del puente en la interfaz de red

Asignar los permisos de manipulación de red requeridos al usuario que se encontrará activo durante la creación del puente.

$ sudo setcap cap_net_admin=ei /usr/bin/qemu-system-x86_64

Agregar el nombre de usuario elegido frente a la propiedad cap_net_admin.

$ sudo vi /etc/security/capability.conf
    cap_net_admin        USUARIO

Actualizar la configuración de las interfaces de red.

$ sudo vi /etc/network/interfaces
    auto lo
    iface lo inet loopback
    auto eth0
    iface eth0 inet manual
    auto br0
    iface br0 inet static
    address 192.168.1.250
    network 192.168.1.0
    netmask 255.255.255.0
    broadcast 192.168.1.255
    gateway 192.168.1.254
    bridge_ports eth0
    bridge_stp off
    bridge_fd 0
    bridge_maxwait 0

Reiniciar el servicio de red para que los cambios anteriores sean tenidos en cuenta.

$ sudo /etc/init.d/networking restart

Creación de una máquina virtual desde línea de comando

En el servidor instalar la herramienta de virt-install para la creación de máquinas virtuales desde la línea de comando.

$ sudo aptitude install virtinst

Solicitar la creación de la máquina virtual a partir de su configuración básica.

En este caso se va a instalar un Scientific Linux 5.7 llamada SL_57_x64_Generic con 384MB de RAM, un disco duro de 7GB y utilizará la interfaz de red en puente creada anteriormente.

$ virt-install \
    --connect qemu:///system \
    -n SL_57_x64_Generic \
    -r 384 \
    --os-type linux \
    --os-variant generic26 \
    --hvm \
    --cdrom /b1/ISO/SL.57.090911.DVD.x86_64.disc1.iso \
    --network bridge:br0 \
    --disk path=/home/vms/SL_57_x64_Generic.img,size=7 \
    --vnc --noautoconsole \
    --accelerate

Desde el cliente donde se deseen administrar las máquinas virtuales ejecutar el siguiente comando para conectarse a la máquina virtual recién creada para realizar el proceso de instalación.

$ virt-viewer -c qemu+ssh://SERVIDOR/system SL_57_x64_Generic

Enlaces

• KVM en Ubuntu Documentation
  https://help.ubuntu.com/community/KVM

GitHub es un servicio de hospedaje de proyectos basado en web incluye funciones de red social como feeds, seguidores y estadísticas como clasificaciones.  Este sistema se basa en el software de control de versiones llamado Git.

El servicio se ofrece de manera gratuita para los proyectos de código abierto y bajo un costo mensual para los proyectos privados.

Una vez se ha creado la cuenta del usuario en GitHub este debe instalar y configurar Git para que se pueda interactúar de manera con los repositorios de los proyectos que se crearán en él.

Para hacer esto se deben realizar las siguientes actividades que se describen a continuación.

Procedimiento

Instalar Git

$ sudo aptitude install git

Crear la pareja de llaves SSH

En este paso se debe decidir si se va a utilizar una combinación de llaves existente o si se creará una nueva como se describe a continuación.

$ cd ~/.ssh
$ ssh-keygen -t rsa -C "correo@electronico.com"

Recuerde especificar un contraseña (passphrase) segura a su llave privada, de esta forma evitará que pueda ser utilizada de manera maliciosa si pierde el control sobre el archivo.

Registrar la llave pública a GitHub

Ingrese al sitio web de GitHub con la información de su cuenta de usuario y seleccione en el menú de Account Settings la opción SSH Keys y presione el botón Add SSH key.

Especifique un nombre (Title) para la llave SSH y copie/pegue el contenido del archivo ~/.ssh/id_rsa.pub (o el que haya especificado) en el área Key.

Verificar la configuración de la llave pública en GitHub

Desde una terminal en el equipo de desarrollo ejecutar el siguiente comando.

$ ssh -T git@github.com

Si la llave ha sido correctamente establecida se deberá recibir un mensaje como el siguiente.

Hi username! You've successfully authenticated, but GitHub does not provide shell access.

Configurar el nombre de usuario y el correo electrónico

En este paso se establecen localmente el nombre de usuario (de GitHub) y el correo electrónico del desarrollador para relacionarlo con los commits que haga a los diferentes proyectos del repositorio.

$ git config --global user.name "Nombre Completo"
$ git config --global user.email "correo@electronico.com"

Configurar el token de GitHub

Este token (secreto) se utiliza como medida de seguridad para autenticar las herramientas que no utilicen SSH y que deseen acceder a GitHub en nombre del usuario.

Para determinar el valor del token del usuario, seleccione en el menú de Account Settings la opción Account Settings y copie el valor mostrado frente al texto Your API token is.

Finalmente ejecute las siguientes instrucciones en una terminal teniendo en cuenta que username deberá corresponder con el nombre de usuario elegido en GitHub y reemplazar el TOKEN con el obtenido anteriormente desde el sitio web de GitHub.

$ git config --global github.user username
$ git config --global github.token TOKEN

Importante, debe tener en cuenta que cada vez que modifique la contraseña del usuario de GitHub se generará un nuevo valor del token.

Enlaces

• Set Up Git
  http://help.github.com/linux-set-up-git/

Cloud9 es un ambiente integrado para el desarrollo de software diseñado específicamente para ser ejecutado en la nube.  Este trae consigo múltiples características muy interesantes, incluyendo el soporte para diferentes lenguajes de programación como C/C++, C#, CSS, Java, Javascript, Lua, PHP, Python, Ruby, SQL y HTML entre otros mas.

Este software ha sido desarrollado en Node.js el cual es también su plataforma objetivo para el desarrollo de proyectos.  Cloud9 pueden ser accedido desde dos diferentes perspectivas: como un servicio en el cual el usuario se inscribe en la página (gratuitamente o con un pago) y accede remotamente al servicio.  La otra perspectiva corresponde con instalar este software en un servidor propio y acceder a él de manera privada.

Cloud9 IDE running on Firefox

A continuación se describirán los pasos seguidos para la instalación de Cloud9 IDE en un GNU/Linux Ubuntu 12.04.

Instalación

Se decidió instalar el software asociado bajo la carpeta ~/local del usuario que utilizará al ambiente de desarrollo.

Requerimientos

$ sudo apt-get install -y build-essential g++ curl libssl-dev apache2-utils git libxml2-dev

Ajustes iniciales

Crear la ruta donde se instalarán los diferentes paquetes de software necesarios.

$ mkdir ~/local

Agregar la ruta de los paquetes binarios al PATH.

$ echo 'export PATH=$HOME/local/bin:$PATH' >> ~/.bashrc
$ . ~/.bashrc

Instalación de Node.js

Verificar cual es la versión mas reciente del software, en este caso era la 0.6.14.

$ cd ~/local
$ git clone git://github.com/joyent/node.git
$ cd node
$ git checkout v0.6.14
$ ./configure --prefix=~/local
$ make
$ make install
$ cd ..

Instalación de npm (Node Package Manager)

$ curl http://npmjs.org/install.sh | sh

Instalación de Cloud9 IDE

$ git clone git://github.com/ajaxorg/cloud9.git
$ cd cloud9
$ git checkout devel
$ git submodule update --init --recursive
$ cd ..

Instalación del framework de componentes O3

$ git clone http://github.com/ajaxorg/o3
$ cd o3
$ ./tools/node_modules_build
$ cp ./build/Release/o3.node ../cloud9/support/jsdav/support/node-o3-xml-v4/lib/o3-xml/
$ cd ..

Ejecutar el IDE

Para lanzar el ambiente de desarrollo es necesario ejecutar el siguiente comando.  Debe tenerse en cuenta que si no se especifica un puerto su valor por defecto será de 3000 y si no se especifica un lugar de trabajo se utilizará el directorio actual donde fue ejecutado el comando.

$ ~/local/cloud9/bin/cloud9.sh --port 3000 --workspace ~/proyectos/xxx

Otro aspecto a tenerse en cuenta es que se deberá crear una instancia del IDE por cada proyecto ya que estos se trabajan de manera independiente.

Enlaces

• Sitio web de Cloud9 IDE
  http://c9.io/
• GitHub del proyecto Cloud9 IDE
  https://github.com/ajaxorg/cloud9
• HOWTO: Install Cloud9 IDE locally
  http://ubuntuforums.org/showthread.php?t=1813076
• Node Package Manager
  http://npmjs.org/
• Instalación de Cloud9 IDE mediante nvm (versiones no muy actualizadas)
  http://gratdevel.blogspot.com/2011/03/easier-way-of-setting-up-cloud9-on.html

El servicio de DNS (Domain Name System) se encarga de traducir los nombres de los dominios de los requerimientos a sus correspondientes direcciones IP para poder ser físicamente localizados y consultados.  Este procedimiento toma unos cuantos milisegundos los cuales a lo largo del día pueden significar cantidades significativas de tiempo.  En casos como este o de problemas específicos es conveniente algunas veces utilizar el servicio de servidores DNS diferentes a los provistos por el ISP.

A continuación se muestra una lista de los servidores DNS gratuitos y públicos que he recopilado.

Servidores DNS

1. Google
   8.8.8.8
   8.8.4.4
2. Google (IPV6)
   2001:4860:4860::8888
   2001:4860:4860::8844
3. OpenDNS
   208.67.222.222
   208.67.220.220
4. Norton DNS
   198.153.192.1
   198.153.194.1
5. OpenNIC
   69.164.208.50
   216.87.84.211
6. Level3
   209.244.0.3
   209.244.0.4
7. DNS Advantage
   156.154.70.1
   156.154.71.1
8. ScrubIT3
   67.138.54.120
   207.225.209.77
9. Public-Root5
   199.5.157.131
   208.71.35.137
10. Comodo Secure
    8.26.56.26
    8.20.247.20

Movement detection with Flob

En la búsqueda de como detectar movimiento en las imágenes recibidas de una cámara web utilizando un sketch de Processing para ser utilizado como medio para la interacción entre el usuario y el computador, he iniciado el día de hoy algunas pruebas con la librería Flob que facilita este proceso.

Hasta el momento se ha utilizado la característica para calcular la imagen de movimiento y la facilidad para determinar las áreas de movimiento (blobs) agrupándolas según su cercanía.

El sketch de demostración se desarrolló utilizando Processing 2 (alpha 4) por lo que se descargó la versión de desarrollo de la librería.

Enlaces

• Demostración
  http://blog.jorgeivanmeza.com/wp-content/uploads/2012/03/Flob_Demo.zip
• flob // multi blob tracker for processing
  http://s373.net/code/flob/flob.html