martes, 31 de julio de 2012

Utilizando SOCKS por Consola

Tengo conexión SSH con un servidor que está en una red a la que no tengo acceso desde casa. Entonces, para ver recursos Web en esa red, generalmente me valgo de un Proxy SOCKS 5 con SSH y configuro mi navegador. Hago algo como:

$ ssh -D 1234 usuario@servidor

Y después en mi navegador configuro el Proxy SOCKS5 (host: localhost, port: 1234). Con eso puedo navegar sin ningún problema por todos los recursos a los que no tengo acceso desde casa, porque son parte de la red privada. Inicialmente utilizaba un tunel SSH-Forward típico, pero era una pesadilla, del tipo:
$ ssh -L 1234:localhost:1234 usuario@servidor
usuario@servidor$ ssh -L 1234:localhost:80 usuario@servidor-web

Y para acceder al recurso introducía en mi navegador URLs del tipo: http://esedominioquenoveo:1234

Luego, el método de SSH Forwarding lo seguía utilizando hasta hoy para conectarme a otros servicios, no visibles desde el navegador, como por ejemplo MySQL.
De qué va este artículo en realidad, que hoy descubrí tsocks... Si instalas tsocks basta con ejecutar:
$ sudo aptitude install tsocks

Modificar las siguientes últimas líneas del archivo /etc/tsocks.conf:
server = 127.0.0.1
# Server type defaults to 4 so we need to specify it as 5 for this one
server_type = 5
# The port defaults to 1080 but I've stated it here for clarity 
server_port = 1234

Y luego...
$ ssh -ND 1234 usuario@servidor &
$ tsocks mysql -u usuario -h IP_REMOTA bd

Fíjense que ya no necesito cambiar la IP, porque tsocks resuelve el "problema". NOTA: El usuario debe tener acceso a la BD en la IP_REMOTA desde la IP de servidor.

lunes, 23 de julio de 2012

Aplicaciones web con Node.js

Node.js me tiene impresionado. Es realmente poderoso el enfoque de la plataforma, todo lo que se puede y podría lograr con ella.

Creo que herramientas como esta, simples y poderosas, terminarán por desplazar muchas vacas sagradas, o al menos quitarán cuotas importantes de mercado. He estado investigando quiénes están detrás de la plataforma, o al menos utilizándola, y resulta increíble la cantidad de empresas importantes, entre ellas Yahoo! y Linkedin.

Claro, y es que no hace falta darle demasiadas vueltas a la plataforma para darse cuenta de lo poderoso que puede resultar algo que interpreta el lenguaje de programación más ejecutado (cuentan todos los navegadores del mundo!) y levanta servidores http o tcp con tal facileza.

En lo que vi la plataforma pensé en una sóla cosa: computación distribuida. Pequeños servidores instanciándose en computadores bajo demanda, sin mayores complicaciones, ofreciendo servicios REST y a la vez aplicaciones web que los consumen, bien programados, sin perder de vista buenas prácticas y patrones, bases de datos replicadas, ¿NoSQL?, etc, etc...

A raíz de todas estas ideas y reflexiones, decidí comenzar un proyecto que espero sirva de guía a programadores que se hagan las mismas preguntas que yo. Si bien la plataforma es brutal y tiene un gran presente y futuro, veo que quedan muchas cosas abiertas.

En mi espacio de github conseguirán el proyecto. Aquí el enlace directo. Si alguno se entusiasma y quiere echarle un ojo al proyecto, le recomiendo leer la wiki que iré actualizando. Espero ir haciendo entradas en el blog en español, pero por razones de difusión mantendré el proyecto en inglés.

El proyecto aborda conceptos típicos en aplicaciones de medio tamaño, como: i18n, MVC, DAO, SOA, REST, testing (xUnit style) y documentation (Javadoc style).

domingo, 20 de mayo de 2012

sábado, 12 de mayo de 2012

Extracción de Requerimientos

Este es un artículo que publiqué en el blog de 21redES que mantengo con unos panas... Extracción de Requerimientos

jueves, 19 de enero de 2012

Algunos tips para gestionar mercurial-server

Agregando usuarios

Para agregar usuarios a una instalación de mercurial-server, basta con agregar la clave pública de la máquina -desde donde se conectará el usuario- al repo hgadmin.

