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.

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.

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.

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.

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.

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)

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.

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.

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 :-

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;

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.

Optimizando tablas InnoDB en MySQL

Cuando utilizamos MySQL es común optimizar tablas con muchos registros con cierta periodicidad, esto para solventar problemas de fragmentación, entre otros. La verdad esta es una de las cosas del modelo de PostgreSQL que echo en falta, quizás no es tan "amigable" pero todo queda claro desde el inicio.

En PostgreSQL hay un proceso de aspiradora (vacuum) que va eliminando periódicamente registros inutilizados en tablas, su configuración, pan nuestro de cada día para un admin de BBDD que debe ajustarlo con frecuencia.

Bueno.... Volviendo a MySQL, si necesita optimizar tablas InnoDB, lo mejor que puede utilizar son ALTER nulos, estas son instrucciones DDL de tipo ALTER sin parámetros que permiten seguir trabajando con las BBDD, porque realiza copias temporales en disco. La cuestión es que esta herramienta "reconstruye" la tabla y elimina, entre otros, los problemas de fragmentación.

Aquí les dejo un script para optimizar de "un sólo golpe" varias tablas InnoDB:

#!/bin/bash

if [ $# -lt 2 ]; then
        echo "You must specify database host"
        echo "Eg. script.sh MY_DATABSE 192.168.10.1"
        exit
fi

db="$1"
host="$2"
user="root"
declare -a tables=(Table1 Table2 Table3)

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

for table in ${tables[@]}; do
        echo $table &&
        time mysql -u $user --password=$password -h $host $db -e "ALTER TABLE $table ENGINE=INNODB"
done

Básicamente optimizamos las tablas especificadas (en un arreglo) e imprimimos el tiempo que toma cada instrucción (time).

Si tiene la certeza de que todas las tablas de una BD son InnoDB y quiere optimizarlas todas aún más rápido, puede hacerlo valiéndose del comando "show tables"...

#!/bin/bash

if [ $# -lt 2 ]; then
        echo "You must specify database host"
        echo "Eg. script.sh MY_DATABSE 192.168.10.1"
        exit
fi

db="$1"
host="$2"
user="root"

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

mysql -u $user --password=$password -h $host --batch --skip-column-names $db -e "SHOW TABLES" |
while read table; do
        echo $table &&
        time mysql -u $user --password=$password -h $host $db -e "ALTER TABLE $table ENGINE=INNODB"
done

La única diferencia es que las tablas ya no son especificadas a través de un arreglo (que recomiendo para BBDD grandes, donde optimizar todas las tablas podría demorar toda la vida), sino que se toman directamente del comando "SHOW TABLES" para una BD especificada.

Ejecutando lotes de modificaciones (INSERT, UPDATE, DELETE) en BBDD

Esta me salvó hace poco de un proceso de modificaciones (INSERT, UPDATE y DELETE) eterno!

Si necesita realizar muchas operaciones de las comentadas, por ejemplo un par de millones, resulta bastante útil y reduce considerablemente el tiempo de respuesta, incluir BEGIN y COMMIT al comienzo y final del lote.

Con esto eliminamos sobrecarga realizando una sola transacción y no una por instrucción. Espero sea de utilidad... Recuerde: BEGIN; INSERT...; COMMIT;

Barajita premiada (#21) - número de días en un mes

Esta es una barajita breve, pero no por ello menos útil. Se trata de un método sencillo en *nix de obtener el número de días que tiene un mes:

$ month=02; year=2011
$ cal $month $year | xargs | awk '{print $NF}'
28

Obtengo los días en formato calendario, los paso por xargs para quitar retornos de carro/tabulaciones y luego pido el último elemento con AWK.

Instalando dos versiones de PHP-CLI en una misma máquina

El otro día tuvimos problemas instalando dos versiones del interprete de línea de comandos de PHP (PHP-CLI) en una misma máquina, específicamente, queríamos instalar en una máquina con Ubuntu 10.04 que ya tenía PHP5.2, PHP5.3.

Mi primo Daniel (http://dcestari.posterous.com/), quien es un crack como dicen por estos lares (en Venezuela diríamos un duro), dió con la solución...

Descargó el fichero con los fuentes de php.net y configuró utilizando las opciones que trae el .deb que descargas desde los repos. A continuación las opciones:

# ./configure --prefix=/usr/local/ --disable-cgi \
--program-suffix=5.3 \
--with-config-file-path=/etc/php5.3/cli \
--with-config-file-scan-dir=/etc/php5.3/cli/conf.d \
--build=$(dpkg-architecture -qDEB_HOST_GNU_TYPE) \
--host=$(dpkg-architecture -qDEB_HOST_GNU_TYPE) \
--sysconfdir=/etc \
--localstatedir=/var \
--disable-debug \
--with-regex=php \
--disable-rpath \
--disable-static \
--with-pic \
--with-layout=GNU \
--enable-calendar \
--enable-sysvsem \
--enable-sysvshm \
--enable-sysvmsg \
--enable-bcmath \
--with-bz2 \
--enable-ctype \
--with-db4 \
--without-gdbm \
--with-iconv \
--enable-exif \
--enable-ftp \
--with-gettext \
--enable-mbstring \
--with-pcre-regex=/usr \
--enable-shmop \
--enable-sockets \
--enable-wddx \
--with-libxml-dir=/usr \
--with-zlib \
--with-kerberos=/usr \
--with-openssl=/usr \
--enable-soap \
--enable-zip \
--with-mhash=yes \
--with-libedit \
--without-mm \
--enable-pdo \
--with-pdo-mysql \
--with-mysql --without-sybase-ct --with-sqlite \
--without-mssql --with-sqlite3 --enable-pcntl \
--without-pear

Luego, compilamos con make y lo novedoso.... en lugar de instalar el compilado con el típico make install, el descubrimiento del año (al menos para mi), utilizamos checkinstall lo que genera un .deb -con el nombre especificado- que después se puede instalar y desinstalar fácilmente con dpkg.

Copiando permisos de una BD MySQL a otra

Este script lo encontré en la red y me pareció que debía publicarlo aquí por su gran utilidad:

#!/bin/bash
# adapted from (http://www.pyrosoft.co.uk/blog/2006/10/18/show-grants-for-all-users-on-mysql/)
mysql --batch --skip-column-names -e "SELECT user, host FROM user" mysql |
while read user host; do
  echo "# $user @ $host"
  mysql --batch --skip-column-names -e"SHOW GRANTS FOR '$user'@'$host'"
done

El script mostrado arriba saca todos los usuarios de la BD y luego retorna un script con los privilegios para cada uno de estos, lo que permitiría migrar privilegios y usuarios de una BD MySQL a otra.