Para generar la clave pública puede ejecutar los siguientes comandos:
$ ssh-keygen -t rsa
$ cat ~/.ssh/id_rsa.pub

Obtenida la clave pública del usuario, deberá pegarla dentro de la carpeta keys/users/ o keys/root/ del repo hgadmin, dependiendo de si quiere que el nuevo usuario sea "ordinario" o "admin", respectivamente. Los admin pueden hacer clone del repo hgadmin (modificar usuarios).

IMPORTANTE: Recuerde que la manera de modificar el repo hgadmin es clonarlo, modificarlo y empujar (push) los cambios al repo principal. NO MODIFIQUE DIRECTAMENTE SOBRE EL SERVIDOR!. Puede seguir los siguientes pasos:
$ mkdir hgadmin-tmp && cd hgadmin-tmp
$ hg clone ~hg/repos/hgadmin .
$ mkdir keys/users/newuser
$ cp ~/newuserkey keys/users/newuser
$ hg add *
$ hg ci -m "Added newuser to repo"
$ hg push

En el momento en que empuje los cambios al repo se agregará automáticamente la nueva clave pública al archivo ~hg/.ssh/authorized_keys, verifíquelo.

Creando un repositorio remoto para compartir entre diferentes usuarios

Debe crear el proyecto en el servidor y luego clonarlo en la máquina donde desee modificar el repositorio. Para ello puede ejecutar los siguientes comandos:

Del lado del servidor
$ cd ~hg/repos/
$ mkdir newrepo && cd newrepo
$ hg init 
$ cd ..
$ chown -R hg.hg newrepo

IMPORTANTE: Dar todos los permisos al usuario dueño del proceso "mercurial-server", en este ejemplo: hg

Del lado del cliente
$ mkdir newrepo && cd newrepo
$ hg clone ssh://hg@hg.mydomain.com/repos/newrepo .

Listo, nuevo repo creado y preparado para ser utilizado!


lunes, 5 de diciembre de 2011

Servicios REST con Jersey y Ajax

Esta semana estuve de cursos en Indra Ciudad Real, por cierto, un grupo majísimo/panísima.

Hicimos un ejercicio de servicios REST con Java, Jersey, e invocación de estos con Ajax (una parte Prototype y otra jQuery) que no podía dejar pasar por alto. Utilizamos Eclipse como IDE, Derby como RDBMS y Glassfish como Servidor de Aplicaciones.

Les dejo los pasos en este artículo. El código completo lo pueden conseguir aquí.

Implementamos un CRUD para una entidad llamada Persona. Aquí les dejo la estructura de la BD.

El código incluye tres partes y de esa forma espero abordar este artículo, a saber: DAO, Servicio REST e Interfaz Gráfica de Usuario (GUI).

El DAO

Realmente aquí no hubo demasiada sofisticación, como el curso iba de Web 2.0, hicimos el menor énfasis en acceso a datos. Les dejo el pequeño DAO que hicimos para trabajar con la BD.

La interfaz, pensando en el uso futuro de IoC, la pueden conseguir aquí.

La clase concreta, aquí.

Si se fijan, la interfaz la implementamos siguiendo el estándar de nombrado de C# que me parece más fácil de seguir, es decir, agregamos una "I" al inicio de la interfaz. El resto es la implementación de la clase concreta. En caso de utilizar IoC, por ejemplo con Spring, la inicialización y destrucción de la conexión en el constructor y método finalize debería desaparecer. De hecho, como está ahora no me gusta mucho, pero lo hice de esta forma para mantener el código lo más simple posible.

La clase Persona es simplemente un POJO con todos los campos de la entidad: id, nombre y apellido. El código aquí.

El Servicio REST

El servicio REST lo implementamos con Jersey, que facilita bastante el código.

Para configurar Jersey se debe agregar como filtro en el Descriptor de Despliegue (web.xml), por supuesto después de haber descargado los JAR (en el proyecto dentro de WEB-INF/lib). Clic aquí para ver el web.xml.

Una vez configurado Jersey, implementamos la API, el código aquí. Cosas importantes que destacar:
  • Los métodos de consulta (GET) producen JSON.
  • Los métodos de modificación (PUT, POST y DELETE) producen HTML, success y error.
  • El método POST está implementado para hacer POST y DELETE por restricciones impuestas por la librería Prototype (ver aquí), para peticiones diferentes de GET y POST; ésta hace peticiones POST especificando el método en la petición a través del parámetro _method. Se puede modificar la librería para no hacer esto, pero me parece más robusto y escalable hacerlo del lado del servicio REST.
  • Para que pudiesen "convivir" Prototype y jQuery se tuvo que activar el modo de no conflictos de jQuery, ver aquí.

La API se puede probar utilizando cURL. A continuación los comandos de prueba que utilizamos, que además ayudan a describir el funcionamiento de los servicios:
$ echo "GET todos"; curl -X GET -H "Content-type:text/json" -v http://localhost:8080/TiendaVirtual/rest/persona
$ echo "GET uno"; curl -X GET -H "Content-type:text/json" -v http://localhost:8080/TiendaVirtual/rest/persona/1
$ echo "PUT"; curl -X PUT -H "Content-type:application/x-www-form-urlencoded" -d "nombre=Cambiar" -d 
"apellido=Apellido" -v http://localhost:8080/TiendaVirtual/rest/persona
$ echo "POST"; curl -X POST -H "Content-type:application/x-www-form-urlencoded" -d "id=1" -d "nombre=Cambiar" -d "apellido=Apellido" -v http://localhost:8080/TiendaVirtual/rest/persona
$ echo "DELETE"; curl -X DELETE -H "Content-type:application/x-www-form-urlencoded" -d "id=1" -v http://localhost:8080/TiendaVirtual/rest/persona

La GUI

La GUI la hicimos en HTML puro y utiliza una librería JS que separa las llamadas Ajax de la lógica de presentación.

El HTML lo pueden conseguir aqúi y la librería de utilidades (donde se manejan los eventos Ajax, con Prototype y jQuery) aquí. Cosas importantes que destacar:
  • Las llamadas de listar son síncronas, por lo que su manejo es diferente al del resto.
  • Las llamadas de modificación (agregar, modificar, eliminar) son asíncronas y funcionan con callback sobre listar.
  • Debido a que el código es de en un ejemplo para un curso, donde Javascript era uno de los temas, el listado se genera con DOM también (lamentablemente sólo funciona en Firefox, o al menos con Gecko como motor). Está deshabilitado por defecto, pero se puede activar con la variable TRABAJAR_DOM

Finalmente para ejecutar: http://localhost:8080/TiendaVirtual/persona.html

Espero este artículo sea de utilidad, sobre todo por el uso de Jersey y la invocación de la API vía Ajax. No conseguí demasiada información precisa y ejemplos que funcionaran desde el inicio. Inicialmente me apoyé bastante en el blog de Lars Vogel, aquí el ejemplo.


martes, 23 de agosto de 2011

Configurando mod_proxy para evitar CORS (por Same Origin Policy)

Otra solución que conseguimos para evitar CORS (por Same Origin Policy) fue instalar/configurar mod_proxy como "proxy en reverso" en nuestro Apache HTTP Server. Sugiero leer este artículo también: CORS, XDM, Same Origin Policy, Prototype y JQuery.

Les dejo el pequeño HOWTO que hice:

0.- Configuración del sistema

$ cat /etc/issue
Ubuntu 10.10 \n \l

$ dpkg -l \*apache\* | grep ^i
ii  apache2-mpm-prefork                  2.2.16-1ubuntu3.1                                 Apache HTTP Server - traditional non-threaded model
ii  apache2-utils                        2.2.16-1ubuntu3.1                                 utility programs for webservers
ii  apache2.2-bin                        2.2.16-1ubuntu3.1                                 Apache HTTP Server common binary files
ii  apache2.2-common                     2.2.16-1ubuntu3.1                                 Apache HTTP Server common files
ii  libapache2-mod-php5                  5.3.3-1ubuntu9.5                                  server-side, HTML-embedded scripting language (Apache 2 module)
ii  libapache2-mod-proxy-html            3.0.1-1                                           Apache2 filter module for HTML links rewriting

1.- Pasos para la instalación del mod_proxy

1.1.- Instalación de paquetes

$ sudo aptitude install libapache2-mod-proxy-html
$ sudo a2enmod proxy
$ sudo a2enmod proxy_http

1.2.- Configuración del VirtualHost

Agregar al virtual host (Ej. /etc/apache2/sites-available/default) correspondiente lo siguiente:

ProxyRequests Off


Order deny,allow
Allow from all


ProxyPass /mio http://mio.com
ProxyPassReverse /mio http://mio.com

2.- Pruebas

Simplemente bastaría con hacer una petición a: http://localhost/mio/recurso



CORS, XDM, Same Origin Policy, Prototype y JQuery

Tiempo sin escribir nada por estos lados...

Me trae de vuelta un problema que me quitó mucho tiempo y me tuvo varias horas atascado, y como este blog va de compartir problemas y soluciones en la red, pues ahí lo dejo...

Los navegadores suelen seguir una política/restricción de seguridad conocida, llamada Same Origin Policy, que restringe la modificación de páginas/recursos -generalmente con Javascript- con contenidos obtenidos de otro lugar diferente al "origen". Esta tabla me parece perfecta para explicar qué se considera diferente del "origen".

Bueno, pues resulta que esta política se puede saltar valiéndose del concepto de CORS (Cross Origin Resource Sharing) o directamente utilizando una librería de XDM (Cross Direct Messaging), como: easyXDM.

Resulta que XDM nos parecía un hack y no queríamos valernos de este tipo de librerías; mucho más frecuentes en sitemashups. Entonces la solución era CORS. Cumplíamos con todos los parámetros, simplemente "creíamos" enviar los parámetros básicos en nuestras peticiones HTTP, a saber: Accept, Accept-Language, Content-Language, Content-Type o Media-Type (sólo dentro del rango: application/x-www-form-urlencoded, multipart/form-data y text/plain).

Y pasó lo que tenía que pasar, no funcionaba!! Estábamos utilizando Prototype porque JQuery no nos funcionaba en el navegador. Resulta que nuestro código si funcionaba en local, utilizando Firefox, con JQuery y seguía sin funcionar con Prototype.

Estuve al menos 1 hora depurando/debuggeando con Firebug y la paranoia y desesperación me llevaron hasta a probar con Wireshark. Fue cuando nos dimos cuenta de que Prototype estaba incluyendo algunos parámetros adicionales en la petición y JQuery no.

Ya estábamos más cerca de solucionar el problema. Este artículo abrió nuestros ojos defintivamente y agradezco de nuevo a su autor. Incluimos el código comentado allí y resolvimos el problema. Simplemente borra las cabeceras cuando detecta peticiones a recursos diferentes del origen. ¿Por qué JQuery si funcionaba? Porque cuando detecta peticiones a otro origen remueve los parámetros.

lunes, 30 de mayo de 2011

Clonando máquinas virtuales con VirtualBox

Estuve dándome varios golpes con VirtualBox para clonar una máquina virtual que había configurado con Ubuntu.

Hasta que por fin! Lo que hice fue:
  1. Instalar la máquina virtual fuente (vbox1). Para ello me descargué la ISO de Ubuntu Server de la Web, la configuré en el VirtualBox como CD, reinicié e instalé.
  2. Configurar la máquina virtual con dos interfaces de red. Una primera con vista "sólo anfitrión" y otra con NAT. La idea de la primera es mantener conexión con la máquina anfitrión (la no virtual) y la segunda tener acceso a Internet.
  3. Instalar todos los paquetes necesarios. En mi caso instalé: apache2, php5, php5-mysql, mysql-server y openssh-sever.
  4. Clonar la máquina. Esto me dio varios problemas de configuración de red... Al final lo que hice fue:
    1. Seleccionar la opción de "Exportar servicio virtualizado" (CRTL+E). Para lo que generé un archivo .OVA con un nombre diferente (vbox1_1)
    2. Seleccionar la opción de "Importar servicio virtualizado" (CRTL+I). Seleccionando el archivo .OVA recientemente generado.
    3. Modificar, en opciones avanzadas, las dos direcciones MAC de las 2 interfaces de red de la nueva máquina (vbox2). Para hacer esto basta con hacer clic en el botón de refrescar. Si no se hace este paso, VirtualBox asignará las mismas direcciones de red a ambas máquinas y habrán conflictos de red.
    4. Modificar el nombre de la nueva máquina. Para esto inicié la vbox2 y cambié el nombre del host en /etc/hosts y /etc/hostname.
    5. Borrar los parámetros heredados de direcciones MAC. Esto fue realmente problemático, como esta nueva máquina era un clon de otra, se traía las direcciones MAC de su padre y Ubuntu fallaba al reconocer las nuevas direcciones MAC. Para esto simplemente se debe eliminar el contenido del archivo: /etc/udev/rules.d/70-persistent-net.rules
    6. Reiniciar. Aunque creo que bastaría con "/etc/init.d/udev restart" y "/etc/init.d/networking restart".

Cogiendo N líneas aleatorías sin repetición de un archivo

Se me presentó el siguiente problema: tenía un archivo con N líneas y debía tomar/coger de éste M líneas no repetidas y de forma aleatoria. Siendo M < N. Como me "da nota"/mola bash, decidí hacerlo con un script. Antes explico el algoritmo, inspirado en un método para barajar cartas:

  1. Creando el mazo de cartas. Creo un arreglo con tantas posiciones como líneas tiene el archivo de entrada (el de N líneas).

  2. Barajando el mazo de cartas. Cojo el primer y último elemento del arreglo origen (source) y los coloco de últimos en el arreglo destino (tmp). Esto lo hago hasta vaciar el arreglo de origen y repito el procedimiento un número "aleatorio" de veces, entre 20 y 120 veces en este ejemplo. Siempre reemplazando al final de cada bucle el arreglo de origen por el temporal.

  3. Intercambiando última y primera carta. Esto para garantizar que la primera carta no permanezca siempre igual

  4. Sacando M cartas del mazo. Cojo las primeras M cartas del mazo.


#!/bin/bash

# Variables
fileName=$1
inputLines=`wc -l $fileName | cut -d' ' -f1`
outputLines=$2 # 596 

# Filling array
for i in `seq 0 $((inputLines-1))`; do
  source[$i]=$((i+1))
done

# Shuffling array
ceil=$((RANDOM%10*10+20)) # from 20 to 120, increment 10

for rand in `seq 1 $ceil`; do

  tmpIndex=0
  for srcIndex in `seq 0 $(($inputLines/2))`; do
    let srcTopIndex=$inputLines-$srcIndex

    tmp[$tmpIndex]=${source[$srcIndex]}
    tmp[$((tmpIndex+1))]=${source[$srcTopIndex]}

    let tmpIndex+=2

  done

  # for arrays with odd length
  if [ $(($inputLines%2)) -eq 1 ]; then
    tmp[$tmpIndex]=${source[$((srcIndex+1))]}
  fi

  source=( ${tmp[@]} ) # copying tmp array
done

# Changing first element for last one
tmp=source[0]
source[0]=${source[$((inputLines-1))]}
source[$((inputLines-1))]=$tmp

# Printing random lines of input file
for i in `seq 0 $(($outputLines-1))`; do
  sed -n "${source[$i]}p" $fileName
done

Cosas interesantes en este ejemplo:
  • Manejo de arreglos: ver iteraciones, copia, extracción y asignación de valores.
  • Extracción de una línea específica de un archivo, basado en el número de línea con sed.


sábado, 14 de mayo de 2011

Apagando y encendiendo el mousepad del laptop

Hoy estuve peleando con mi laptop tratando de encender y apagar el mousepad, básicamente porque no me siento cómodo utilizándolo, para lo que conecto un mouse externo, y además porque lo tropiezo al teclear, lo que se vuelve algo desesperante.

Intenté "apagar" el mousepad desde el menú de configuración del ratón, pero no conseguí ninguna opción. Entonces tuve que descubrir qué nombre tenía mi ratón, para lo que utilicé el siguiente comando:

rodolfo@tiuna:~$ xinput list --short | grep -i 'touchpad'
⎜   ↳ SynPS/2 Synaptics TouchPad               id=12 [slave  pointer  (2)]

Y luego para encender y apagar el ratón fácilmente creé el siguiente script:

#!/bin/bash

if [ $# -gt 0 ] && [ $1 == "on" ]; then
 mode=1
elif [ $# -gt 0 ] && [ $1 == "off" ]; then
 mode=0
else
 echo "You must specify an option, on or off"
 echo "Usage: script.sh on"
 exit
fi

format=8

# xinput list --short | grep -i 'touchpad'
DISPLAY=:0 xinput set-int-prop 'SynPS/2 Synaptics TouchPad' 'Device Enabled' $format $mode

Entonces, por ejemplo para apagar el mousepad bastaría con hacer:
rodolfo@tiuna:~$ ./mousepad.sh off

Por cierto, tengo instalado Ubuntu 10.10, por lo que supongo que esto funcionaría como mínimo en todas las distribuciones hijas de Debian.



lunes, 9 de mayo de 2011

Particionando el disco de mi nueva máquina

Compré una máquina este fin de semana y para instalar Linux tuve que enfrentarme al típico problema de particionamiento del disco.

Siempre había hecho esto con Partition Magic, ahora de Symantec, pero esta vez tuvo que ser un poco diferente.

La cuestión es que la máquina vino con Windows 7 de fábrica y quería conservarlo. La última versión pirata que conseguí del programa, siento aceptar que instalé la pirata, me estaba dando varios problemas con este Sistema Operativo.

Pues me puse a buscar y descubrí una herramienta, seguro recontra conocida, pero totalmente desconocida por mi, Parted y su equivalente gráfico Gparted.

Fue tan fácil particionar el disco que dudé hasta el final... Inicié la máquina por DVD (tengo un Ubuntu 10.10 en DVD), inicialmente ejecuté "sudo gparted", pero luego me di cuenta de que estaba en el menú de Administración.

Borré las particiones de HP UTILS y RECOVER, para lo que previamente compré a través de la página de HP el DVD de Recovery, mero romanticismo de conservar la máquina tal cual la compré en algún futuro improbable. Y luego, instalar Ubuntu! Fáchil perolito!

Enjoy! Recuerden, Gparted es la herramienta.

martes, 12 de abril de 2011

Ubuntu Cosillas: Xvidcap grabaciones de escritorio (una alternativa muy recomendable)

Excelente!! Esto lo conseguí en el blog citado abajo, los pasos son (textual):

  • Uninstall xvidcap in Synaptic
  • Install xvidcap from http://sourceforge.net/projects/xvidcap/files/xvidcap/1.1.7/xvidcap_1.1.7jaunty_i386.deb/download
  • Lock the installed version in Synaptic
  • Install pavucontrol in Synaptic (Needed in Ubuntu 10.04 but not in Linux Mint 10: already present)
  • Open the program with padsp xvidcap
  • Click on the recording button (red circle)
  • Run pavucontrol, go to the Recording tab and there choose Monitor of Analog Stereo Internal Audio

Ubuntu Cosillas: Xvidcap grabaciones de escritorio (una alternativa muy recomendable)

domingo, 10 de abril de 2011

Barajita premiada (#24) - generando documentos PDF a partir de imágenes

Por cosas de la vida necesitaba entregar un PDF con mis notas de grado escaneadas, el problema: tenía un montón de imágenes y llevarlas a un PDF con Openoffice siempre quedaba mal por inconsistencias con los márgenes. La solución:

$ ls 
notas1.jpg  notas3.jpg  notas5.jpg
notas2.jpg  notas4.jpg  notas6.jpg
$ sudo aptitude install imagemagick
$ convert *.jpg notas.pdf

Listo! El paquete imagemagick trae el programa convert que permite manipular imágenes (formatos, tamaños, etc), éste cogió los archivos en orden (por la numeración) y generó el PDF en un pis-pas.


viernes, 8 de abril de 2011

Iterando sobre un archivo con claves y consultando en BD (en bash)

El problema: un archivo/fichero con columnas separadas por tuberías "|" y por cada identificador contenido en la primera columna de éste, se debía buscar en BD unos datos específicos.

Les dejo este pequeño script que tiene algunas cosillas útiles, como la utilización de contadores en bash fácilmente (a lo C).

#!/bin/bash

dbuser=DB_USER
dbhost=DB_HOST
dbname=DB_NAME
ln=1 # counter
sql="SELECT ... FROM ... WHERE ... id="

cat content.csv |
while read line; do
  id=`cut -d'|' -f1 <(echo $line)`

  if [ $ln -gt 1 ]; then
    mysql -u $dbuser -h $dbhost $dbname --batch --skip-column-names -e "$sql$id" | sed 's/\t/|/g'
  fi

  let ln+=1
done
Por cada línea del archivo content.csv se toma la primera columna (como id - luego de la primera línea) y luego se ejecuta una query en BD utilizando este número; el resultado es formateado con columnas separadas por tuberías. Interesante: la forma en que se incrementa el contado con "let+=1".
OJO: Esto se pudo hacer con otro lenguaje de programación, ideal perl, pero como me da nota/mola bash lo hice de esta forma. Además, cabe acotar que esto es sólo algo puntual, no es una base de código que deberá mantenerse en el tiempo, de no ser así, recomendaría otra vía.

martes, 29 de marzo de 2011

Barajita premiada (#23) - variables vacías o sin definir en bash

Recientemente tuve que hacer un script de bash, que entre tantas cosas, en un momento determinado debía validar y diferenciar si una variable existía o no tenía valor (era vacía).

Para resolver el problema descubrí dos operadores que desconocía...

#!/bin/bash

# a equals empty string (var instance exists)
a=""
echo "${a-NO_INSTANCE}"
echo "${a:-NO_VALUE}"

# a equals full string (var instance exists)
a="hello"
echo "${a-NO_INSTANCE}"
echo "${a:-NO_VALUE}"

# b not exists as var
echo "${b-NO_INSTANCE}"
echo "${b:-NO_VALUE}"


Al ejecutar el script verá una salida como la siguiente:

$ ./checkBashVars.sh 

NO_VALUE
hello
hello
NO_INSTANCE
NO_VALUE

En la salida mostrada arriba se puede ver que:
  • El operador "-": devuelve el valor de la variable (VAR) si existe, no importa si es vacía. En caso de no existir, devuelve el valor alternativo (VALOR).
  • El operador ":-": devuelve el valor de la variable (VAR) si existe y tiene valor (no es vacía). En caso de no existir, devuelve el valor alternativo (VALOR).

Un ejemplo para mostrar dónde se puede utilizar esto: imaginemos que tenemos un documento con identificadores, otro con registros (un CSV) donde estos identificadores están presentes y la idea es conocer cuál de los identificadores no está en el documento.

Identificadores:
$ cat ids
1
2
3

Fuente, CSV:
$ cat source
1|nice|bad
2|welcome|bye
1|tokio|caracas

Script que retornará los ids que no están presentes en el documento fuente (CSV):
#!/bin/bash

cat ids |
while read id; do
        match="`grep $id'|' $source`"

        if [ "${match:-NULL}" = "NULL" ]; then
                echo $id 
        fi
done

La salida:
$ ./script.sh 
1

El script mostrado arriba, busca dentro del archivo fuente (source) cada uno de los id contenidos en el archivo de ids y en el momento en que no consigue registros, porque el grep sobre el archivo retorna "NULL", imprime el id. Puede ver que el NULL es impreso utilizando el operador :-



lunes, 14 de marzo de 2011

Obteniendo comentarios de tablas y columnas - diccionario de datos

Se presentó el típico problema de falta de documentación! Entender un sistema es complejo y paradojicamente, pareciera que cada vez más... Muchas tecnologías, muchos entornos de trabajo, muchas maneras de configurarlos, mucho... Spring, GWT, Hibernate, Symfony, CakePHP, Rails, Struts, etc, etc, etc, etc... Y etc...

Como para rematar, más que un sistema sin documentación, una BD sin ella, es como buscar una aguja en un pajar... Como mínimo deberíamos tener un diccionario de datos y alguno de esos diagramitas (ER - Peter Chen) generados con alguna herramienta CASE.

El problema que persigue a cualquier "UP frutado" y que además haya leído algo con aires del Manifiesto por el Desarrollo Ágil de Software es: si debe generar ese diccionario en un documento que seguramente no será actualizado más nunca en la vida y del que no podrá generarse un artefacto de software.

Idealmente, en un modelo bottom-up, podemos comenzar con un CASE e ir incluyendo los comentarios según realizamos el modelo y al generar nuestro script SQL, pum! Ya tenemos comentarios en BD.

Ahora, todo esto es bello como la pradera, pero mentira como el comercial de Coca-Cola (el de la canción de Oasis, Whatever). Esto seguramente no se actualizará más nunca en la vida.

Con base en todo lo que he mencionado, decidí incluir los comentarios en BD directamente. Y cuando deseo leerlos, pues lo hago con el MySQL Admin.

Ahora, qué pasa si el jefe o alguien no técnico quiere esa info... O simplemente quieres tenerla en otro formato... Precisamente ese fue uno de los problemas con los que me conseguí y realmente MySQL no me daba una herramienta que se adaptara a lo que necesitaba... Les dejo este sencillo script que pretende facilitarles la vida... Por supuesto, se pueden incluir muchas más cosas en la salida:

#!/bin/bash

if [ $# -lt 3 ]; then
        echo "You must specify table, schema and host"
        echo "Eg. script.sh TABLE SCHEMA 192.168.10.1"
        exit
fi

table="$1"
schema="$2"
host="$3"
user="root"

stty -echo
read -p "Enter MySQL's Admin password: " password
stty echo
echo

mysql -u $user --password=$password -h $host --batch information_schema --skip-column-names -e "SELECT table_name, table_comment FROM tables WHERE table_name='$table' AND table_schema='$schema'" | sed 's/\t/|/g'

mysql -u $user --password=$password -h $host --batch information_schema --skip-column-names -e "SELECT column_name, column_type, column_comment FROM columns WHERE table_name='$table' AND table_schema='$schema'" | sed 's/\t/|/g'

El script de arriba imprime campos separados por tuberías "|". Específicamente, nombre de tabla, nombre de columnas, tipos y comentarios. Un ejemplo de salida:

$ ./extractComments.sh mia test localhost 
Enter MySQL's Admin password: 
mia|Descripcion de la tabla
id|int(11)|Descripcion del campo id
name|varchar(50)|

Y puede utilizar esta variante para extraer el "Diccionario de Datos" de toda la BD:

#!/bin/bash

if [ $# -lt 2 ]; then
        echo "You must specify table, schema and host"
        echo "Eg. script.sh SCHEMA 192.168.10.1"
        exit
fi

schema="$1"
host="$2"
user="Admin"

stty -echo
read -p "Enter MySQL's Admin password: " password
stty echo
echo

mysql -u $user --password=$password -h $host --batch $schema --skip-column-names -e "SHOW TABLES" |
while read table; do

  mysql -u $user --password=$password -h $host --batch information_schema --skip-column-names -e "SELECT table_name, table_comment FROM tables WHERE table_name='$table' AND table_schema='$schema'" | sed 's/\t/|/g'

  mysql -u $user --password=$password -h $host --batch information_schema --skip-column-names -e "SELECT column_name, column_type, column_comment FROM columns WHERE table_name='$table' AND table_schema='$schema'" | sed 's/\t/|/g'

  echo; echo
done;


viernes, 11 de marzo de 2011

Barajita premiada (#22) - copiando en consola con barra de progreso

Copiar ficheros de un lado a otro por consola resulta trivial, esto se puede hacer utilizando el comando cp. Luego, hay momentos en los que se debe copiar mucha información... Por ejemplo, yo hago respaldos de mi info en un disco externo cada cierto tiempo y son varios gigas, entonces al hacer una copia no conocía nada del estatus de la copia, sólo me quedaba la persignación... XD

Podría pensar que soy un freak por hacer copias por consola, la cuestión es que es mucho más útil porque puedo manipular la salida de error estándar y no dejo colgada la interfaz gráfica!

Generalmente hacía algo como:

# cp -r /etc/ /home/ /opt/ /root/ /var/ 201111_respaldo_linux 2>201111_respaldo_linux/errores

Ahora, sólo sabía como iba esto cuando terminaba... Como máximo podía ir viendo errores con un "tail -f" sobre el fichero de errores, algo así:

# cp -r /etc/ /home/ /opt/ /root/ /var/ 201111_respaldo_linux 2>201111_respaldo_linux/errores & tail -f 201111_respaldo_linux/errores

Pero ya no sufro más!!! Encontré una mejor manera de hacer esto, utilizando rsync que me da detalle del progreso de la operación...

# rsync -aRv --progress --delete /etc/ /home/ /opt/ /root/ /var/ 201111_respaldo_linux 2>201111_respaldo_linux/errores

Esto mostrará el estatus de la copia (al más puro estilo scp), las opciones: -a, -R, -v, --progress y --delete, las utilizo -respectivamente- para: copiar ficheros, utilizar nombres relativos, activar modo verboso, mostrar progreso y eliminar contenidos diferentes de la fuente en el destino.