micro - How To

GIT - Vista Rapida Comandos

2014-10-25T16:24:00.004-07:00

Para crear un Branch
git checkout -b newLocalBranch
git push -u origin newLocalBranch

Uso de checkout
branch (cambiar de branch a branch):
     git checkout remoteBranch
Para restaurar al archivo original (olvidar cambios):
git checkout path/local/file

Watering - traerte los cambios del branch origen a tu branch actual
git merge origin/master --no-commit
git commit  -m"watering"
git push

Cherry pick - traerte los cambios de un commit a tu branch actual
1. git cherry-pick #hash
2. git push

Hacer un merge de un branch sobre master (o el origen de donde surgio el branch)
git checkout {upstream-branch-name}
git pull
git merge --squash --no-commit origin/{branch-to-merge}
git commit
mvn clean install
ant test.js.all
git push

Borrar un branch
git branch -rd origin/remoteBranchName (forzar a borrarlo cuando no tienes una copia localmente)
or
git branch -D localBranchName
git push origin :remoteBranchName

Esconder cambios con stash
ver lista de cambios escondidos: git stash list
ver cambios de un elemento de la lista: git stash show stash@{#}
esconder cambios como uno en la lista: git stash save "Some stash message here”
aplicar cambios al branch sin borrar de la lista: git stash apply stash@{#}
aplicar cambios y eliminarlos de la lista : git stash pop stash@{#}
borrar un elemento de la lista : git stash drop stash@{#}
borrar todos los elementos de la lista: git stash clear

Revertir cambios de un branch remoto (o ya pusheados)
git revert #exactlyTheRemoteHashOfInterest —no-commit

Resetear cambios del branch local (commiteados pero no pusheados)
1. buscar el #hash previo (no el hash que estas interesado en resetear, sino uno antes)
git log
2.1 resetear (todos los commits van a ser devueltos a la bandeja de unstage - antes de comitear)
git reset #localHash
2.2 O tambien puedes deshacer el commit N (con HEAD~N) y perder los cambios (con --hard)
git reset --hard HEAD~1
2.3. Si quieres deshacer cambios pero no perderlos (que por default usa --soft)
git reset HEAD~1

Patron de Diseño Command

2014-10-25T16:10:00.001-07:00

El patrón comando permite que solicitudes del cliente sean encapsuladas como objetos, indicar parámetros a diferentes solicitudes, encolarlas, registrarlas y hasta dar soporte para operaciones des-hacer.

Participantes:

invocador (invoker) - el que almacena las ordenes y las manda ejecutar.
cliente (client) - el que proporciona la orden al invocador.
receptor (receiver) - aquél que en verdad realiza la acción que se mandó a ejecutar
comando (command) -la orden que relaciona al invocador con el receptor de manera general
comando concreto (concrete command) - la implementación para la ejecución de la orden (es más específica)

Ejemplo:

El consumidor (cliente) da órdenes (comandos) a un mesero (invocador), el cuál las apila para después pasarla al cocinero (ejecutar la acción). El cocinero (receptor) entonces realiza la acción.
El usuario abre su programa favorito (cliente) , da clic sobre el contenedor de comandos llamado "menú Archivo" (invocador) y después sobre abrir archivo (comando), el cual abre una segunda ventana para indicarle de que archivo se trata (receptor). Cada opción del menú archivo ejecuta una acción que es un comando parametrizado.

Consecuencias:
El objeto que invoca el comando y el que lo realiza están des-acoplados. El invocador no tiene por que saber de que forma se ejecuta la acción.
Los objetos comandos se pueden extender usando patrones como Composite y Memento.
Es fácil agregar comandos porque no tienes que modificar las clases ya hechas.

Decisiones de diseño:

Cuando quieras parametrizar objetos que realicen una acción determinada
Cuando necesites encolar y ejecutar una serie de solicitudes en diferentes momentos
Si deseas mantener un historial de ejecuciones para así permitirte des-hacerlas, también es sencillo logear cada proceso de manera que si falla el sistema, se pueda saber en que punto quedó para una restauración manual.

Aceleración del Emulador Android en Linux

2013-09-11T10:25:00.002-07:00

Apenas me estoy metiendo a jugar un poco para programar en Android y me topé con el problema de que el emulador va lentísimo en Linux. Cabe notar que el Android SDK Manager tiene un paquete que menciona la aceleración del emulador en Intel, pero explícitamente dice: "NO SOPORTADO EN LINUX". Lo cual no significa que todo esté perdido ;-)

Investigando me topé con este hilo en stackoverflow: http://stackoverflow.com/questions/1554099/slow-android-emulator

Que hace referencia a esta información del sitio de Intel: http://software.intel.com/en-us/blogs/2012/03/12/how-to-start-intel-hardware-assisted-virtualization-hypervisor-on-linux-to-speed-up-intel-android-x86-gingerbread-emulator

En resumen, hay que instalar Qemu (para virtualización en Linux usando KVM), y puesto que el emulador de Android se basa en Qemu, es sólo cuestión de ligarlos.

Hecho eso, se puede crear un AVD que utilice como CPU/ABI un Intel Atom (x86), y que al emular se debe usar el host del GPU. Si emulas vía la consola, debes usar emulator-x86 con las opciones -qemu -m 2047 -enable-kvm

Voilá, tu emulador debería de volar ahora...

Issues con los que me topé:
-Al instalar los módulos del kernel de KVM hay que asegurarse que la virtualización no esté deshabilitada en la BIOS. (Y ya con esto tengo para virtualizar lo que quiera! suelo usar virtualbox, luego jugaré con esto también :D )
- No hay que olvidar que se debe instalar también la imagen Intel X86 en el Android SDK Manager

Hacer Push de un branch local a un repositorio Git remoto

2013-09-06T09:56:00.001-07:00

Tan simple como usar git push con el nombre del branch.
Digamos que tenemos un branch plugin que queremos subir al repositorio origin:

git push -u origin plugin

El parámetro -u permite crear un upstream en donde sea que bajemos este branch desde origin, de forma que hacer push/pull sea mucho más sencillo.

Para bajar este branch desde el repositorio, bastaría hacer:

git fetch origin

[Git nos informará que se ha creado un nuevo branch, origin/plugin]

git checkout --track origin/plugin

Con esto cambiamos al nuevo branch, y además le damos seguimiento para hacer actualizaciones de manera rápida y sencilla cuando hagamos push.

Como agregar una libreria al codigo manualmente (jQuery)

2013-08-30T09:00:00.001-07:00

function loadJQuery() {

var fileref = document.createElement('script');

fileref.setAttribute("type", "text/javascript");

fileref.setAttribute("src", "http://code.jquery.com/jquery-1.5.min.js");

document.getElementsByTagName('head')[0].appendChild(fileref);

}();

Fácil no? .. Puedes cambiar la version si deseas otra de jQuery o bien , la URL completa para cualquier otra libreria.

Por otro lado, si ya la cargaste previamente en el render de tu documento, no olvides poner tu código dentro de ready:



$(document).ready(function() {



  // Handler for .ready() called.



});

2 configuraciones con Spring Mail para usar Gmail

2012-08-24T14:01:00.001-07:00

He notado que la configuración de la clase "JavaMailSender" de Spring es un poco confusa para algunos y personalmente me ocurrió cuando al principio tomé el proyecto de enviar correos con Spring.

Así que dejo aquí, dos configuraciones que me funcionaron a la perfección con Gmail: TLS y SSL

Debo hacer notar que también funciona con Google Apps for Business.

Usando TLS en puerto 587

<bean class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="defaultEncoding" value="UTF-8">
    <property name="host" value="smtp.gmail.com">
    <property name="port" value="587">
    <property name="protocol" value="smtp">
    <property name="username" value="correo@gmail.com">
    <property name="password" value="miPassword">
    <property name="javaMailProperties">
        <props>
            <prop key="mail.debug">true</prop><!--Este se puede omitir-->
            <prop key="mail.smtp.auth">true</prop>
            <prop key="mail.smtp.starttls.enable">true</prop>
            <prop key="mail.smtp.quitwait">false</prop>
        </props>
    </property>
</bean>

Usando SSL en puerto 465

<bean class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="defaultEncoding" value="UTF-8">
    <property name="host" value="smtp.gmail.com">
    <property name="port" value="25">
    <property name="username" value="correo@gmail.com">
    <property name="password" value="miPassword">
    <property name="javaMailProperties">
        <props>
            <prop key="hostname">smtp.gmail.com</prop>
            <prop key="mail.debug">true</prop><!--Este se puede omitir-->
            <prop key="mail.smtp.auth">true</prop>
            <prop key="mail.smtp.socketFactory.class">javax.net.ssl.SSLSocketFactory</prop>
            <prop key="mail.smtp.socketFactory.port">465</prop>
            <prop key="mail.smtp.socketFactory.fallback">false</prop>
        </props>
    </property>
</bean>

Otras fuentes:
- Configuracion con código.
- Probar conecciones SMTP AUTH (inglés)
- Enviar Mail con Telnet

Entorno No Integrado de Desarrollo (UDE)

2012-06-19T07:00:00.000-07:00

Casi todos los desarrolladores que conozco acostumbran utilizar herramientas pesadas para hacer su trabajo.

Una de dichas herramientas, el IDE (entorno de desarrollo integrado) suele ser un programa grande que incluye en un sólo paquete las herramientas más comunes que un desarrollador puede llegar a necesitar.

Ese es el problema: asumir que el desarrollador VA a necesitar las herramientas, cuando en realidad sólo PUEDE que las necesite.

Por esa razón, tiene un tiempo ya que no utilizo IDEs para mi trabajo. O como leí alguna vez, utilizo un entorno NoIntegrado de Desarrollo (Unintegrated Development Environment).

Armar un entorno así no es nada difícil, y sólo requiere de un conocimiento concisio de las herramientas que en realidad tiene a su disposición un programador para hacer su trabajo, según el sistema sobre el que trabaje.

El primer elemento, el editor de texto, debe ser una herramienta sencilla y a la vez eficaz, que haga bien su trabajo. Suele ser una herramienta muy especializada, y aunque para muchos pueda parecer trivial, la realidad es que es la más importante de todas. Ideal que cuente con resaltado de sintaxis, y si es posible, integración con algunas de las otras herramientas (lo que haría del editor de textos, para efectos prácticos, un mini-IDE, pero eso es otro asunto). En gustos se rompen géneros, los hay para entornos gráficos de escritorio como para entornos de consola. Mi favorito, Emacs, tiene la posibilidad de integrarse con muchísimas herramientas más, además de poder ser programado y extendido (usando Lisp) para hacer mejor las labores que un editor de textos potente (propio de un programador) debe realizar. Claro, también está vim, gedit, en windows está notepad++, y un largo etcétera...

Anexo al editor de textos, no viene nada mal alguna herramienta para búsqueda de declaraciones, para localizar fácilmente los encabezados y declaraciones de funciones, clases y demás bichos que viven en un programa común. En Unix existen ctags y etags, que generan un pequeño archivo con las referencias para localizar estas declaraciones y que puede integrarse fácilmente a Emacs o vim.

Dependiendo el lenguaje de programación utilizado, por supuesto que se tiene que tener el compilador o intérprete adecuado al lenguaje en cuestión. Incluso los IDEs dependen de esta herramienta externa, pues los lenguajes de programación son algo tan vasto, que incluye librerías y extensiones por sí mismas, e incluirlas en un mismo paquete ya sería una exageración para el de por sí exagerado tamaño de los IDEs. No entraré en detalles de esta herramienta, ya que depende siempre del lenguaje en cuestión el tener el compilador o intérprete y las librerías adecuadas correctamente instaladas para su uso.

Y si el desarrollo que se está haciendo implica alguna plataforma específica, por ejemplo web, además se requerirá de algún entorno de desarrollo bien armado que incluya un servidor web, con cgi bien configurado, de forma que no sólo se escriba texto, sino que también se puedan hacer las pruebas adecuadas accediendo, por lo menos, a http://localhost , es decir a la propia máquina. Lo mismo aplica para motores de bases de datos y cualquier otro recurso del que haga uso el proyecto en el que se esté trabajando.

De la mano del proceso de compilación y lanzamiento para pruebas (o incluso a producción o 'deploy') del proyecto en que se esté trabajando, está la herramienta de generación y automatización de código. Compilar todo un proyecto puede ser un proceso complejo que incluya no solamente generar el código objeto (o como se llame en el lenguaje en particular que se use) de un archivo modificado, sino también puede haber dependencias entre los otros archivos, generación de código (por ejemplo para analizadores léxicos y gramaticales), producción de archivos de otros tipos (imágenes, documentación, etc.) que dependan directamente de otros archivos del proyecto. ¿Cómo hacer la vida sencilla a un desarrollador ante esta complejidad? La herramienta por antonomasia es make, que aunque se originó para proyectos en lenguaje C, es tan potente que puede ser usado para prácticamente cualquier proyecto de cualquier lenguaje, e incluso para cualquier otro proyecto que no sea de programación pero que requiera de la producción de archivos con base en dependencias.

Hablando del deploy, incluso este puede automatizarse de manera eficiente. Depende mucho del entorno en que el proyecto vaya a ser lanzado. Pensando por ejemplo en un proyecto web, si se cuenta con acceso SSH o FTP al servidor en donde será lanzado, se puede utilizar rsync. Algunos utilizan el versionador para estas labores, pero yo no lo recomiendo. Un versionador además de que incluye archivos ajenos al proyecto final ya lanzado, tiene un propósito específico. Recuerda: no uses un desarmador como martillo. Otros proyectos se lanzan en otros entornos o con otras condiciones. La idea en sí es encontrar las herramientas adecuadas que permitan estos procesos de manera sencilla, eficiente y precisa. Incluso simplemente copiar y pegar archivos puede servir, pero si se puede contar con una herramienta más avanzada (que mantenga por ejemplo un log del proceso del deploy, con capacidades de deshacer y revertir el proceso en casos de emergencia), mejor. Aquí, como en los otros casos, aplica también el principio básico de que, si no se cuentan con las herramientas adecuadas, habrá que crearlas. Por algo somos programadores, y por lo menos para el caso del deploy, algunos scripts en bash, sql, python y demás pueden bastar para lo que se requiere.

Una de las herramientas más útiles que conozco para el desarrollo es el versionador. Con un versionador se puede, como su nombre lo indica, mantener versiones del código de un proyecto. ¿Para qué mantener versiones del código si de todas maneras lo que importa es el producto final? Por mil razones: a veces el desarrollo toma un camino que ya no agrada (porque funciona mal o porque cambian los objetivos) y es bueno poder regresar a una versión del código que no incluya esos últimos cambios; organizar equipos de desarrollo es muchísimo más fácil (en varios órdenes de magnitud) usando versionadores que administrándose como se pueda y dejando que todos hagan lo que deseen; los versionadores proporcionan la posibilidad de ramificar el desarrollo, dirigiéndolo hacia distintos objetivos cada rama, y posteriormente unificarlas de regreso, con los distintos desarrollos ya hechos de manera independiente. Hay muchos versionadores, pero los que valen la pena hoy en día son los llamados distribuidos, como Git (mi favorito) o Mercurial.

Y ¿qué desarrollo está completo sin un ciclo de depuración de errores? Alguna vez leí un artículo donde se mencionaba que el proceso de depuración (o debuggeo) conlleva cerca del 80% del tiempo de desarrollo de un proyecto. Así que más vale agarrarle el gusto a esta etapa del desarrollo, que está embebida dentro de todo el proceso, no es que vaya a encontrarse en algún lugar específico, al inicio o al final. Y se puede depurar haciendo simples prints de mensajes a consola, pero es mejor utilizar un debugger simbólico, como el que los IDEs acostumbran incluir. Claro está, dependiendo el lenguaje de programación usado, serán las herramientas de depuración con que se cuenten. Los proyectos en C y C++ pueden utilizar fácilmente gdb. Java cuenta con jdb. Python con pdb...

Dependiendo del lenguaje, sobre todo los interpretados, estos llegan a contar con una herramienta que a mi en lo particular me es muy útil. El shell del lenguaje donde se puede jugar libremente con el mismo, experimentar, probar cosas e investigar también. Python y Ruby, por ejemplo, tienen uno.

Y así puedo seguir enumerando más herramientas. Las que ya mencioné son las que más utilizo yo, pero existen otras. Por ejemplo, perfiladores de consumo de recursos (para la labor de optimización que, recuérdese, SIEMPRE se debe hacer hasta el final, y solamente una vez que ya se midió. El perfilador sirve precisamente para este propósito), o herramientas para armar pruebas (unitarias, funcionales, de estrés). Múltiples herramientas del sistema pueden aprovecharse para el desarrollo: buscadores de textos y de archivos, herramientas de diagnóstico, documentación, etc.

El punto es, como dije al principio, conocer todas y cada una de las herramientas individuales que suelen venir empaquetadas en un IDE, y así desmenuzadas, aprovecharlas al máximo y sin la obligación de tenerlas para no usarlas, con el consecuente consumo de recursos excesivo que los IDEs plantean. ¿O a poco no es cierto que Eclipse o Netbeans llegan a alentar tu máquina muchas veces?

Y además, se tiene la GRANDÍSIMA ventaja de poder elegir. Si un editor no te gusta eliges otro, si un debugger no te satisface, probablemente existan muchos más. Yo por ejemplo, cuando desarrollo en python, no utilizo el shell y el debugger por default que se incluyen con el lenguaje. Yo utilizo, como buen fan de la consola que soy, ipython como shell y ipdb (muy relacionado con ipython) como debugger. Es cosa de buscar, probar y elegir.

¡Ah! y no quiero terminar este post sin antes mencionar otro par de detalles de los UDEs (Unintegrated Development Environments). Conforme se quiera contar con más y mejores herramientas, se dará uno cuenta que el sistema sobre el que se trabaje también hará la diferencia entre PODER elegir, y TENER que elegir. Es decir, que la libertad que se tenga entre elegir por separado las herramientas para hacer un mejor trabajo de desarrollo, depende muy directamente del sistema sobre el que se trabaje. Y en algunos sistemas desafortunadamente, tanto la cantidad y disponibilidad de herramientas es más bien escasa (tanto que en muchos sistemas así a veces no queda de otra más que usar a fuerzas o a fuerzas un IDE), pero también las interfaces de desarrollo entre el proyecto y el sistema suelen ser pobres, defectuosas, mal documentadas, nada compatibles entre versiones diferentes del mismo sistema, en fin, que hacen de la labor de desarrollo lo que en inglés se conoce coloquialmente como un 'pain in the ass'. Yo por eso prefiero trabajar en un ambiente Unix. Es mi eleccion personal, sí, pero no sólo es mía, muchos desarrolladores estarán de acuerdo conmigo que trabajar en un sistema Unix es muchísimo más productivo, y hasta relajante, que trabajando en un Windows. Y claro, al decir Unix, abarco no sólo Linux o los BSDs, incluso Mac podría caer en esta categoría, lo malo es que no todos tenemos tanto dinero para pagarnos las herramientas, y además, en mi opinión, no es tan buen sistema para desarrollar: menos documentación, creo yo que menos gente en internet ayudando, más restricciones; es un entorno que, según leí alguna vez, podría compararse con un jardín amplio, grande y bello, pero que al final tiene bardas en los límites.

Y por cierto, acabo de mencionar casi por accidente el último recurso importante: internet. ¿Qué desarrollador puede preciarse de llamarse así si no sabe dónde y cómo buscar la información y documentos, ejemplos, ayuda que necesita entre otros desarrolladores (por ejemplo en foros o sitios dedicados a la consulta como stackoverflow) y que han enfrentado problemas similares? Simplemente para conocer más herramientas que cumplan las funciones ya enlistadas y otras, internet es fundamental. Yo soy de la opinión que un desarrollador no lo es más sólo por saberse un lenguaje o una tecnología de memoria al derecho y al revés. Esa función ya la cumple internet. Lo que se necesita es muchísima creatividad, y por supuesto un conocimiento y uso adecuado de las herramientas que convengan en el momento.

Como subir un proyecto con GIT a GitHub

2012-05-16T09:30:00.003-07:00

Para subir un proyecto a gitHub no hay mas que seguir los mismos tutoriales que te proveen pero a resumidas cuentas tienes que hacer lo siguiente:

1.- Crear una cuenta en GitHub

Tienes que ir a la liga : https://github.com/plans y darle en el botón de Create a free Account, una cuenta libre te permite tener tantos repositorios públicos y colaboradores públicos como quieras, pero ninguno privado, si quieres esto, tienes que pagar.

Este paso es muy rápido y obvio, después de ingresar tus datos recibirás un mail de confirmación y listo, regresas a la página para entrar a tu cuenta.

2.- Instalar Git en tu equipo

En windows puedes descargar una versión de Git desde : http://code.google.com/p/msysgit/, pero para los que usamos linux Mint y similares a Ubuntu lo que tienes que hacer es:

sudo apt-get install git git-core git-gui git-doc
(lo que está en negritas es lo esencial, lo demás son agregados y puedes no indicarlos)

luego debes crear la configuración global de git para que se puede rastrear los cambios que tu haces y diferenciarlos con respecto a los demás integrantes del proyecto.

git config --global user.name "Nombres Apellidos"
git config --global user.mail "tunick@gmail.com"

Para establecer una conexión segura entre tu máquina y el servicio de gitHub debes crear una llave SSH que se almacena en la carpta .ssh de tu home.

mkdir respaldo
mv ~/.ssh/id_rsa* respaldo
ssh-keygen -t rsa -C "cuenta@gmail.com"

Después lo que nos pedirá será la ruta donde almacenar la llave que por defecto es .ssh de tu home, basta con darle Enter y luego una frase tipo password que hay que indicar dos veces

Generating public/private rsa key pair. 

Enter file in which to save the key (/home/tu_directorio/.ssh/id_rsa):<presiona enter>

Enter passphrase (empty for no passphrase): <ingresa una contraseña> 

Enter same passphrase again: <repite la contraseña> 

El resultado sería algo como esto:

Your identification has been saved in /home/tu_directorio/.ssh/id_rsa

Your public key has been saved in /home/tu_directorio/.ssh/id_rsa.pub 

The key fingerprint is:

01:ff:f4:2a:ca:37:dd:aa:a1:bb:f0:cc:08:f0:23:dc  tunick@gmail.com

The key's randomart image is:

+--[ RSA 2048]----+

|     .+   +      |

|     o o =       |

|       = o O .   |

|       o = +     |

|     o o =       |

|      o S .      |

|      o . E      |

|     o o =       |

|                 |

|                 |

+-----------------+

Puedes ver el contenido del archivo que se acaba de generar (/home/tu_directorio/.ssh/id_rsa.pub):

ssh-rsa AAAAB3NzaC1yc2EAAAADQAERYSFVDGoORPfVQ5kX3gdW08/2Qi8za7p9W4UQH7VOVb84sWlPcIehA+9WUlah1elxT8Img4LNmloUY6rccRcoTWBaqyL8AbhNtEKD3EylNqK4uLF3Omm/QcXphjDpsb5HKl00nVAdhprvogAgCp98743ERT#$MyWRR+PnDW8KJvOKt+EJ8RD2Dhk5WEYp3GsN4MHxF/eUDOlwnJx58d7UmdyDz74rDB3v4NqQKk+KvTjPtG2yI3K4gDCLp/+XfwkjGw0+sOwnuRNlurb0joZv3h2qWJRj5RhWk1Wel+hCOGfXXc0A0TaX3Eim9L415bZg9QHQEmXK5QgvZO7H8YsdN tunick@gmail.com

Ahora vete a la configuración de la cuenta, SSH Keys y da clic en agregar una nueva llave.

https://github.com/settings/ssh

En la ventana que aparece, coloca un titulo para darle un nombre a la llave y en el contenido pega todo el texto que se encuentra dentro de /home/tu_directorio/.ssh/id_rsa.pub y luego da clic en Agregar.

Para comprobar que te puedas conectar con gitHub debes ejecutar el comando de abajo y cuando te pregunte si desas seguir conectando, respondes con "yes". Deberás recibir una respuesta como la que sigue.

ssh -T git@github.com

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

3.- Crear un repositorio

Es muy sencillo, basta ir a https://github.com/new e indicar un nombre para repositorio que no haya usado nadie más, agregar una descripción del proyecto, indicar que será público y luego dar clic en "Crear repositorio".

Como resultado tendrás una página donde te muestra una liga parecida a la de abajo y usando el nombre del proyecto que acabas de agregar

git@github.com:tu_nick/tu_proyecto.git

4.- Subir tu proyecto

Debes crear una carpeta nueva para tu proyecto y luego iniciarlizarlo con git.

$ mkdir miProyecto

$ cd miProyecto

$ git init

Initialized empty Git repository in ../miProyecto/.git.

$ git remote add origin git@github.com:tu_nick/tu_proyecto.git remote add origin dasdfasdfasdfgit@github.com:username/Hello-World.git

La última línea relaciona tu actual directorio con la ruta de repositorio que acabas de crear y le agrega el alias "origin". Por defecto, todos los cambios que hagas con commit se agregarán a la copia del repositorio local (llamado master) pero si quieres ver reflejados los cambios en el repositorio remoto deberás usar push.
Ejemplo:

$ echo "Este proyecto es una prueba del uso de gitHub" > README

$ git add README

$ git commit README -m"Este es mi primer archivo que agrego"

$ git push origin master

De esta manera puedes ir agregando elementos a tu proyecto y subiendolos al repositorio.

5.- Otros comandos que debes saber

Para descargar una copia del repositorio remoto (como hacer un checkout en SVN):

$ git clone usuario@192.168.0.1:/ruta/al/proyecto

que sería lo mismo con un proyecto en gitHub

$ git clone git@github.com:tu_nick/tu_proyecto.git

Para actualizar el repositorio (envia los cambios de master a origin):

$ git push -u origin master

Para ver todos los cambios, ver el log:

$ git log 

Para ver los cambios entre la version anterior y la actual:

$ git show 

Para ver todos los archivos con cambios y pendientes de subir:

$ git status 

Para crear un branch

$ git branch nombreBranch -m"Un mensaje descriptivo"

Para crear un tag (cuando se hace un push para subir los cambios al repositorio remoto, no toma en cuenta los tags creados, es un comportamiento por defecto, por lo que si queremos subir un tag hay que usar el parametro --tags):

$ git tag -a nombreTag -m"Un mensaje descriptivo" 

Para hacer un switch a otro branch:

$ git checkout nombreBranch

Fuentes:

Creacion de un proyecto base con Grails 2.0.3

2012-05-04T11:04:00.002-07:00

Vamos a crear un proyecto web base para una aplicación que podría usar un kinder considerando solo poder hacer Altas Bajas y Cambios (ABC) de dos entidades Tutores y Alumnos. Yo trabajaré en un Linux Mint, las instrucciones en consola son similares en cualquier distribución derivada de Debian o Ubuntu, para windows solo cambiarían las carpetas y las variables de entorno.

Empecemos instalando Grails.

Necesitamos tener instalado java y haber definido nuestra variable de entorno JAVA_HOME.

Descargar grails
Descomprimir ZIP en una carpeta (la mia será /opt )
Crear las variables de entorno GRAILS_HOME y JAVA_HOME (si no existe)

export GRAILS_HOME=/opt/grails-2.0.3
export PATH=$PATH:/opt/grails-2.0.3/bin

Para comprobar que nuestra instalación está completa debemos ejecutar el comando grails para obtener la versión. En algunos sistemas como el mío se requiere reiniciar la sesión de usuario para que se apliquen los cambios en las variables de entorno.

$ grails -version
Grails version: 2.0.3

Ahora creamos nuestra aplicación, se genera una carpeta con el nombre de la aplicación, ingresamos a dicha carpeta y luego abrimos la consola de grails.

$ grails create-app kinder
| Created Grails Application at /home/wdonet/branches/grails/kinder
$ cd kinder/
$ ls
application.properties  grails-app  lib  scripts  src  test  web-app
$ grails
| Downloading: plugins-list.xml
grails> help

Podemos usar el comando help para ver todos los comandos que tenemos disponibles en la consola de grails, incluso puedes obtener ayuda de un comando en especifico escribiendo por ejemplo : help create-app. Pero toma nota que la consola de grails es una forma para jugar con el ambiente de tu proyecto, si quieres ejecutar tu aplicación es mejor usar el comando grails (fuera de la consola).

Como yo utilizo IntelliJIDEA como IDE para desarrollo, le voy a agregar el soporte para este IDE al proyecto, pero no es necesario, si usas eclipse, STS u otro, este paso no es necesario ya que Grails genera por defecto el archivo de configuración para abrir el proyecto en eclipse.

grails> integrate-with --intellij
| Created IntelliJ project files..

Convención sobre la configuración

Algo que debemos entender antes de continuar, por si no lo sabías, es el concepto de "Convention over configuration". Grails usa esta convención para configurarse a sí mismo, en otras palabras, cada nombre y ubicación de los archivos es usado como parte de la configuración de la aplicación en lugar de explicitamente declararlo en algun lado. Por tanto, es necesario que te familiarises con la estructura de directorios que se generó en el proyecto que acabamos de crear.

Los elementos dentro de la carpeta kinder son:

grails-app - el directorio más alto que contiene todas tus fuentes

conf - configuración en general.
controllers - aquí se guardan los controladores web.
domain - las clases de dominio.
i18n - soporte para la internacionalización (i18n).
services - la capa de servicios.
taglib - librerías de etiquetas o (tag libraries).
utils - utilerías específicas de Grails.
views - la configuración de las vistas ó Groovy Server Pages (.gsp).

scripts - scripts de Gant.
src - tu código fuente

groovy - fuentes en lenguaje Groovy
java - fuentes en lenguaje Java

test - Pruebas unitarias y de integración.

Configurar la Base de Datos

Como todo sistema, necesitamos de un lugar donde almacenar nuestros datos y en este caso usaremos MySQL con el driver 5.1.18.

Debes editar el archivo kinder/grails-app/conf/BuildConfig.groovy.

(optativo) Descomentar, en repositorios, la linea mavenLocal() si ya tienes instalado maven en tu equipo, Grails se beneficia del repositorio local en tu máquina, sino usa por defecto los repositorios centrales de Grails y Maven.
Descomentar, dentro de las dependencias, la linea runtime 'mysql:mysql-connector-java:X.X.X' y sustituir la versión actual por la 5.1.18.

Debes editar el archivo kinder/grails-app/conf/DataSource.groovy.

Agregar los datos de conexión a tu base de datos

dataSource {
    dbCreate = "update"

    driverClassName = "com.mysql.jdbc.Driver"
    username = "root"

    password = "admin"
}
 

environments {
    development {
        dataSource {
            url = "jdbc:mysql://localhost/kinder"
        }
    }
    test {
        dataSource {
            url = "jdbc:mysql://pruebas/kinder"
        }
    }
    production {
        dataSource {
            url = "jdbc:mysql://produccion/kinder"
            username = "usuario_produccion"
            password = "pass_produccion"
        }
    }
}
Como solamente usaremos el ambiente desarrollo (el default), basta con dejar toda la configuración en datasource o development. Pero el ejemplo muestra que el datasource externo define las propiedades comunes y los datasource internos de development, test y production sobreescriben la configuración externa, por ejemplo la url del ambiente donde se va a conectar.

La propiedad dbCreate puede tener cualquiera de los siguientes valores:

create, elimina el esquema actual y luego lo crea cuando levanta la aplicación.
create-drop, igual que la anterior solo que elimina el esquema al terminar la aplicación.
update, crea nuevas tablas, agrega indices o columnas que falten, no borra tablas, columnas, ni datos. Pero toma en cuenta que no soportara muchos cambios y ahí convendria un create primero.
validate, no crea nada ni borra nada, pero valida la similitud de tu configuración con lo que ya existe en la BD. Si hay diferencias envía warnings!.
cualquier otro valor, no hace nada.

A programar !

La parte central de la mayoría de proyectos Grails es su modelo de dominio el cual representa la capa de persistencia de los datos y esto es tan sencillo como crear clases de dominio que mapean las tablas en una Base de Datos.

Por esa razón vamos a crear las clases de dominio principales: Alumno, Tutor y un par de catalogos: Grupo, Estado, Municipio y Postal. Las instrucciones se vuelven repetitivas para cada clase así que es probable que no las coloque en todas las secciones pero sin duda debes considerarlas.

Diagrama de Clases y sus relaciones entre sí. Da clic para ver en grande

$ grails create-domain-class mx.com.kinder.Alumno
| Created file grails-app/domain/mx/com/kinder/Alumno.groovy
| Created file test/unit/mx/com/kinder/AlumnoTests.groovy
$ grails create-domain-class Tutor
| Created file grails-app/domain/mx/com/kinder/Tutor.groovy
| Created file test/unit/mx/com/kinder/TutorTests.groovy
Hacer lo mismo para el resto de clases y luego agregar sus propiedades a mano.

Agrega a la clase Tutor:

package mx.com.kinder

import mx.com.kinder.dto.Nombre
import mx.com.kinder.dto.Direccion

class Tutor {
    Nombre nombre
    Estado estado
    Municipio municipio
    Postal postal
    Direccion direccion
    Date fechaNacimiento
    String mail
    String telefonoCasa
    String telefonoOficina
    String telefonoCelular

    //para embeber los tres campos de nombres, paterno y materno en un DTO
    // o todos los campos de la direccion en un solo DTO
    static embedded = ['nombre', 'direccion']

    //el orden de los campos en constraints define el orden de los
    // elementos en la vista que se generara después.
    static constraints = {
        nombre()
        direccion(nullable: false)
        estado(nullable: false)
        municipio(nullable: false)
        postal(nullable: false)
        fechaNacimiento nullable: false
        mail email: true, blank: false, nullable: true
        telefonoCasa()
        telefonoOficina()
        telefonoCelular()
    }

}

Observa que los atributos de la clase en realidad son propiedades dado que Grails le inyecta automáticamente sus métodos getters y setters correspondientes, además se determina el nombre de la Tabla como el nombre de la clase y el nombre de las columnas como el nombre de cada propiedad. La creación de estos elementos en la Base de Datos se hace de manera automática cuando se levante la aplicación.

Los constraints son validaciones que se ejecutan antes de la persistencia de los datos, para el caso de Tutor por ejemplo, ningún elemento de la dirección puede ser nulo; el mail si puede ser nulo pero no debe tener solo espacios, además se valida que la estructura del mail sea la de un correo con "email: true".

Agrega a la clase Alumno:

package mx.com.kinder

import mx.com.kinder.dto.Nombre
import mx.com.kinder.dto.Direccion

class Alumno {

    Nombre nombre
    Date fechaNacimiento
    Grupo grupo
    Tutor papa
    Tutor mama
    Direccion direccion

    static embedded = ['nombre', 'direccion']

    static constraints = {
        nombre()
        grupo()
        fechaNacimiento()
        papa()
        mama()
        direccion()
    }
}

Debemos crear ahora los controladores (capa de clases que sirven de interfaz entre la vista web y la capa de persistencia - base de datos). Grails puede generar los metodos del controller de forma automática a manera que queden programadas como servicios REST que se pueden exponer via web. Toma en cuenta que el controlador se genera con base en las propiedades de la entidad.

$ grails create-controller mx.com.kinder.Alumno

$ grails create-controller mx.com.kinder.Tutor

$ grails create-controller mx.com.kinder.Estado

$ grails create-controller mx.com.kinder.Municipio

$ grails create-controller mx.com.kinder.Postal

, o bien, usar una funcionalidad denominada scaffolding, que se encarga de crear en tiempo de ejecución una interfaz web tipo ABC (vista con Altas, Bajas y Cambios) para la clase de dominio indicada.

$ grails create-scaffold-controller mx.com.kinder.Estado

Esto generará la clase como sigue (Ojo, solo escoge uno de los dos comandos: create-controller ó create-scaffold-controller):

package mx.com.kinder

class EstadoController {

    static scaffold = Estado  //tambien funciona si colocas el valor: true
}

Esta funcionalidad se encargará de generar las operaciones abajo listadas para manipular los datos de esa entidad en la Base de Datos. Es de notar que el controlador se llama igual que la clase de dominio, salvo por la terminación "Controller", esto es importante ya que se usa para determinar que esta clase es un controlador de la clase de dominio. A pesar de que se tenga el scaffolding activado, se pueden sobreescribir los métodos para afinar su comportamiento.

list
show
edit
delete
create
save
update

Por último y antes de levantar nuestra aplicación quizá nos ayude tener algunos datos iniciales, por ejemplo de Catalogos como el de Estado (el cual solo contiene dos elementos ademas del identificador: el nombre y si esta activo). Existe una clase Groovy que podemos usar para tal efecto: BootStrap.groovy y se implementaría mas o menos así:

import mx.com.kinder.Estado
class BootStrap {
  def init = { servletContext ->
    environments {
      development {
        if (!Estado.count()) {
          ["Aguascalientes", "Baja California", "Baja California Sur", "Campeche",
           "Coahuila de Zaragoza", "Colima", "Chiapas", "Chihuahua", "Distrito Federal",
           "Durango", "Guanajuato", "Guerrero", "Hidalgo", "Jalisco", "Mexico",
           "Michoacan de Ocampo", "Morelos", "Nayarit", "Nuevo Leon", "Oaxaca", "Puebla",
           "Queretaro de Arteaga", "Quintana Roo", "San Luis Potosi", "Sinaloa", "Sonora",
           "Tabasco", "Tamaulipas", "Tlaxcala", "Veracruz", "Yucatan", "Zacatecas"].each {
              new Estado(nombre: it, activo: true).save(failOnError: true)
           }
        }
      }
    }
  }
  def destroy = {}
}

Como ven, tiene dos fases; init se encarga de ejecutar el codigo dependiendo el ambiente indicado al levantar la aplicación y destroy trata de ejectuar algun proceso cuando la aplicación se dé de baja o por terminada. En este caso estamos llenando de datos el catalogo de Estado solo si no existiese ningun dato en la tabla.

Si no se desea especificar ambiente, se puede prescindir de environments y el proceso lo ejecutará cuando levante para cualquier ambiente.

Casi hemos terminado esta base de proyecto, tan solo falta generar las vistas, podemos hacer uso del comando generate-views para generar los archivos .gsp que hacen uso de jquery y hacen la funcion del Front (vista) al usuario de la aplicación.

$ grails generate-views mx.com.kinder.Estado

$ grails generate-views mx.com.kinder.Municipio

$ grails generate-views mx.com.kinder.Postal

$ grails generate-views mx.com.kinder.Alumno

$ grails generate-views mx.com.kinder.Tutor

Cada comando generará una carpeta dentro de views con el nombre de cada clase de dominio y adentro 5 archivos .gsp: un template (_form.gsp), y cuatro paginas create.gsp, edit.gsp, list.gsp y show.gsp con el fin de lograr la funcionalidad ABC de cada clase de dominio.

JQuery

Si quieres jugar con este script, Grails 2.0.3 incluye como plugin por defecto la version 1.7.1 de jquery. Pero para poder acceder a sus funciones debes incluir la linea siguiente en el archivo /grails-app/views/layouts/main.gsp, dentro de la etiqueta <head> y antes de la línea que dice <r:layoutresources/> :

<g:javascript library="jquery" plugin="jquery"/>

Luego, en cada página gsp donde quieras ejecutar codigo de jQuery debes incluir el siguiente script dentro de la etiqueta <head>, (si usas el clasico tag <script> no funcionará porque al momento de que Grails renderea la página, coloca este tag antes del include de la librería de jQuery, por lo que el código que coloques aquí no funcionará - por tanto es forzoso usar <g:javascript>):

    <g:javascript>
        $(document).ready(function() {
            alert('si funciona mi codigo de JQuery')
        })
    </g:javascript>

O la otra alternativa es:

    <r:script disposition='head'>
    </r:script>

Ambos scripts renderean a una etiqueta <script>, solo que <g:javascript> coloca el código dentro y al final de la etiqueta <body>, mientras que <r:script> lo coloca dentro de la etiqueta .

Ejecutar la aplicación

El comando run-app levanta la aplicación usando un tomcat con el puerto 8080 por defecto, pero se lo podemos cambiar si especificamos la variable "server.port". Para salir debes dar CTL+C.

$ grails -Dserver.port=8090 run-app

Pero como esto no es lo óptimo para un ambiente de producción, sino instalarlo en un servidor aparte, podemos usar el comando war para generar el WAR con la configuración de producción por defecto y luego montarlo manualmente en cualquier servidor que soporte la version 2.5 de servlets (Por ejemplo: Tomcat,6,7; GlasFish 2,3; Resin 3,4; JBoss 5,6; Jetty 6,7; Websphere 6.1,7; Weblogic 9,10,10.3; SpringSourc tc Server).

Para ver la aplicación ejecutándose ve a la siguiente url:

http://localhost:8080/kinder

Se debería ver algo como esto.

Fuentes:

Sitio oficial de Grails

Documentos de referencia

The Quick Start

http://grails.org/doc/2.0.3/ref/

API jQuery

Descargar el código fuente de esta demo

Clases embebidas en Grails

2012-04-30T15:57:00.001-07:00

En Grails se pueden mapear clases a entidades simplemente ubicándolas en un paquete dentro de la carpeta /grails-app/domain como se muestra abajo. Mapeando la clase y atributos a una tabla y columnas con un mismo nombre si no se le especifica otra cosa con la propiedad mapping.

import mx.com.proyecto
class Tutor {
    String nombres
    String paterno
    String materno
    Integer edad
    static constraints = {
        nombres maxSize: 150, nullable: false, blank: false
        paterno maxSize: 80, nullable: false, blank: false
        materno maxSize: 80, nullable: true, blank: false
    }
}

Pero quizá nos interese tener nuestra entidad un poco mas amigable y legible agrupando los tres elementos nombres, paterno y materno dentro de un mismo POJO y seguirla mapeando a las mismas columnas de una sola tabla.

La regla de oro está en definir el POJO en el mismo archivo Tutor.groovy o en un archivo separado pero dentro de la carpeta /src/groovy/ (Nombre.groovy).

/grails-app/domain/Tutor.groovy

import mx.com.proyecto
class Tutor {
    Nombre nombre
    Integer edad
}

/src/groovy/Nombre.groovy

import mx.com.proyecto
class Nombre {
    String nombres
    String paterno
    String materno
    static constraints = {
        nombres maxSize: 150, nullable: false, blank: false
        paterno maxSize: 80, nullable: false, blank: false
        materno maxSize: 80, nullable: true, blank: false
    }
    static mapping = {
        nombres column: 'nombres'
        paterno column: 'paterno'
        materno column: 'materno'
    }
}

Si no colocamos el apartado mapping en la nueva clase Nombre e indicando como se mapearían las propiedades a las columnas de la tabla, los nombres de columna que tendríamos en la tabla serían:

[nombreDePropiedadTutor] + _ + [nombreDePropiedadNombre]

Esto es: nombre_nombres, nombre_paterno y nombre_materno, lo cual funcionaría solo para cuando quieras embeber el mismo POJO varias veces en la misma entidad.

Tu puedes seguir haciendo búsquedas con las propiedades de ese objeto, instanciando un objeto y asignando el valor en la propiedad que te interesa usar para buscar en la tabla Tutor. Por ejemplo:

    Nombre rebeca = new Nombre()
    rebeca.setNombres('rebeca')
    Tutor.findAllByNombre(rebeca)

También puedes agregar métodos que te permita operar con las columnas de Nombre, ejemplo:

    String obtenerPorNombre() {
        return nombres + ' ' + paterno + ' ' + materno
    }

    String obtenerPorPaterno() {
        return paterno + ' ' + materno + ' ' + nombres
    }

Fuentes:

Sitio oficial Grails

Introducción a MongoDB

2012-04-26T17:56:00.000-07:00

Me metí un poco a ver como funcionaba CouchDB pero entre revisiones y vistas rápidas a referencias aquí y allá llegue a MongoDB, ambas son alternativas No-SQL (termino que empezó a agarrar fama desde 2009) y que su almacenamiento de datos está orientado a documentos JSON y BSON (Bynary JSON) para ofrecer sistemas flexibles, rápidos, ligeros, potentes y fáciles de usar.

Según Eliot Horowitz, 10gen CTO y co-fundador de mongoDB, prácticamente podrías tomar una base de datos hecha en MySQL, cambias el modelo relacional a uno basado en documentos y obtendrías varias mejoras como:

Documentos embebidos para mejorar la velocidad

El uso de json es más amigables con objetos en lenguajes de programación
El meter documentos embebidos y arreglos reduce la necesidad de hacer joins

Manejabilidad
Desarrollo ágil con base de datos sin esquemas

Al usar JSON/BSON es fácil de codificar y administrar

Escalabilidad horizontal más facil

Es una solución para sistemas que requieren escalar horizontalmente sobre varios servidores.
La funcionalidad de autosharding permite escalar tu cluster agregando mas equipos sin necesidad de dar de baja el servicio.

En realidad no estamos quitando todo el trabajo que ya se ha hecho con las bases de datos relacionales porque en muchas cosas como la creación de indices, llaves primarias, consultas dinámicas y actualizaciones, por mencionar algunas, se tiene que hacer los mismo, salvo que se busca tener las ventajas arriba descritas.

La gente de apache que desarrolla CouchDB mencionan que los esquemas relacionales funcionarán en algunos casos mientras que los esquemas no-SQL funcionarán en otros.

El modelo de datos de MongoDB considera lo siguiente:

Un sistema mongo contiene un conjunto de bases de datos.
Una base de datos (database) contiene un conjunto de colecciones.
Una colección (collection) contiene un conjunto de documentos.
Un documento (document) es un conjunto de campos.
Un campo (field) es un par llave - valor.
Una llave (key) es un nombre en forma de cadena.
Un valor (value) es:

un tipo de dato básico, string, integer, float, timestamp, binary, etc.,
otro documento, ó
un arreglo de valores

El lenguaje de consulta

Al tratar con objetos json la estructura de un nombre podria ser: {nombre: 'Sebastian', paterno: 'Morales'}, esta estructura se puede usar por ejemplo para buscar todos los documentos (registros) de una colección (tabla) que empaten con el nombre "Sebastian Morales", pero también podemos hacer lo siguiente:

{nombre.paterno: 'Morales'}, para obtener los que tengan apellidos 'Morales'.
{nombre.paterno: /^M/}, para obtener los que tengan apellidos que inicien con 'M'
{keywords: 'tecnico'}, para los documentos con 'tecnico' dentro del contenido del arreglo
{keywords: {$in:['tecnico', 'licenciado']}, para los documentos con 'tecnico' o licenciado dentro del contenido del arreglo.

Si tenemos muchos documentos en una colección y queremos mejorar la velocidad de búsqueda de las consultas, crearemos índices comose muestra abajo, pero hay que tomar en cuenta que se ocupa mas espacio y reduce la velocidad de los 'update'.

ensureIndex({nombre.apellido:1})
ensureIndex({keywords: 1})

Instalación y primeros ejemplos

Aunque los procesos de instalación son diferentes para cada S.O. yo presentaré el que realicé en Linux Mint. Debo comentar que el sitio de MongoDB recomienda que se descargue la última version de sus servidores ya que los repositorios de Debian o Ubuntu no se encuentran del todo actualizados, no obstante para propositos de esta entrada nos basta seguir lo siguiente:

sudo apt-get install mongodb

Entre los comandos que se instalarán se encuentran mongod (servidor) y mongo (cliente). Este último debe ser el usado para entrar a la consola y ejecutar consultas al servidor.

mongo
> db.alumno.save({nombre:'julian', paterno:'rodriguez', edad:12, grupo:'2A'})
> db.alumno.find()
{ "_id" : ObjectId("4f99d713b16869a4f4d5abd9"), "nombre" : "julian", "paterno" : "rodriguez", "edad" : 12, "grupo" : "2A" }
> help

Con db.alumno.save() creamos la colección alumno y agregamos el primer documento con el nombre de julian, luego lo consultamos con db.alumno.find() y para ver mas ayuda sobre los comandos ejecuta help.

Por defecto, el comando mongo se conecta a una base de datos llamada "test" en localhost, por eso al ejecutar el comando mongo, verían algo como esto:
wdonet@wdonet-mint12 ~ $ mongo
MongoDB shell version: 1.8.2
Thu Apr 26 17:06:35 *** warning: spider monkey build without utf8 support. consider rebuilding with utf8 support
connecting to: test
> db
test
> use miPropiaBD
switched to db miBD
> db
miPropiaBD

Usamos el comando use para poder cambiar la base de datos y lo comprobamos con el comando db o con show dbs. Esto no crea inmediatamente la BD, sino hasta que por primera vez le insertas datos. El comando show no mostrará la nueva BD hasta que insertes datos. Lo mismo sucede con las colecciones.

En MongoDB no hay campos predefinidos (lo que serían columnas en un RDBMS), tampoco hay esquemas definidos para dichos campos por lo que sus tipos de dato pueden variar y las colecciones pueden guardar diferenets campos.

> j = { nombre : "roberto"};
{ "nombre" : "roberto" }
> t = {edad : 30}
{ "edad" : 30 }
> db.nuevaColeccion.save({j, t})
Thu Apr 26 19:25:15 SyntaxError: invalid object initializer (shell):1
> db.nuevaColeccion.save(j)
> db.nuevaColeccion.save(t)
> db.nuevaColeccion.find()
{ "_id" : ObjectId("4f99e77c00745aa18f47cb08"), "nombre" : "oswaldo" }
{ "_id" : ObjectId("4f99e77e00745aa18f47cb09"), "edad" : 30 }
>

Cada vez que se inserta un documento en la colleccion, se crea un identificador del objeto "_id" que es diferente para cada documento, funciona como una llave primaria.

También es de observar que los ';' son para terminar una instrucción, pero si solo es una por línea, no son necesarios. Otro conveniente es que podemos usar ciclos y operaciones matemáticas como el que sigue:

> for (var i = 0; i <= 5; i++) db.nuevaColeccion.save({x: i*i, y: i+i});
> db.nuevaColeccion.find()
{ "_id" : ObjectId("4f99e77c00745aa18f47cb08"), "nombre" : "roberto" }
{ "_id" : ObjectId("4f99e77e00745aa18f47cb09"), "edad" : 30 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0a"), "x" : 0, "y" : 0 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0b"), "x" : 1, "y" : 2 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0c"), "x" : 4, "y" : 4 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0d"), "x" : 9, "y" : 6 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0e"), "x" : 16, "y" : 8 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0f"), "x" : 25, "y" : 10 }

El comando find() devuelve un objeto cursor, pero esta limitado a 20 resultados por pagina, si tuvieramos más de 20 documentos y quisieramos ver la siguiente página de resultados, deberíamos ejecutar "it" para que el shell itere automáticamente sobre el cursor

> it

Podemos jugar un poco con un cursor mediante metodos hasNext() o forEach(), e imprimimos con el método printjson().

> var cursor = db.nuevaColeccion.find();
> while (cursor.hasNext()) printjson(cursor.next())
{ "_id" : ObjectId("4f99e77c00745aa18f47cb08"), "nombre" : "roberto" }
{ "_id" : ObjectId("4f99e77e00745aa18f47cb09"), "edad" : 30 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0a"), "x" : 0, "y" : 0 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0b"), "x" : 1, "y" : 2 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0c"), "x" : 4, "y" : 4 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0d"), "x" : 9, "y" : 6 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0e"), "x" : 16, "y" : 8 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0f"), "x" : 25, "y" : 10 }
>
> db.nuevaColeccion.find().forEach(printjson);
{ "_id" : ObjectId("4f99e77c00745aa18f47cb08"), "nombre" : "roberto" }
{ "_id" : ObjectId("4f99e77e00745aa18f47cb09"), "edad" : 30 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0a"), "x" : 0, "y" : 0 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0b"), "x" : 1, "y" : 2 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0c"), "x" : 4, "y" : 4 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0d"), "x" : 9, "y" : 6 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0e"), "x" : 16, "y" : 8 }
{ "_id" : ObjectId("4f99e96600745aa18f47cb0f"), "x" : 25, "y" : 10 }>
> var cursor = db.nuevaColeccion.find();
> printjson(cursor[1])
{ "_id" : ObjectId("4f99e77e00745aa18f47cb09"), "edad" : 30 }

Los resultados del cursor se almacenan en memoria, por lo que hay que tener cuidado con resultados con muchos documentos.

Por último, para el propósito de introducción de esta entrada, podemos convertirlo en un verdadero arreglo como sigue:

> var arreglo = db.nuevaColeccion.find().toArray();
> printjson(arreglo[1])
{ "_id" : ObjectId("4f99e77e00745aa18f47cb09"), "edad" : 30 }

Para salir:

> exit;

Fuentes:

www.mongodb.org
Api para js
Mapeo SQL - MongoDB
Cliente Grafico JMongoBrowser (linux/windows/mac)
MongoDB vs CouchDB

Introducción a PostgreSQL

2012-04-25T17:04:00.001-07:00

Hace un par de días me tuve que meter con PostgreSQL (versión 9.1.3) a manera de conocerlo un poquito ya que no sabía nada y me encontré con algunos detalles.

Para su instalación en Linux Mint o Ubuntu debemos hacer lo siguiente.

sudo apt-get install postgresql libpq-dev (instala el motor y un usuario postgress con todos los privilegios para operar sobre el servidor)
sudo su postgress (esto te permite abrir una sesion con el nuevo usuario postgress)

createuser -d -s -P usuario , creamos un usuario donde:

-d es para darle permisos de creación de base de datos
-s es para darle permisos de superusuario
-P para poderle indicar un password al usuario

exit

sudo apt-get install pgadmin3 - para instalar el cliente gráfico (opcional)

Detalles de interés que se podrán observar en las instrucciones de ejemplo que copio mas adelante:

La diferencia contra otros manejadores de Base de Datos es que se puede hacer herencia entre tablas.
Cuando se heredan las tablas, las llaves primarias se tienen que redefinir dado que estas no se heredan.
Cuando se borran las tablas, los índices también se eliminan de forma automática.
Cuando se hacen muchas operaciones de creación/borrado en la base de datos, es necesario darle mantenimiento (opción vacuum en el pgadmin3).
La sintaxis para las fechas siempre es: YYYY-MM-DD.

Vamos a los ejemplos ahora sí:

-- Eliminamos la vista
DROP VIEW if exists dime_sus_tutores, dime_personas_sin_cel;

-- Eliminamos indices primero (aunque cuando se borran las tablas estos ya se eliminan)
DROP INDEX if exists idx_clave_escolar;

-- Eliminamos las tablas
drop table if exists
 tutores, personas, alumnos, tutores_alumnos;
 
-- Tabla personas PADRE
create table personas (
 id integer PRIMARY KEY,
 nombres varchar(75) not null,
 genero varchar(1),
 fecha_nacimiento date,
 lugar_nacimiento varchar(150),
 curp varchar(18) unique,
 tel varchar(20),
 cel varchar(20),
 email varchar(50),
 cuando date default current_date
);

-- Tabla hija de personas
create table tutores(
 id integer primary key,
 ocupacion varchar(100)
) inherits (personas);

-- Tutores
insert into tutores (id, nombres, genero, fecha_nacimiento, lugar_nacimiento, cel, ocupacion) values
 (1, 'Ricardo Rogers', 'm', '1970-01-10', 'Ciudad de México', '0445554374879', 'Musico'),
 (2, 'Guillermo Garcia', 'm', '1971-04-12', 'Tlaxcala', '044 55 94637383', 'Contador'),
 (3, 'Pita Perez', 'f', '1964-05-22', 'Ciudad de México', null, 'Ama de casa');

-- Tabla hija de personas
create table alumnos (
 id integer primary key,
 clave_escolar varchar(25),
 fecha_ingreso date,
 carrera varchar(50)
) inherits (personas);

-- Creacion de un indice
create unique index idx_clave_escolar on alumnos(clave_escolar);

insert into alumnos
 (id, nombres, genero, fecha_nacimiento, lugar_nacimiento, cel, clave_escolar, fecha_ingreso, carrera) values
 (4, 'Leonora Rogers Mendoza', 'f', '1994-01-10', 'Ciudad de México', '044 55 12345678', 'a100-101', '2011-08-14', 'informatica'),
 (5, 'Maximiliano Hotel', 'm', '1993-04-12', 'Tlaxcala', '044 55 87654321', 'b200-202', '2011-07-13', 'contaduría'),
 (6, 'Lupita Gómez Pérez', 'f', '1993-02-22', 'Ciudad de México', null, 'c300-303', '2011-06-12', 'contaduría'),
 (7, 'Arturo Gómez Pérez', 'm', '1994-05-22', 'Ciudad de México', null, 'd400-404', '2011-05-11', 'administración')
 ;

-- Tabla que relaciona personas y tutores
create table tutores_alumnos (
 id_tutor integer REFERENCES tutores(id),
 id_alumno integer references alumnos(id),
 primary key (id_tutor, id_alumno)
);

-- relaciones
insert into tutores_alumnos values (1,4),(2,5),(3,6),(3,7);


-- una vista
create view dime_sus_tutores as
 select a.nombres as Alumno, a.clave_escolar as Clave, t.nombres as Tutor, t.cel
 from tutores_alumnos ta
 left join alumnos a on ta.id_alumno = a.id
 right join tutores t on ta.id_tutor = t.id
 order by a.nombres
;

-- otra vista
create view dime_personas_sin_cel as
 select p.id, p.nombres, p.tableoid, c.relname
 from personas p, pg_class c
 where cel is null
 and p.tableoid = c.oid
;

Fuentes:

@mromtz - Mario Martinez -- Taller de PostgreSQL --
2 módulos de un curso en línea
Comandos de administracion
www.postgresql.org

Usando una conexión a base de datos distinta en un subreporte de JasperReports

2012-03-06T20:04:00.002-08:00

Al incluir un subreporte en JasperReports por default éste utiliza la misma conexión a base de datos que el reporte maestro que contiene el subreporte.

Sin embargo, a veces es deseable que el subreporte se conecte a una base de datos diferente.

Una manera de lograrlo es la siguiente:

Incluir el subreporte como cualquier otro
Agregar un parametro, que en este ejemplo llamaré SUBREPORT_CONNECTION, con Parameter Class = java.sql.Connection , no usar prompt,Default value expression = java.sql.DriverManager.getConnection("jdbc:mysql://localhost:3306/base_de_datos", "usuario", "password")[Obviamente, editar la url para que coincida con el motor de BD usado, nombre de base, puerto, host y demas datos]
En las propiedades del subreporte,Connection type = Use a connection expression,
Connection expression = $P{SUBREPORT_CONNECTION}(o como sea que se le haya nombrado al parámetro del inciso anterior)
Si al intentar generar el reporte, aparece un error del tipo "No suitable driver found for jdbc:mysql://localhost:3306/base_de_datos", puede funcionar agregar un parametro mas, que se cargue antes del de SUBREPORT_CONNECTION (en iReport se pueden acomodar el orden de los parámetros y ese es el orden de carga también), que no use prompt, que
Parameter Class = java.lang.Classy con
Default value expression = Class.forName("com.mysql.jdbc.Driver").getName()[O como sea que se llame la clase Driver del manejador de BD utilizado...]
Por último, si aún con esto surge una excepción ClassNotFoundException para, en este ejemplo, com.mysql.jdbc.Driver, se puede copiar el jar al subdirectorio jre/lib/ext de donde se encuentre instalada la máquina virtual que use JasperReports para compilar los reportes.

Usando una base de datos SQLite en un proyecto de Symfony2

2012-03-03T19:01:00.003-08:00

Para configurar una base de datos en un proyecto de Symfony2, se edita el archivo app/config/parameters.ini:

[parameters]
database_driver = pdo_sqlite
database_host = localhost
database_port =
database_name = test_project.db
database_user = root
database_password =

Sin embargo, con esta configuración, que es la default para usar cualquier otro motor de base de datos con Doctrine2 (incluido en cualquier instalación estándar de Symfony2), una base de datos SQLite no funciona.

Lo correcto es, primero, editar y agregar una línea en app/config/config.yml:

doctrine:
dbal:
driver: %database_driver%
host: %database_host%
port: %database_port%
dbname: %database_name%
user: %database_user%
password: %database_password%
path: %database_path%
charset: UTF8

Esta línea no se encuentra originalmente en el archivo, se agrega para que Doctrine utilice el parámetro 'database_path', que ahora se agrega a parameters.ini:

[parameters]

database_driver = pdo_sqlite

database_host = localhost

database_port =

database_name = test_project.db

database_user =

database_password =

database_path = /path_to_my_project/app/db/test_project.db

Y con eso, la base de datos queda creada en el path establecido. Notar que para servidores Unix (Linux por ejemplo), este archivo debe quedar con permisos de lectura/escritura por parte del usuario que utilice el servidor web (cualquiera que este sea, http, www-data o lo que sea): Y el directorio donde reside el archivo tambien debe tener permisos de lectura, escritura y ejecución para este mismo usuario (en este caso, el subdirectorio db que yo puse aquí dentro de app/, pero en realidad podría residir donde más nos convenga).

Autowiring basado en anotaciones con Spring Framework

2011-01-31T12:44:00.000-08:00

Autowiring se un método que tiene Spring Framework para inyectar de forma automática las dependencias entre clases (servicios, daos, controllers, etc).
Para cada DAO, agrega una anotación de nivel clase @Repository.

Estas anotaciones van en la clase de implementación y no en la intefaz.
import org.sringframework.stereotype.Repository;

@Repository("parametroDao")
public class ParametroDaoImpl implements ParametroDao {
    // ...
}

Para cada componente Servicio, agrega una anotacion de nivel clase @Service.
import org.springframework.stereotype.Service;

@Service("parametroService")
public class ParametroServiceImpl implements ParametroService {
    // ...
}

Para cada controller en Spring MVC, agrega una anotacion de nivel clase @Controller.

No te preocupes de proveer el nombre, no se necesita.
import org.springframework.stereotype.Controller;

@Controller
public class ParametroServiceImpl implements ParametroController {
    // ...
}

Hasta ahora no se ha cambiado nada a la aplicación, se pueden seguir teniendo los nombres de beans usados en la configuración manual, pero es recomendable compilar y construir el proyecto para revisar que no se haya afectado algo.

Una vez hecho lo anterior, hay que decirle a Spring dos cosas: dónde encontrar los nombres para nuestros beans y que estrategia usar para el autowiring.

Para definir donde encontrar los nombres de beans debemos usar el tag <context:component-scan> en el archivo de configuración del contexto de Spring. Se debe declarar el namespace y schema location:

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd
         http://www.springframework.org/schema/jee
         http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">    
    <context:component-scan base-package="x.y.dao">
        <context:include-filter type="annotation"
            expression="org.springframework.stereotype.Repository"/>
    </context:component-scan>
</beans>

Las piezas importantes del xml anterior son xmlns:context, xsi_schemaLocation y <context:component-scan>. Se le está diciendo a Spring que haga un escaneo (búsqueda) de componentes que tengan la aotación @Repository sobre el paquete x.y.dao y si a la anotacion usada se le coloca un valor textual, como en en nuestros casos anteriores del @Repository y el @Service, ése será el nombre a utlilizar como bean para el autowiring

Con la anotacion @Autowired aplicada a los atributos de las clases, se pueden evitar tener setters de dicho atributo, pero si tienes clases unitarias, necesitaríamos setter para inyectar mocks u otras implementaciones.

La convención es utilizar, como nombres de las propiedades que se pretende auto-inyectar, los mismos nombre del componente, lo cual nos permite eliminar los componentes Dao, Service y Controller del archivo de configuracion del contexto de Spring (xml) dado que la configuración ya se está dando en la misma clasa, mediante las anotaciones.

No obstante, sigue siendo recomendable configurar dentro del XML los objetos DataSource (la configuración del orígen de datos, es decir, la Base de Datos), SessionFactory (Hibernate o algún otro ORM) y TransactioManager (Para el control de las transacciones).

Updated: Referencia del entorno de programación en Unix

2011-01-04T09:49:00.000-08:00

Resulta que recomendando un libro sobre programación en Unix, me encontré con :

El entorno de programación UNIX (o en amazon)
Kernighan, Brian W.
Pike, Rob
Editorial Pearson

Anteriormente lo vi en mediafire pero ya no esta y yo no lo tengo lamentablemente pero si les es posible comprarlo, se los recomiendo ampliamente.

Otra referencia de Fernando Bellas Permuy esta en PDF.

Manual de introducción al comando sed

2011-01-04T08:44:00.000-08:00

Se trata de un editor de cadenas, que deriva directamente del comando ed, por lo cual es fácil de aprender, una vez conocido el propio comando ed. Un editor de cadenas es usado para realizar transformaciones de texto básicas de una cadena de entrada (un archivo o la salida de un pipe). A diferencia de otros editores comunes, sed hace solo una revisión sobre cada entrada, por lo cual es mas eficiente, en especial lo es, cuando filtra texto que pasa por una unión pipe.

Cuando sed filtra un archivo, no altera su contenido, todos los cambios los realiza sobre la salida que imprime. Sed despliega cada renglón automáticamente y por ello p no se necesita después del comando de sustitución (s, por ejemplo s/old/new/). Las comillas son indispensables pues existen metacaracters de sed que tienen significado especial para el shell sobre el cual se ejecuta.

El comando sed tiene una limitación que no se encuentra en ed: no maneja números relativos de renglón. En particular, + y - no son entendidos como expresiones para indicar números de renglón, por lo cual resulta imposible de retroceder a uno o mas renglones anteriores o hacer direccionamientos relativos hacia adelante. Esto se debe a que una vez leído un renglón, el anterior se pierde para siempre; no hay manera de identificar el penúltimo renglón.

En la lista de comandos puede existir cualquiera de los listados más adelante. Cuando se hace uso de uno solo, basta con encerrarlo entre comillas simples como sigue:

sed 's/old/new/' archivo

Pero en el caso de que necesitemos ejecutar varios comandos sobre un mismo archivo, es necesario que estos se encuentren en diferentes lineas, por ejemplo:

sed 's/^/ /

3q' archivo

No hay que olvidar que antes de escribir el primer comando, se deben abrir las comillas simples y las mismas se deben cerrar después de teclear el último comando. También es posible almacenar los comandos dentro de un archivo y llamarlo a la hora de que se ejecute sed con el parámetro -f. Por ejemplo:

sed -f cmdarchivo archivo_texto

Se pueden utilizar otros selectores o patrones antes de cada comando, por ejemplo:

sed '/patron/q' Imprime cada linea de archivo hasta encontrar aquella que contenga el patron

sed '/patron/d' Cancela todas las lineas que contengan el patron y no se imprimen

Incluso si se desea el resultado inverso a lo que realiza un comando, basta con agregar un '!' antes

del comando. Por ejemplo, para los dos ejemplos anteriores se prosigue como sigue:

sed '/patron/!q' No imprime c/línea de archivo hasta encontrar aquella que contenga el patron

sed '/patron/!d' No cancela todas las lineas que contengan el patron y no se imprimen

Sintaxis

La sintaxis de sed es la siguiente

sed [-n] [-V] [--quiet] [--silent] [--version] [--help]

[-e script] [--expression=script]

[-f script-file] [--file=script-file]

[script-if-no-other-script]

[file...]

-----------------------------------------------------------------------------------------------

-V ó --version

Imprime la versiòn de sed y nota de copyright.

-h ó --help

Imprime un resumen de todas las opciones de sed.

-n ó --quiet ó --silent

Por defecto, sed imprime cada linea cuando termina de editarla. Esta opciòn deshabilita la impresiòn automàtica y no se produce ninguna salida, excepto que se incluya el comando p.

-e script ó --expression=script

Agrega los comandos de la cadena script, encerrada entre comillas simples, a la lista de comandos para ser ejecutados mientras se procesa la entrada.

-f script-file ó --file=script-file

Agrega los comandos contenidos en el archivo script para ser procesados sobre la entrada. Si ninguno de los dos parámetros anteriores es utilizado, en cualquiera de sus formas, sed tomará como comandos la primer expresión que no sea opción de sed como argumento para ejecutar como si fuera script.

Comandos ================================================

A continuación se presenta una lista de comandos que se pueden utilizar para filtrar una entrada con sed, así mismo se incluyen algunos ejemplos para una mayor comprensión.

** Sustitución **

Su función es sustituir una cadena old por una nueva new en cada linea que procese. Su sintaxis

es la siguiente:

s/old/new/

Ejemplo:

sed 's/casa/carro/' contrato.txt Sustituye la cadena 'casa' por 'carro' en contrato.txt

sed 's/^/.-/' arch.txt Agrega la cadena '.-' al inicio de cada linea de arch.txt

sed 's/^/\

/' arch.txt Agrega un salto de linea al final de cada linea de arch.txt

Otro comando que puede ser útil es y, el cual remplaza cada caracter procedente de old con el caracter correspondiente proveniente de new. Aqui no se admiten rangos. Su sintaxis es:

y/old/new/

** Borrado **

Su función es borrar a la salida, las lineas que correspondan al patrón escrito. Su sintaxis es la

/patron/d

Ejemplo:

sed '/calvo/d' arch.txt Elimina las lineas que contienen la cadena 'calvo' en arch.txt

sed '/amor/!d' carta.txt Elimina las lineas que no tengan la palabra amor en carta.txt

sed '3d' forma.txt Elimina la linea 3 del archivo forma.txt

** Impresión **

Su función es imprimir la salida de sed. En realidad, sed imprime automáticamente la entrada filtrada, entonces si se agrega el comando p, cada linea de salida se imprimirá doble. En caso de que se agregue el parámetro -n a sed, pero se quiera imprimir la salida, se agrega el comando p. Su sintaxis es la siguiente:

/patron/p

Ejemplo:

who | sed -n '/root/p' Imprime solamente las sesiones de root

who | sed '/root/p' Imprime dos veces cada sesion abierta de root

who | sed -n '2p' Imprime solamente la segunda sesion que se inició en el sistema

** Abandonar filtrado **

Otro comando útil para imprimir una parte de la entrada es q. Este comando termina inmediatamente las operaciones de sed, en base a la correspondencia del patrón con las líneas que este procesando. Su sintaxis es la siguiente:

/patron/q

Ejemplo:

sed '3q' forma.txt Imprime hasta la linea 3 del archivo forma.txt

sed '/clavo/q' arch.txt Imprime desde la línea 1 de arch.txt hasta encontrar aquella que contiene la palabra 'clavo'.

** Inserción de texto **

Este comando inserta o agrega texto a cada línea que procesa sed. El texto debe estar localizado

en las siguientes lineas que proceden después del caracter '\'. Su sintaxis es la siguiente:

i \ y a\

[ texto a agregar ]

Ejemplo:

sed 'i \

.' oraciones.txt Agrega un punto final a cada linea de oraciones.txt

sed 'a \

' doble.txt Agrega un salto de linea al final de cada linea de doble.txt

** Guardar la entrada filtrada en un archivo **

Este comando permite salvar la entrada filtrada en otro archivo. Su sintaxis es la siguiente:

/patron/w archivo

Ejemplo:

sed '/pat/w patos.txt

/pat/!w otros.txt animales.txt

Guarda las lineas que concuerden con 'pat' en un archivo llamado patos.txt y los que no

concuerden en el archivo otros.txt

sed 's/UNIX/UNIX(TM)/gw u.out' libros.txt > salida.out

Almacena toda la salida en el archivo salida.out, pero las líneas que fueron modificadas, se

almacenan en u.out

Funciones =================================================

** Etiqueta **

Permite identificar una etiqueta label, si se realiza un cambio en la línea actual. Esta es

especificada por ':' y seguida del nombre de la etiqueta. Su sintaxis es como sigue:

: label

** Grupo **

Indica un grupo de comandos, que inicia con un carácter '{' y termina con un '}'.

** Lectura de archivos **

Con el comando r, lee un archivo y agrega todo su contenido al final de cada línea de entrada de

sed. Su sintaxis es:

nr archivo, donde n es el número de línea donde pegar el texto de archivo.

** Listar línea **

El comando es l y su función es hacer visibles todos los caracteres no imprimibles de cada línea de

entrada.

** Linea actual **

Se puede imprimir el número de la línea actual, si se agrega el comando '='. Su sintaxis es:

/patron/=

** Salto **

Permite saltar o ir a la línea donde se encuentra una etiqueta label definida y continuar la ejecución

de sed desde ese comando. Su sintaxis es:

b label

Conclusión sobre los usos de sed. ==========================================

En realidad sed tiene bastante utilidad como la comprobación de condiciones, creación de ciclos y ramificaciones, retención de líneas precedentes y muchos de los comandos de ed. Su uso es

similar al que se ha descrito en este manual, comandos sencillos de edición y no tanto de

secuencias largas o complejas.

Sed es adecuado para manejar entradas arbitrariamente grandes de forma rápida, pero ofrece una

forma bastante reducida de memoria, puesto que al filtrar una siguiente línea, ya no recuerda la

anterior, por lo que no se puede regresar a filtrar la anterior y tampoco proporciona recursos para

manipular números. Solo es un editor de texto.

debugging remoto de scripts Python con winpdb

2010-12-16T11:22:00.000-08:00

Usando el programa winpdb se pueden debuggear scripts en Python de manera mas intuitiva que con el clásico pdb.

Una de las ventajas que tiene winpdb es la posibilidad de debuggear scripts que esten ejecutandose en remoto en algun servidor. De esta manera, se pueden debuggear no solo scripts en servidores de producción, por poner un ejemplo, sino también scripts que utilicen curses para manipular la pantalla.

winpdb se basa en una arquitectura de cliente-servidor que comunica al servidor (el cual ejecuta el script a debuggear en sí) a través de sockets con el cliente (el cual ejecuta la interfaz del debugger).

winpdb cuenta con dos programas para poder hacer el debuggeo:

rpdb2 - que es la interfaz de consola o modo texto, y que puede ser usada como servidor del debugger también.
winpdb - que es la interfaz gráfica

Para debuggear un script en remoto, hay que ejecutar lo siguiente en el servidor:

screen rpdb2 -s -d -r script.py

El cual utiliza el programa 'screen' para tener la salida del script python a debuggear en una pantalla dedicada.

El parámetro -s se usa en conjunto con screen.

El parámetro -d le indica a rpbd2 que se ejecute en modo servidor solamente, esperando a que algún cliente se conecte para poder hacer el debuggeo.

El parámetro -r permite conexiones remotas.

script.py es simplemente el path y nombre del script a debuggear.

Al ejecutar esta línea, el programa rpdb2 solicitará un password que deberá introducir el cliente también, y con eso asegurar la comunicación entre el cliente y el servidor.

Hecho esto, rpdb2 queda en espera de alguna conexión.

En el lado del cliente, se puede ejecutar rpdb2 para debuggear con la consola, o si se prefiere winpdb para hacerlo con una interfaz gráfica:

winpdb -oserverhost -a script.py

El parámetro -o va seguido de la dirección IP o nombre del servidor

El parámetro -a le indica a winpdb que al conectarse al servidor, adjunte el script script.py que se debe estar ya ejecutando en el servidor para poder debuggear con rpdb2.

Hecho esto, se solicitará el password que se indicó en rpdb2 y con eso la interfaz inicializará y conectará con el servidor y cargará el código fuente del script solicitado, con lo que ya puede comenzar a debuggearse...

Links:
winpdb - sitio oficial de winpdb, con el código fuente del programa, para instalarlo, y documentación.

Configurar POI en Spring 3 para generar archivos Excel

2010-12-03T12:17:00.000-08:00

He decidido registrar el proceso de como generar archivos Excel con POI mediante Spring 3 para que no se me olvide (aunque es bastante sencillo). Me sorprendí de terminarlo en tan sólo 3 pasos!

1) Generar un controller que obtiene los valores que se pretenden mostrar en la vista, los agrega al modelmap de MVC que maneja Spring y luego devuelva el nombre de la vista encargada de generar el excel.

@Controller
@RequestMapping("/excel")
public class ExcelController {

    @Autowired
    private Servicio servicio;

    @RequestMapping(value = "/{parametro}", method = RequestMethod.GET)
    public String generarExcelByParametro(
            ModelMap modelMap, HttpServletResponse response,
            @PathVariable("parametro") String nombreVista) {
        modelMap.put("datos", servicio.obtenerDatos(parametro));

        response.setHeader("Content-type", "application/vnd.ms-excel");
        response.setHeader("Content-Disposition","attachment; filename=\"excel.xls\"");
        return "reporteExcel";
    }

}

Observa que el método generarExcelByParametro() del controller responde a una petición http://{servidor:puerto}/{contexto}/excel/{parametro} y realiza algo en un servicio que devuelve cierta información que se espera administrar de lado de la vista (más adelante lo vemos) y lo guarda dentro del ModelMap de spring con el identificador "datos".

Los headers que se agregan al response, son solo para asegurar que cuando se genere el archivo .xls, se identifique como tal y se obligue al usuario a descargarlo.

Finalmente la cadena ("reporteExcel") que se devuelve determina el nombre de la vista que interpretara los datos para generar el documento.

2) Configurar la vista
Es necesario generar un archivo de nombre views.properties o agregar al que ya exista en el classpath del proyecto, algo como lo siguiente:

reporteExcel.(class)=mx.com.empresa.miproyecto.web.view.ExcelView

La linea comienza con el nombre de la vista, que es el nombre de la cadena que se devuelve en el controller; no olviden encerrar el .class entre paréntesis. La clase (junto con el paquete) que se asigna como valor indica la ubicacion de la View (o vista), misma que interpretará los datos y los plasmará sobre el Excel.

3) Generar la View (vista) que interpreta los datos del controller. Se debe generar una clase que herede de org.springframework.web.servlet.view.document.AbstractExcelView e implemente el metodo buildExcelDocument(). En dicho método es donde se debe recuperar los datos que se involucraron en el ModelMap desde el controller.

public class ExcelView extends AbstractExcelView {
    @Override
    protected void buildExcelDocument(
            Map<String, Object> model, HSSFWorkbook book,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        //recuperar datos
        List reporte = (List<Map<String, Object>>) model.get("datos");
        //crear la hoja
        HSSFSheet hoja = book.createSheet("nombre de la hoja");

        //generar un estilo para la celda
        HSSFCellStyle estiloCelda = obtenerEstiloCelda(book);

        //guardar valores en toda la hoja
        HSSFCell celda;
        int row = 0;
        int col;
        for (Map m : (List<Map<String, Object>>) reporte){
            col = 0;
            // guarda valores en una fila de la hoja
            for (Object o : m.keySet()) {
                celda = getCell(hoja, row, col++);
                celda.setCellStyle(estiloCelda);
                setText(celda, null == m.get(o) ? "[nulo]" : m.get(o).toString());
            }
        row++;
        }
}

La información a utilizar, según el controller que hicimos antes, se obtiene del ModelMap con el identificador "datos". Para este caso se está obteniendo una lista de registros devueltos comúnmente por la ejecucion de un jdbcTemplate.queryForList("... mi query sql ...") de Spring.

Es necesario crerar una hoja mediante createSheet() y usar el valor devuelto (HSSFSheet) para agregar contenido, diseño, colores de fondo y bordes, agregar registros o contenido en celdas específicas con coordenadas (fila, columna), rotar texto, fuente, tamaño, forma de texto y clasificación de contenido de la celda, entre otros muchos más.

Por ejemplo puedes utilizar la instancia de la hoja (HSSFSheet) y el metodo autoSizeColumn((short) 1) para configurar una columna (este caso la B) como autoajustable a lo ancho, de acuerdo al texto que contenga. Para modificar el alto de la primera fila, hacer:

        HSSFRow primerRegistro = hoja.createRow(0);
        primerRegistro.setHeight((short) 1200);  //es una altura de 60.00 cuando lo ves desde el Excel

Observa que utilizas dos métodos básicamente: getCell() para obtener una celda (HSSFCell) de una hoja determinada en una ubicación con la combinación fila, columna; y setText() para asignarle un valor de texto a dicha celda.

También puedes crear templates de estilos de celda para luego aplicarlos a un grupo de ellas. En el código siguiente se esta definiendo un tipo de letra (HSSFFont) de ancho normal, con tamaño 8 y un estilo (HSSFCellStyle) con alineación a la izquierda y borde inferior con pequeños puntos consecutivos(BORDER_DOTTED).

    private static HSSFCellStyle obtenerEstiloCelda(HSSFWorkbook book) {
        HSSFFont fuente = book.createFont();
        fuente.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
        fuente.setFontHeightInPoints((short)8);
        HSSFCellStyle estilo = book.createCellStyle();
        estilo.setFont(fuente);
        //alineacion
        estilo.setAlignment(HSSFCellStyle.ALIGN_LEFT);
        estilo.setVerticalAlignment(HSSFCellStyle.VERTICAL_TOP);
        //border
        estilo.setBorderBottom(HSSFCellStyle.BORDER_DOTTED);
        return estilo;
    }

Existen muchas más alternativas para los estilos pero para no volver a escribir lo que ya está publicado en otros lados, debes revisar las ligas siguientes para abundar más sobre el tema:

Aunque puedes realizar un montón de ajustes en el estilo de tu hoja, básicamente, tu hoja la diseñas en la vista (View) que hereda de la AbstractExcelView y Spring hace todo el resto del trabajo. Sencillo no ?

Servidor VNC para sesiones de escritorios remotos

2010-11-30T11:12:00.000-08:00

Introducción
VNC (Virtual Network Computer) es el software a través del cual se puede iniciar sesión en escritorio remoto con GNU/Linux.

Otra opción es el RDP de Windows, sin embargo aquí explicaremos únicamente como configurar el servidor para el caso de VNC.

Lo primero que hay que saber es que VNC funciona para controlar escritorios remotos que utilizan el servidor gráfico X-Window , el default de GNU/Linux hasta ahora. Sin entrar en detalles de cómo funciona X-Window, basta saber que en este tutorial explicaremos dos opciones:

controlar el escritorio X real que se tenga en el escritorio remoto
controlar un escritorio X virtual que se crea a demanda en dicho escritorio remoto

Ambas opciones tienen posibilidades de aplicación.

Por ejemplo, si lo que deseamos es que otras personas vean mi escritorio mientras yo lo manipulo, puedo levantar VNC usando la opción 1 y permitiendo que los demás se conecten sólo en escucha (sin posibilidad de intervenir en mi sesión). Y de esta manera se pueden impartir cursos o hacer demostraciones en vivo.

Si lo que deseamos es acceder a sesión remota del escritorio para poder acceder como si se tratara de estar sentado físicamente frente a la máquina, pero sin estarlo, y que no importe (o no se requiera) manipular directametne la terminal real de X, sino sólo iniciar sesión, puedo levantar VNC usando la opción 2.

Cabe entonces mencionar que en X se tiene siempre asociada una 'pantalla' (display) real con la terminal física. Normalmente se le asigna el número 0 como identificador. A partir de ahí, el programa Xserver permite levantar nuevas 'pantallas' virtuales (displays) no relacionadas con la terminal física. Es decir que si usamos la pantalla #1, al no ser la física, podemos acceder a ella a través de VNC, pero en la pantalla física no se verá nada (pues esta es la 0, no la 1).

Requisitos previos
Los programas en cuestión que necesitamos instalar son los siguientes:

opción 1: x11vnc en el servidor
opción 2: TightVNC , RealVNC, UltraVNC o cualquier otro que permita VNC en el servidor
clientes: cualquier visor de VNC, como krdc, realvnc vncviewer, etc. No entraremos en detalle sobre el uso de los clientes, ya que se trata de algo muy intuitivo, bastará conectarse al servidor VNC una vez que esté levantado en el puerto que se haya configurado para lo mismo. Cabe anotar que los clientes pueden correr en cualquier plataforma independientemente de que el servidor sea GNU/Linux u otro. Por ejemplo, se puede iniciar sesión remota con un cliente en Windows, a pesar de que el servidor sea GNU/Linux. Otra anotación interesante sobre los clientes es que algunos servidores de VNC (por ejemplo TightVNC) permiten levantar el servidor a través de una interfaz en Java para que el escritorio remoto pueda ser accedido a través de un navegador web con soporte para Java, utilizando un applet específico para lo mismo.
configurar XDMCP en el escritorio remoto para permitir el incio de sesión.

También hay que asegurarse de tener instalado en el servidor el programa Xserver, y de preferencia el superservidor xinetd, que permitirá conectarse a pantallas virtuales sin consumir recursos del servidor cuando no se esté utilizando VNC y a la vez permitir a más de una persona conectarse a su propia sesión con VNC sin que el servidor bloquee puertos ni nada por el estilo.

Inicio de sesión remoto

XDMCP es un protocolo que, en resumen, permite el incio de sesión remoto en terminales X de cualquier índole.

Si no configuramos XDMCP, entonces solamente podremos acceder a pantallas que ya tengan la sesión iniciada. Puesto que esto sólo es posible en pantallas físicas, nos veríamos restringidos a la opción #1, sin posibilidad de utilizar la pantalla de inicio de sesión de la pantalla que quisiéramos controlar, por lo que sólo sesiones previamente iniciadas podrían ser controladas. Esto no es ni práctico, ni mucho menos seguro, lo recomendable es que podamos iniciar sesión en modo gráfico en el escritorio remoto a partir de un prompt de nombre de usuario y password por validar.

XDMCP se configura de manera diferente, dependiendo el manejador de pantalla que estemos utilizando. Físicamente, sin importar el tipo de manejador de escritorio que estemos utilizando (GNOME, KDE, XFCE, etc.), se utiliza un manejador de pantalla para poder iniciar sesión en nuestro escritorio remoto, incluso cuando estamos sentados físicamente frente a él. Las opciones más comunes son: gdm, kdm y xdm. (Normlamente GNOME utiliza gdm, pero podría utilizar otro; KDE utiliza kdm pero podría ser otro, y así...)

xdm

Debe abrirse el archivo xdm-config y comentarse la línea con el texto

DisplayManager.requestPort :0

insertando un ! al inicio.

El usuario 'nobody' debería de tener asociada una terminal shell válida para poder iniciar sesión, por lo que hay que ejecutar:

usermod -s /bin/bash nobody

gdm
Debe ejecutarse gdmconfig, encontrar la pestaña llamada 'XDMCP' y habilitar esta opción.

En escritorios como XFCE, que a veces usan también gdm, la opción se encuentra, dentro del menú 'Configuración', en la pantalla 'Ventana de entrada', en la pestaña 'Remota' hasta abajo se encuentra el botón 'Configurar XDMCP' (obviamente hay que empezar por habilitar la pestaña Remota en los permisos de inicio de sesión dentro de esta misma pantalla).

kdm
Debe editarse el archivo kdmrc y habilitar XDMCP en el puerto 177:

[Xdmcp]
Enable=true
Willing=/etc/X11/xdm/Xwilling
Xaccess=/etc/X11/xdm/Xaccess
Port=177

seguridad
En caso de soportarlo, lo recomendable también es configurar quiénes pueden acceder a sesión. Esta configuración depende completamente del manejador de pantalla que se tenga pero no entraremos en detalle en este caso.

Más información aquí.

Opción 1 (x11vnc , control directo de la terminal física remota)
Como dijimos, se trata de manipular remotamente la pantalla 0, la cual X asocia por default a la terminal física de la máquina que llamaremos en adelante 'escritorio remoto'.

En 'escritorio remoto' hay que instalar entonces x11vnc y Xserver.

Hecho eso, se puede lanzar una línea como la siguiente:

x11vnc

Lo cual nos brindará información adicional sobre los parámetros que deberíamos de lanzar para autenticar nuestra sesión, entre otros.

Yo uso normalmente la siguiente línea:

x11vnc -auth /var/lib/gdm/:0.Xauth -display :0 -shared -forever -ncache -rfbport 5901 -rfbauth ./.vnc/passwd_x11vnc

En donde el parámetro -auth asocia el archivo :0.Xauth (que hay que localizar en el 'escritorio remoto' para cada caso particular) y de esa manera si mi escritorio remoto se quedó en la pantalla de login, poder hacer uso de la autenticación y así poder iniciar sesión. Si no se usa este parámetro, se tendría que tener la pantalla 0 ya dentro de sesión en el escritorio remoto para poder hacer uso del acceso remoto.

El parámetro -forever permite escuchar constantemente conexiones aunque estas se terminen, siempre y cuando no se cierre la sesión gráfica en 0

El parámetro -rfbport indica el número de puerto en que estará escuchando el 'escritorio remoto' para aceptar conexiones. 5901 es el puerto por default para VNC. Por cierto, no hay que olvidar abrir este puerto en el firewall del escritorio remoto.

El parámetro -rfbauth apunta a un archvio en el que previamente almacené un password para autenticar el acceso a mi servidor y así evitar que cualquiera que conozca la dirección IP de mi escritorio remoto se pueda conectar a mi terminal gráfica física 0 y por lo tanto ver o intervenir en mis sesiones directamente (este riesgo es MUY REAL, hay que generar el password siempre). Para generar el archivo del password, x11vnc debe ejecutarse con el parámetro -storepassword, por ejemplo:

x11vnc -storepassword /path/al/archivo_de_password

Aquí no entraremos en detalle para levantar x11vnc usando xinetd, pero el sitio oficial de x11vnc da más información. Además, traspolando un poco la información que daremos para la opción #2, se puede lograr levantar un servidor así.

Antes de concluir con x11vnc, hay que aclarar también que para poder inciar sesión remota también es necesario configurar el protocolo XDMCP como se explicó anteriormente...

Opción 2 (vnc, control de pantallas virtuales remotas)

En este caso se manipularán pantallas virtuales no directamente relacionadas con la terminal física del escritorio remoto. La idea será que dichas pantallas se creen a demanda también.

En el escritorio remoto habrá que tener instalado tanto el software que se usará como servidor VNC (tightvnc, ultravnc, realvnc, etc.) y Xserver.

Hecho eso se puede ejecutar la siguiente línea de comandos:

vncserver -query localhost -once -geometry 1024x768 -depth 16 :1

Con lo que se tendrá un servidor VNC en la pantalla virtual #1, y si esta no estuviera disponible, buscaría en la 2, y así sucesivamente.

El parámetro -once indica que sólo permitirá el inicio de sesión una vez, luego de terminar la cual cerrará el servidor. Esta opción es más útil aún usando un superservidor como se explica más adelante.

El parámetro -geometry 1024x768 define la resolución que tendrá la sesión en el escritorio remoto.

El parámetro -depth 16 indica la profundidad de color a obtener en la sesión remota, en este caso a 16 colores.

El parámetro :1 indica el número de pantalla virtual que se desea utilizar.

El parámetro -query localhost indica que se desea iniciar sesión en el escritorio remoto a través de XDMCP.

Para que se autentique a los usuarios, es necesario crear previamente el archivo de passwords con el programa vncpasswd. Por default, vncserver busca en $HOME/.vnc/passwd

Superservidor xinetd

Sin embargo, levantar manualmente un servidor de pantallas virtuales VNC no es la forma más óptima, ya que se tienen estos inconvenientes:

hay que levantar nuevamente el servidor cada vez que se termine de usar
solamente podrá entrar a sesión por VNC una persona, y si se tiene más de un usuario que pudiera iniciar sesión en el escritorio remoto (cada uno a su propia sesión), no se les permitiría.
además si no se está utilizando el servicio VNC en un momento dado, aún así se está consumiendo memoria en el servidor, con el programa a la escucha de posibles conexiones.

La solución implica levantar algo conocido como un superservidor, de los cuales xinetd es el más popular en GNU/Linux. El superservidor permite levantar a demanda instancias de los servidores configurados en él. Esto trae ventajas de menor consumo de memoria, además de permitir levantar instancias múltiples del servidor escuchando un sólo puerto (que atiende el superservidor). Y en cuanto se termine de usar el servidor en cuestión, el superservidor sigue atento para nuevas solicitudes. Un superservidor es útil para servidores que no están en constante uso o que no requieren de alta disponibilidad, podría ser (dependiendo las circunstancias, claro): telnet, ftp, o en nuestro caso vnc.

Una vez instalado xinetd, lo único que debe hacerse es agregar la configuración adecuada para utilizar VNC a través del mismo. Esta configuración se puede escribir en un archivo exclusivo para VNC, pero debe asegurarse de guardarse en donde xinetd lo lea, por lo regular en /etc/xinetd.d

El siguiente es un ejemplo de un servidor VNC levantado a través de xinetd:

service vnc
{
protocol = tcp
socket_type = stream
wait = no
user = user_name
server = /usr/bin/Xvnc
server_args = -inetd -query localhost -once -geometry 1024x768 -depth 16 -rfbauth=/home/user_name/.vnc/passwd
disable = no
}

Antes de utilizarlo, explicaré algunos detalles:

-El servidor que se mandó llamar utiliza el programa 'Xvnc', en vez de 'vncserver'. Leyendo la página del manual de vncserver (man vncserver), se puede constatar que en realidad vncserver es un wrapper que manda llamar en el fondo a Xvnc, por lo que este último programa será el indicado para llamar en las instancias que genere el superservidor.

-Los argumentos incluyen el parámetro -inetd que es necesario para que el servidor VNC sepa que fue mandado llamar desde un superservidor.

-Se incluye el parámetro -rfbauth=/path/passwd , el cual es la ruta al archivo de password a utilizar.

-El nombre de usuario 'user_name' se utilizó en este caso para que el servidor se ejecute a nombre de este usuario. Normalmente se utiliza el usuario 'nobody', pero este debe de tener permisos de lectura al archivo de password, por lo que otra opción implica ejecutar el servidor como otro usuario, con acceso al archivo de password en una ruta particular.

-Si se utiliza TightVNC, las opciones de configuracion no deben incluir el caracter '=', sino que hay que sustituirlos por espacios

Una vez configurado el servicio, hay que reiniciar xinetd:

/etc/init.d/xinetd restart

(o cualquiera que sea la manera de hacerlo en tu distribución en particular).

No hay que olvidar abrir el puerto 5901 (que es el default de VNC, en realidad es el puerto 5900 + N, donde N será el número de pantalla virtual que se utilice) para escuchar las peticiones a conectarse.

Igualmente no olvidar que aunque muchos usuarios se puedan conectar al servidor VNC, sólo una persona a la vez podrá entrar a una sesión en particular. Si hay más de una sesión disponible en el servidor, cada una podrá ser iniciada una vez, pero no pueden entrar a sesión más de una vez por nombre de usuario.

En este link, se da más información y la posibilidad de levantar más de un servidor con xinetd para escuchar en distintos puertos, para tener la posibilidad de conectarse con distintas resoluciones al mismo servidor VNC.

Algunos servidores VNC (como Tight VNC) permiten conectarse también vía http en un navegador web, utilizando un applet de Java. Hay que consultar la documentación de cada caso particular para poder lograr esto. De entrada, lo que normalmente se hace es utilizar el puerto 5800 + N para obtener esta conexión.

DBUnit lo hace facil

2010-08-26T01:56:00.000-07:00

Dado que he trabajado con JUnit y DBUnit y he encontrado en ellos unas buenas herramientas para probar el codigo de las aplicaciones en java, pues me dí a la tarea de investigar un poquito sobre como obtener datasets desde una BD, y como cargarlos para realizar pruebas específicas. Fue entonces cuando me encontré con este artículo de Bill Siggelkow y me dí a la tarea de traducir una parte, también he agregado notas mías, pero pueden encontrar el original en enlace al final del post.

Y dice así:
Si desarrollas aplicaciones que acceden a datos relacionales necesitas verificar el código de tu aplicación trabaje con los datos, como fue diseñado. Cuando usas Hibernate o algún otro framework que implemente JPA, deberías confirmar que tus mapeos dirijan a Hibernate para almacenar y recuperar la información correctamente. Yo implemento este tipo de pruebas usando JUnit. Nadie puede refutar que las pruebas contra una base de datos activa es fundamental - no hay una mejor forma para verificar tus mapeos.

Pero para probar contra la base de datos se requiere que los datos se encuentren en un estado inicial. Puedes cargar la base de datos manualmente antes de correr tu prueba pero eso se vuelve monotono y propenso a errores. DBUnit resuelve este problema. Este puede precargar la base de datos para cada una de tus pruebas, basado en un grupo de datos dentro de un xml (comúnmente llamado dataset). El formato de este dataset es sencillo de entender; aquí hay un ejemplo de tres tablas de una base de datos MySQL. Los nombres de los elementos empatan con los nombres de las tablas y sus atributos con los nombres de sus columnas. Cada elemento implica un registro en esa tabla.

<dataset>
    <cliente id_cliente="778899" id_estatus = "1" id_sucursal="98765"/>
    <banco id_banco="1" nombre="BNMX" descripcion="Banamex" activo="1"
valor="0"/>
    <pago id_cliente = "778899" id_estatus = "1" id_tipo_producto =
"1" id_promotor = "1" id_sucursal = "58" />
</dataset>

Para una base de datos pequeña donde solo necesitas cargar unas pocas tablas con unos pocos registros puedes crear el dataset manualmente. Pero seguramente no querás hacerlo con una base de datos empresarial compleja que contiene cientos de tablas con nombres de columnas complejas. Es más facil si le permites a DbUnit extraer los datos por ti.

Aquí esta un proceso típico que sigues cuando usas DBUnit:

Poblar las tablas de tu base de datos como sea necesario para ejecutar tu prueba.
Extraer los datos desde esas tablas hacia un dataset XML. En el método setUp de tu prueba unitaria, llamar a DBUnit para cargar la base de datos desde los dataset's recientement creados.

Puedes extraer los datos usando una clase como esta:

import java.io.FileOutputStream;
import java.sql.Connection;
import java.sql.DriverManager;

import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;

public class ExtractTestDataSet {
    public static void main(String[] args) throws Exception {
        // conexion a la base de datos
        Class driverClass = Class.forName("com.mysql.jdbc.Driver");
        Connection jdbcConnection = DriverManager.getConnection(
                "jdbc:mysql://localhost/bon_app", "scott", "tiger");
        IDatabaseConnection connection = new DatabaseConnection(jdbcConnection);
        // exportar un dataset parcial
        QueryDataSet partialDataSet = new QueryDataSet(connection);
        partialDataSet.addTable("recipe", "SELECT * FROM recipe where
is_deleted != 'Y'");
        partialDataSet.addTable("recipe_ext_xref");
        FlatXmlDataSet.write(partialDataSet,
                new FileOutputStream("partial-dataset.xml"));
        // exportacion de la base de datos completa!!
        IDataSet fullDataSet = connection.createDataSet();
        FlatXmlDataSet.write(fullDataSet, new
FileOutputStream("full-dataset.xml"));
    }
}

DBUnit puede crear un dataset con todos los datos en tu base de datos configurándole solamente una conección JDBC abierta En la práctica, probablemente querá limitar el dataset a tablas específicas y datos usados por tu prueba unitaria. En el ejemplo anterior se esta creando dos archivos dataset. El primero como partial-dataset.xml, representa solo una porcion de la base de datos. DBUnit pobla el dataset basado en tablas y queries especificados. Si solo indicas el nombre de una tabla, el dataset se llenará de todos los registros y columnas en esa tabla. Especifia una tabla y un query y DBUnit solo extraerá los datos devueltos por el query. Si quieres la base de datos completa en el dataset, simplemente llama el metodo IDatabaseConnection.createDataSet().

En el método setUp() de tu prueba unitaria, usas el dataset como entrada para una operacion DBUnit. DBUnit soporta varias combinaciones de operacion para borrar, insetar y ctualizar la base de datos usando un dataset. Las operaciones más comunes son CLEAN_INSERT (limpia toda la tabla e inserta los registros del dataset) y REFRESH (solo agrega los registros del dataset a la tabla y si estos ya existen, los actualiza - con base en el id de la tabla). CLEAN_INSERT es la opcion a usar si tienes tu propia instancia de base de datos y no necesitas preocuparte por ponerle el pie a alguien más del equipo de desarrollo. Por otro lado, si compartes tu base de datos con el equipo, tu mejor amigo es REFRESH.

En el siguiente fragmento de una prueba unitaria, se está usando CLEAN_INSERT para reinicializar la base de datos antes de cada método de prueba.

protected void setUp() throws Exception {
    setUpDatabase();
}

private void setUpDatabase() throws Exception {
    // Inicializa tu base de datos aquí
    Class driverClass = Class.forName("com.mysql.jdbc.Driver");
    Connection jdbcConnection = DriverManager.getConnection(
"jdbc:mysql://localhost/bon_app", "scott", "tiger");
    IDatabaseConnection connection = new DatabaseConnection(jdbcConnection);

// inicializa tu dataset aquí
    IDataSet dataSet = new FlatXmlDataSet(new File("full-dataset.xml"));
    try {
        DatabaseOperation.CLEAN_INSERT.execute(connection, dataSet);
    } finally {
        connection.close();
    }
}

Esta forma trabaja bien pero es algo molesto que tengas que hacer código a mano y recompilar la clase que extrae cuando sea necesariocambiar como DBUnit crea los dataset. Usando Spring se le puede delegar el trabajo de configurar la clase de extracción de datos y esto salvaría un montón de código hecho a mano. Esto resulta en la siguiente clase:

package com.jadecove.bonappetit.test;
import java.io.FileOutputStream;
import java.sql.Connection;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.sql.DataSource;

import org.apache.log4j.Logger;
import org.dbunit.database.DatabaseConfig;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;

/**
* Extracts a DBUnit flat XML dataset from a database.
*
* @author Bill Siggelkow
*/
public class DBUnitDataExtractor {
    private DataSource dataSource;
    private String dataSetName = "dbunit-dataset.xml";
    private List queryList;
    private List tableList;
    private Map dbUnitProperties;
    private Map dbUnitFeatures;
    private String schema;

    /**
    * A regular expression that is used to get the table name
    * from a SQL 'select' statement.
    * This  pattern matches a string that starts with any characters,
    * followed by the case-insensitive word 'from',
    * followed by a table name of the form 'foo' or 'schema.foo',
    * followed by any number of remaining characters.
    */
    private static final Pattern TABLE_MATCH_PATTERN = Pattern.compile(".*\s+from\s+(\w+(\.\w+)?).*", Pattern.CASE_INSENSITIVE);
    private static final Logger log = Logger.getLogger(DBUnitDataExtractor.class);

    /**
    * The data source of the database from which the data will be
    extracted. This property
    * is required.
    *
    * @param ds
    */
    public void setDataSource(DataSource ds) {
        dataSource = ds;
    }

    /**
    * Set the schema.
    * @param schema
    */
    public void setSchema(String schema) {
        this.schema = schema;
    }

    /**
    * Name of the XML file that will be created. Defaults to
    <code>dbunit-dataset.xml</code>.
    *
    * @param name file name.
    */
    public void setDataSetName(String name) {
        dataSetName = name;
    }

    /**
    * Performs the extraction. If no tables or queries are specified,
    data from entire database
    * will be extracted. Otherwise, a partial extraction will be performed.
    * @throws Exception
    */
    public void extract() throws Exception {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            log.info("Beginning extraction from '"+conn.toString()+"'.");
            IDatabaseConnection connection = new DatabaseConnection(conn, schema);
            configConnection((DatabaseConnection) connection);
            if (tableList != null || queryList != null) {
                // partial database export
                QueryDataSet partialDataSet = new QueryDataSet(connection);
                addTables(partialDataSet);
                addQueries(partialDataSet);
                FlatXmlDataSet.write(partialDataSet, new FileOutputStream(dataSetName));
            } else {
                // full database export
                IDataSet fullDataSet = connection.createDataSet();
                FlatXmlDataSet.write(fullDataSet, new
                FileOutputStream(dataSetName));
            }
        }
        finally {
            if (conn != null) conn.close();
        }
        log.info("Completed extraction to '"+dataSetName+"'.");
    }

    /**
    * List of table names to extract data from.
    *
    * @param list of table names.
    */
    public void setTableList(List list) {
        tableList = list;
    }

    /**
    * List of SQL queries (i.e. 'select' statements) that will be used executed to retrieve
    * the data to be extracted. If the table being queried is also specified in the <code>tableList</code>
    * property, the query will be ignored and all rows will be extracted from that table.
    *
    * @param list of SQL queries.
    */
    public void setQueryList(List list) {
        queryList = list;
    }

    public void setDbUnitFeatures(Map dbUnitFeatures) {
        this.dbUnitFeatures = dbUnitFeatures;
    }

    public void setDbUnitProperties(Map dbUnitProperties) {
        this.dbUnitProperties = dbUnitProperties;
    }

    private void configConnection(DatabaseConnection conn) {
        DatabaseConfig config = conn.getConfig();
        if (dbUnitProperties != null) {
            for (Iterator k=dbUnitProperties.entrySet().iterator(); k.hasNext(); ) {
                Map.Entry entry = (Map.Entry) k.next();
                String name = (String) entry.getKey();
                Object value = entry.getValue();
                config.setProperty(name, value);
            }
        }
        if (dbUnitFeatures != null) {
            for (Iterator k=dbUnitFeatures.entrySet().iterator(); k.hasNext(); ) {
                Map.Entry entry = (Map.Entry) k.next();
                String name = (String) entry.getKey();
                boolean value = Boolean.valueOf((String)entry.getValue()).booleanValue();
                config.setFeature(name, value);
            }
        }
    }

    private void addTables(QueryDataSet dataSet) {
        if (tableList == null) return;
        for (Iterator k = tableList.iterator(); k.hasNext(); ) {
            String table = (String) k.next();
            dataSet.addTable(table);
        }
    }

    private void addQueries(QueryDataSet dataSet) {
        if (queryList == null) return;
        for (Iterator k = queryList.iterator(); k.hasNext(); ) {
            String query = (String) k.next();
            Matcher m = TABLE_MATCH_PATTERN.matcher(query);
            if (!m.matches()) {
                log.warn("Unable to parse query. Ignoring '" + query +"'.");
            }
            else {
                String table = m.group(1);
                // only add if the table has not been added
                if (tableList != null && tableList.contains(table)) {
                    log.warn("Table '"+table+"' already added. Ignoring '" + query + "'.");
                } else {
                    dataSet.addTable(table, query);
                }
            }
        }
    }
}

Esta clase sirve como una envoltura compatible con Spring sobre el proceso de extracción de DBUnit, aunque no tenga dependencia con Spring (eso es lo bonito de Spring). Aquí esta como puedes configurar el extractor en un archivo de beans de Spring.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"><beans>
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property>
        <property name="url"><value>jdbc:mysql://localhost/bon_app</value></property>
        <property name="username"><value>scott</value></property>
        <property name="password"><value>tiger</value></property>
    </bean>

    <bean id="dbUnitDataExtractor" class="com.jadecove.bonappetit.test.DBUnitDataExtractor">
        <property name="dataSource" ref="dataSource"/>
        <property name="dataSetName" value="dbunit-dataset.xml"/>
        <property name="tableList">
            <list>
                <value>recipe</value>
                <value>recipe_ext_xref</value>
            </list>
        </property>
        <property name="queryList">
            <list>
                <value>select * from bon_app_ext.person where first_name = 'Bill'</value>
            </list>
        </property>
    </bean>
</beans>

Ahora puedes extraer datasets de DBUnit recuperando un extractor configurado vía Spring y llamando al método extract(). La única propiedad requerida es la fuente de datos. Haciendolo así puedes obtener la base de datos completa, pero también puedes listar tablas y queries específicos. Además, la configuración de Spring te permite agregar otros elementos y propiedades que configuren a DBUnit de diferentes maneras, revisa la API de DBUnit para saber qué más cosas puedes usar al respecto.

Cuando estas usando queries, DBUnit requiere que se especifique ambos, el nombre de la tabla y el query Para hacer una configuración más sencilla, este extractor usa una expresión regular que determina el nombre de la tabla.

Este extractor se ha usado con una base de datos empresarial compleja local MySQL, pero a través de la configuración de la conexión, esquema y características de DBUnit puedes extraer los datos desde la mayoría de bases de datos. En mi actual trabajo de consultoría, yo uso este extractor para obtener datos desde algunas bases de datos complejtas DB2 corriendo en un AS-400 de IBM.

Este ejercicio no solo ayudó a hacer la vida más fácil con DBUnit, esto me ayudó a entender que tan fácil es delegar estas tareas mundanas a Spring.

Fuente:
http://www.oreillynet.com/onjava/blog/2005/10/dbunit_made_easy.html

Configurar JasperReports en Spring 3.0

2010-08-25T12:59:00.000-07:00

Cada vez es más sencillo realizar las configuraciones en Spring. A pesar de que la configuración se puede seguir usando de diferentes maneras, en la documentación de referencia de spring 3 indica lo siguiente de forma general:

Agregar dependencias a tu proyecto
Configurar el ViewResolver
Crear el template con iReports
Configurar las vistas
Crear el controller

Ahora vamos a los detalles.

1. Las dependencias que nos dice debemos tener son las siguientes:

Obviamente el Jasper

        <dependency>
            <groupId>jasperreports</groupId>
            <artifactId>jasperreports</artifactId>
            <version>3.5.3</version>
        </dependency>

• BeanShell (esta no la ocupe)

• Commons BeanUtils (esta no la ocupe)

• Commons Collections (esta es requerida)

        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>

• Commons Digester (esta no la ocupe)

• Commons Logging (esta es para logear, si ya usas otra, puedes omitirla)

• iText (esta es por si generas PDF pero yo no la ocupe)

• POI (esta es para generar archivox XLS)

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.2-FINAL</version>
        </dependency>

2. Configurar el ViewResolver via un properties

Antes ya lo había hecho mediante la clase de spring XmlViewResolver para configurar las vistas en un archivo xml (views.xml) pero me pareció más sencillo mediante un archivo properties y por eso difundo esta alternativa.

<bean id="viewResolver" class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
<property name="basename" value="views"/>
</bean>

Se esta configurando una instancia de ResourceBundleViewResolver que busca por los mapeos de las vistas en un archivo properties con el nombre indicado por la propiedad basename, en este caso views.properties. Donde colocarlo? en el classpath de la aplicación.

El contenido del archivo views.properties se explica en el punto 4.

3. Crear el Template con iReports (yo trabajé con la version 3.5.3)

Una cosa que se debe tomar en cuenta es que se debe usar la misma version de iReports que la que se esta usando en el jar como dependencia.

Descarga la aplicacion iReports desde la pagina. Luego instalala y cuando la abras basta con que crees un proyecto en blanco. Este se guarda como un archivo .jrxml que básicamente es un xml plano.

Puedes encontrar un buen manual de uso de iReports aqui.

Cuando se compila un archivo jrxml, se genera otro con el mismo nombre .jasper, el cual es necesario indicar en la configuración de spring para que se genere el reporte en el formato deseado.

4. Configurar las vistas en el archivo properties.

El framework de spring contiene 5 diferentes implementaciones para crear reportes con Jasper, cuatro de ellas corresponden a formatos específios (csv, pdf, html y xls) y una que permite determinar una de las anteriores en tiempo de ejecución (JasperReportsMultiFormatView).

Para generar un reporte en pdf, por ejemplo, vamos usar el siguiente contenido en nuestro archivo views.properties:

reciboPago.(class)=org.springframework.web.servlet.view.jasperreports.JasperReportsPdfView
reciboPago.url=/WEB-INF/jasperTemplates/recibo.jasper
reciboPago.reportDataKey=reciboKey

El nombre de la vista es "reciboPago", su propiedad class define la clase de jasper que la mapea, en este caso es la clase que genera PDFs. Es importante que esta propiedad esté configurada como .(class) y no .class debido a que spring busca este valor vía la propiedad y no usando el acostumbrado getter/setter. De esta manera se entiende que si no usamos los paréntesis, spring lo interpreta como el hecho que debe usar el getter/setter de dicha propiedad para acceder a su valor.

La propiedad url se utiliza para definir la ruta de acceso al archivo compilado por el programa iReports, en este caso se esta colocando dentro de la carpeta WEB-INF de la aplicación.

Finalmente reportDataKey define el nombre llave para obtener de un mapa el POJO o DTO que contiene cada valor a mostrar en el reporte. En este caso, se le esta diciendo a spring que su fuente de datos se encuentra en la llave "reciboKey" del mapa a recibir (ver punto 5, sobre el controller).

5. Crear el controller.

Es sumamente sencillo generar un controller en spring mediante las anotaciones:

@Controller
@RequestMapping("/pago")
public class PagoController {
    @RequestMapping(value="/recibo", method=RequestMethod.GET)
    public String generarReciboPago(ModelMap modelMap, HttpServletResponse response) {
        List<ReciboDTO> lista = new ArrayList<ReciboDTO>(1);
        ReciboPagoJasperDTO dto = new ReciboDTO();
        dto.setMonto("6789.0");
        dto.setNombre("Pedro Romero");
        lista.add(dto);
        response.setHeader("Content-type", "application/pdf");
        response.setHeader("Content-Disposition","attachment; filename=\"recibo.pdf\"");
        JRBeanCollectionDataSource jrbean = new JRBeanCollectionDataSource(lista, false);
        modelMap.put("reciboKey", jrbean);
        return("reciboPago");
    }
}

@Controller define a la clase como un controller y @RequestMapping define una uri desde la cual se puede acceder a nuestro controller cuando nuesta aplicación ya está montada en un server. Si la aplicacion levanta en un contexto "proyecto" y el servidor levanta en un puerto local 8080, podriamos acceder a nuestro controller anterior como: "http://localhost:8080/proyecto/pago/recibo", aunque esto es asunto de otro tema, basta con observar como se concatenan los valores del contexto de la aplicación, y de las anotaciones @RequestMapping de clase y método usado.

En este caso ReciboDTO es el pojo usado para portar los valores que alimentaran el reporte, se inserta en una instancia de JRBeanCollectionDataSource y luego se agrega al mapa del modelo con el key: reciboKey (observa que es el mismo metodo que usamos en el properties.

Finalmente se devuelve una cadena que indica el nombre de la vista configurada en el properties, la cual esta mapeada a la clase jasper: JasperReportsPdfView.

Notas importantes:

Spring nos provee de la capacidad de agregar elementos dentro de una Collection, dado que internamente Spring los envuelve dentro de un objeto JRBeanCollecionDataSource (implementa interface JRDataSource), también nos da la capacidad de agregar mas beans al modelo en diferentes llaves del mapa, ejemplo:

modelMap.put("reciboKey", jrbean);
modelMap.put("myKey1", jrbean1);
modelMap.put("personal2", jrbean2);

El punto está en que si la vista no esta apuntando a uno de estas llaves en particular (mediante la propiedad de la vista: reportDataKey), usará la primera instancia de JRDataSource que encuentre.

Servidor de correos personal con postfix - Spambayes

2010-08-24T11:38:00.001-07:00

Éste es el último post de 'Servidor de correos personal con postfix'. Ya configurado el mismo (MTA, MDA, MUA) y recuperando automáticamente correos con Fetchmail, sólo queda velar por la seguridad del servidor...

Se llama spam o correo basura a los mensajes no solicitados, no deseados o de remitente desconocido, habitualmente de tipo publicitario, enviados en grandes cantidades (incluso masivas) que perjudican de alguna o varias maneras al receptor.

El spam se puede convertir en una incidencia de seguridad por varias razones:

ocupa espacio en las bandejas de entrada de los receptores. En los casos de cuentas con tamaño limitado esto es un problema.
en sistemas vulnerables, el spam suele llegar también acompañado de scripts perniciosos, a ejecutar en el sistema receptor, o un link engañoso para infectar la máquina cliente.
también puede incluir información engañosa con la cual realizar un robo de información confidencial, engañando al usuario incauto

Claro está, la mejor política de seguridad en estos casos es ser prudente y no dar click y descargar todo lo que llegue a la bandeja de entrada del correo.

Sin embargo, los servidores de correo también cuentan con protección extra ante esta problemática. En nuestro caso, vamos a configurar Spambayes como detector de spam. Existen muchos otros programas que realizan funciones similares, el más famoso es Spamassasin. Sin embargo en este tutorial nos enfocaremos en Spambayes.

Instalación
Spambayes se puede descargar desde su sitio oficial, o puede instalarse con la distribución. En Debian el paquete se llama spambayes.

Configuración

Spambayes es una serie de scripts en Python que utilizan algoritmos de probabilidad para clasificar el correo, si es spam (correo no deseado), ham (correo seguro) o inseguro (no se sabe si es o no spam). Debe entrenarse constantemente la red bayesiana en la que se basa el software para refinar cada vez más su comportamiento.

En la sección del MDA (Procmail) ya creamos los subdirectorios necesarios para que funcione Spambayes, así que continuaremos con la configuración. Como parte de la configuración, es necesario configurar Spambayes, pero también Procmail para que sepa dónde colocar los correos identificados, y además mutt para agregar unas cuantas utilidades que pueden servir para tratar con los distintos tipos de mensajes.

1) Spambayes

El subdirectorio ~/Mail contendrá nuestro correo seguro.
El subdirectorio ~/.CaughtSpam contendrá el correo que Procmail defina como Spam de acuerdo a lo que Spambayes le indique.
El subdirectorio ~/.Unsure contendrá correo que Spambayes no sepa clasificar.
Para propósitos de entrenamiento, en ~/Mail/.MissedHam y ~/Mail/.MissedSpam iremos colocando correos que lleguen a las bandejas equivocadas, de forma que a la siguiente ronda de entrenamiento de Spambayes, sepa en adelante como clasificar dichos correos.

El script de entrenamiento es el siguiente: ~/Mail/train_spambayes

#!/bin/sh
# Script to copy mail missed spam and ham into correct folders
# and run sb_mboxtrain.py to train spambayes
# Training will be done only on missed spam and ham

# Files we saved or bounced may be in the new directory
# We want them in cur for training
mv /home/usuario/Mail/.MissedSpam/new/* \
 /home/usuario/Mail/.MissedSpam/cur 2>/dev/null
mv /home/usuario/Mail/.MissedHam/new/* \
 /home/usuario/Mail/.MissedHam/cur 2>/dev/null
/usr/bin/sb_mboxtrain.py -d /home/usuario/.hammie.db \
 -g /home/usuario/Mail/.MissedHam \
 -s /home/usuario/Mail/.MissedSpam

Obviamente, hay que editarlo según la cuenta de usuario y directorios usados en el servidor. Este script debe ser ejecutable:

$ chmod +x ~/Mail/train_spambayes

Además hay que crear la base de datos en donde Spambayes se entrenará:

$ /usr/bin/sb_filter.py -d $HOME/.hammie.db -n

lo cual creará el archivo .hammie.db

Por último, será útil que el servidor se dedique automáticamente a entrenar la red bayesiana cada cierto tiempo sin intervención del usuario, para lo que creamos un cronjob con

$ crontab -e

y colocamos el cronjob:

21 3 * * * ~/Mail/train_spambayes

que entrenará a las 3:21am de todos los días.

2) Procmail

Ahora hay que decirle a Procmail que, dependiendo lo que diga la base de datos con la red bayesiana entrenada, clasifique los correos entrantes en los subdirectorios que creamos previamente. Editar .procmailrc para que quede así (editarlo para que coincida con los directorios y usuario en el servidor):

SHELL=/bin/sh
MAILDIR=$HOME/Mail
DEFAULT=$HOME/Mail/
CAUGHT_SPAM=$MAILDIR/.CaughtSpam/
UNSURE=$MAILDIR/.Unsure/
  
#Spambayes process
:0fw:hamlock
| /usr/bin/sb_filter.py -d /home/usuario/.hammie.db

:0
* ^X-Spambayes-Classification: spam
${CAUGHT_SPAM}

:0
* ^X-Spambayes-Classification: unsure
${UNSURE}

# Catches everything else.
# Anything left over goes into the DEFAULT folder
:0:
${DEFAULT}

Lo que hicimos fue decirle a Procmail que con el script sb_filter.py clasifique el correo, y lo mande a los directorios de CaughtSpam, Unsure o el Default (~/Mail).

3) mutt

Por último, si observamos la bandeja de entrada con mutt, es probable que encontremos correo que deseemos clasificar como Spam. La opción manual sería mover manualmente estos correos a los directorios creados, a través de los comandos de mutt.

Sin embargo, esto no es funcional, por lo que editaremos el archivo .muttrc para agregar un poco de automatización que facilite este proceso.Editarlo para que quede así:

set editor="emacs"
set folder = /home/usuario/Mail
set signature="~/.signature"
my_hdr From: Nombre Usuario
# Don't ask to move read message
set move=no

# Header control   h displays header when in pager
# I want to only see the unignored by default
ignore *                                        # weed out all headers
unignored date from: to cc subject organization  # now show me these...

# Setting these macros is going to save us all of that time I was
#  talking about.  Now instead of having to type all of those
#  characters to move the mail around we will can just tag the messages
#  and, for the instance of spam in your inbox, hit 'S'.
  
# Move mail to correct directories
macro   index   S       ";s~/Mail/.MissedSpam\r\r$\r"
macro   pager   S       ";s~/Mail/.MissedSpam\r\r$\r"
macro   index   H       ";C~/Mail/.MissedHam\r\r;s~/Mail\r\r$\r"
macro   pager   H       ";C~/Mail/.MissedHam\r\r;s~/Mail\r\r$\r"
macro   index   M       ";s~/Mail/\r"
macro   pager   M       ";s~/Mail/\r"

# This is how we are going to move around to the different
#  mailboxes.  Hitting 'alt-1' will take us to our inbox
#  'alt-2' and we are looking at the mail Spambayes classified
#  as spam.  etc.
#  The extra mailboxes I have in here are for mailing lists I am on.
#  I will show the procmail recipe that automatically puts
#  the mailing list mail into its correct mailbox further down.
  
# Move to mailboxes quickly
macro   index   1  "c~/Maildir\r"
macro   pager   1  "c~/Maildir\r"
macro   index   2  "c~/Maildir/.CaughtSpam\r"
macro   pager   2  "c~/Maildir/.CaughtSpam\r"
macro   index   3  "c~/Maildir/.Unsure\r"
macro   pager   3  "c~/Maildir/.Unsure\r"

# Training Maildirs for Spam and Ham
macro   index   8  "c~/Maildir/.MissedSpam\r"
macro   pager   8  "c~/Maildir/.MissedSpam\r"
macro   index   9  "c~/Maildir/.MissedHam\r"
macro   pager   9  "c~/Maildir/.MissedHam\r"

# Setting these colors makes it easy to tell which emails
#  Spambayes has missed.
# Turn spam red and unsure green
color index red default "~h '^X-Spambayes-Classification: spam'"
color index green default "~h '^X-Spambayes-Classification: unsure'"
# Turn gmail mail brightblue
#  (My regular expression is not correct here.  I think that it
#   is looking anywhere in the header for my gmail address
#   instead of what I wanted..  Just in the 'To:'.
#   It still works for the most part)
color index brightblue default "~h '(^)*my_name@gmail.com'

# Lets set more colors to make things look beautiful.  Judging by
#  my title for this section I must have had bad feelings towards
#  colors when I added this.
#Color crap
color index brightwhite default ~N       # color for new messages
color status black yellow
color attachment brightyellow default    # file attachments
color search brightred default           # search matches
color quoted brightyellow default        # quoted text in replies
color quoted1 magenta default            # quoted text in replies
color body cyan default "((ftp|http|https)://|news:)[^ >)\"\t]+"   # URLs
color body cyan default "[-a-z_0-9.+]+@[-a-z_0-9.]+"               # email

Con esto conseguimos que mutt nos proporcione lo siguiente:

Si estamos ante un mensaje que debió clasificarse como Spam y no lo fue (en la bandeja de entrada o en Unsure), tecleando 'S' se mueve a los directorios correctos (CaughtSpam y MissedSpam) en espera del siguiente entrenamiento.
Si estamos ante un mensaje que debió clasificarse como Ham y no lo fue (en la bandeja de Spam o en Unsure), tecleando 'H' se mueve a los directorios correcots (bandeja de entrada y MissedHam) en espera del siguiente entrenamiento.
Podemos seleccionar varios mensajes a la vez con el comando 't'.
Esc + 1 nos lleva directamente a la bandeja de entrada.
Esc + 2 al spam
Esc + 3 a Unsure
Esc + 8 a MissedSpam
Esc + 9 a MissedHam
Además, dependiendo el tipo de correo, mutt utilizará colores (si la consola los soporta) para mostrar los distintos tipos de mensajes.

Spambayes es una herramienta bastante poderosa, que también permite entrenar para clasificar correos con base en otros criterios, por ejemplo si estuviéramos suscritos a un mailing list, colocar los correos de dicha lista de correos en un directorio particular; o si recibiéramos correos de ofertas de trabajo para colocar todos ellos en otro subdirectorio, etc.

Notas Finales
Con esto damos por terminado el tutorial para levantar un servidor de correos personal utilizando Postfix.

Aún quedan detalles por afinar, que podrían investigarse. Si algún día tengo el tiempo, tal vez haga tutoriales para los mismos:

Levantar un servidor de correos que pueda usar en una organización, a través de una LAN o internet, es cuestión que debe configurarse en Postfix. La documentación del sitio oficial de este programa ofrece varios escenarios para lograr distintas configuraciones deseadas.
Levantar servidores POP e IMAP, con Courier por ejemplo, para poder leer los correos que lleguen a la cuenta en el servidor a través de internet, con Squirrelmail, con un dispositivo móvil, con un cliente convencional en otra máquina, o con Fetchmail en otra máquina cliente.
Ampliar el funcionamiento de Spambayes para que clasifique correos con base en criterios como el uso de mailing lists o aquellos que pertenezcan a mis búsquedas de empleo, por ejemplo.

Espero hayas disfrutado siguiendo este tutorial, como yo haciéndolo. Y sobre todo, levantando tu propio servidor de correos. A mi me llevó meses enterarme bien de cómo funciona todo esto, y lograr que funcionara correctamente. Ojalá esta pequeña guía sirva de ayuda para el que se aventure en un camino similar...

Servidor de correos personal con postfix - Fetchmail

2010-08-24T11:38:00.000-07:00

Con este post continuamos con el 'Servidor de correos personal con postfix'. Una vez configurados el MTA, el MDA y el MUA, quedan detalles por afinar...

Fetchmail es un programa para recuperar correos desde servidores remotos. En realidad no es más que un cliente para los protocolos POP, IMAP, entre otros, que en lugar de desplegar los mensajes de correo (como cualquier cliente convencional de estos protocolos) los descarga para que sean recibidos en la máquina especificada y leídos posteriormente.

Es útil para conexiones de internet intermitentes (que no siempre están en línea), o para mantener una bandeja de entrada sincronizada con un servicio de correo remoto, como será el caso de este tutorial.

Obra del renombrado hacker Eric S. Raymond, Fetchmail es incluso el ejemplo clásico utilizado en su escrito 'La Catedral y el Bazar' para ilustrar cómo el proceso de desarrollo open source es un éxito, y no un caso aislado como se pensaba hasta el momento del kernel Linux. Este escrito fue de hecho la chispa que encendió el furor por el open source en el mundo empresarial, con lo que Netscape liberó el código fuente de su navegador (del que Mozilla Firefox es su heredero), y demás aventuras y desventuras del mundo del open source y el software libre desde entonces (1998)...

Aquí lo vamos a utilizar para recuperar los correos de una cuenta de Gmail (aunque podría ser cualquier otra, ¡o varias! siempre y cuando acepten los protocolos POP, IMAP o similares) cada cierto tiempo.

Instalación
Fetchmail se puede descargar desde su sitio oficial. O como siempre, puede instalarse desde la distribución de GNU/Linux que se tenga. En el caso de Debian el paquete es fetchmail.

Si se desea también se puede instalar el paquete fetchmailconf que es un script en Python, modo gráfico, para configurar fácilmente el programa.

Configuración
Aunque se utilice fetchmailconf, aquí describiremos el tras bambalinas de la configuración de Fetchmail, para entender cómo funciona.

Todo se hace en archivos RC, que pueden ser por usuario (~/.fetchmailrc) o de todo el sistema (/etc/fetchmailrc).

El archivo deberá contener las siguientes líneas:

set postmaster "postmaster"
set bouncemail
set no spambounce
set properties ""
set daemon 600

poll pop.gmail.com with proto POP3 port 995
     user 'gmailuser@gmail.com' there with ssl with
     password 'password' is 'usuarioservidor' here options
     keep

Obviamente, hay que editar la información pertinente para la cuenta de Gmail, el password y el nombre de usuario del sistema.

La línea daemon establece que fetchmail quedará ejecutándose en segundo plano, y que revisará por nuevos correos en la o las cuentas especificadas cada 600 segundos (10 minutos).

Se pueden tener tantas líneas poll como se desee, una por cuenta de correo que se desee sincronizar.

Más información se encuentra en la documentación de Fetchmail.

Uso
Bastará habilitar el script de inicio del servicio de Fetchmail en /etc/init.d para comenzar a ejecutarlo.

¡Listo! el servidor de correo personal ya está tomando forma. Cada 600 segundos (o el tiempo que se hubiera especifidado), Fetchmail debería de revisar la bandeja de la cuenta establecida, y en caso de encontrar nuevos correos, descargarlos. De hecho en el archivo de log de Postfix (/var/log/mail.info) debería de observarse actividad, cada 600 segundos cuando se despierte Fetchmail y se vuelva a dormir, además de cuando llegue a descargar correos.

Por último, vamos a enfocarnos en la seguridad, en el caso particular de este tutorial, a protegernos del spam...

Servidor de correos personal con postfix - MUA

2010-08-24T11:37:00.002-07:00

Continuamos con los posts dedicados a configurar un 'Servidor de correo personal con postfix'.

Previamente ya configuramos el MTA, Mail Transfer Agent y el MDA, Mail Delivery Agent.

Ahora vamos por el MUA, Mail User Agent, el cliente para leer y enviar correos. Normalmente esta parte es la que la gente toma como si fuera todo el sistema de correo, pero como ya hemos podido ver se trata de toda una infraestructura de sistemas.

En este tutorial vamos a configurar mutt como cliente de correo. Se trata de un cliente de consola muy sencillo pero muy completo a la vez. La razón es que su configuración es sencilla para los propósitos de este tutorial. Además, su sencillez permite entender un poco más cómo funciona el correo electrónico, que es de lo que se trata aquí.

Si lo que se pretende es utilizar algún otro software como cliente de email, habrá que hacer un poco de investigación para, por ejemplo, acceder al buzón desde Thunderbird, Evolution, Outlook, etc. Sin embargo, el proceso no debe de ser complicado.

En algún tutorial posterior, hablaremos de los protocolos POP e IMAP, que permitirán ver el correo de nuestro servidor personal desde cualquier cliente conectado a internet, desde clientes web (como Squirrelmail) hasta el uso de cualquier cliente que soporte estos protocolos (como en un dispositivo móvil), pasando también, claro, por los clientes convencionales ya mencionados, pero conectándose vía internet al servidor.

Instalación
mutt se instala en Debian con el paquete mutt. También puede descargarse desde su sitio oficial.

Configuración
Lo primero es establecer una variable de entorno para que mutt sepa en donde buscar el email a leer:

$ export MAIL='~/Mail'

obviamente, el nombre del subdirectorio cambia de acuerdo a lo configurado en Postfix. Esta línea no basta con ejecutarla y ya, debería de colocarse en algún script, como ~/.bashrc para que se ejecute cada vez que se inicia una nueva sesión de consola, de lo contrario sólo durará mientras dure la sesión actual.

Otra manera de configurarlo es através de un archivo de configuración por usuario: ~/.muttrc
que debería de incluir esta línea:

set folder = /home/jstitch/Mail

Si somos usuarios adictos a la consola, seguramente tendremos un editor de preferencia... En mi caso uso Emacs. El editor de preferencia se configura con la siguiente línea:

set editor=emacs

Esto es importante: como todos los buenos programas que siguen la filosofía Unix, mutt se especializa en una sola cosa: es un MUA, un cliente de correo. ¡Ni siquiera cuenta con su propio editor de texto! De esta forma delega la responsabilidad de redactar un correo al editor que se defina, o al que esté definido por defecto en el sistema. Con esto además, el usuario será libre de elegir su propio editor, para que se sienta más a gusto. En un cliente de correo convencional por lo general se cuenta con el editor que proporcione el cliente, ¡que poca libertad de elección!

Otras configuraciones interesantes para mutt (¡y hay muchas más! basta ver la documentación en el sitio oficial...)

set signature="~/.signature"

establece el archivo que contiene la firma predefinida para los correos enviados. Habrá que crear dicho archivo y ponerle algún contenido. Como todos los verdaderos buenos clientes de correo, mutt agrega un par de guiones '--' antes de la firma para que quien lea los correos sepa que se trata de la firma, y no más del cuerpo del correo.

my_hdr From: Javier Novoa C.

establece el header From que llevarán los correos a enviar con mutt

Además, mutt puede utilizar con el archivo ~/.muttprintrc que permite definir instrucciones para imprimir los correos.

Uso
mutt se ejecuta en consola. Para lanzarlo hay que teclear

mutt

aparecerá una pantalla ocupando toda la consola, pues mutt utiliza ncurses.

Los comandos que acepta mutt son básicamente letras para realizar acciones.

m permite enviar un mail, solicitará el destino, el asunto y luego abrirá el editor para redactar el mensaje. Basta guardarlo en donde lo haya solicitado mutt y salir para que se tenga el email redactado. Luego con Y se enviará el correo.

La pantalla está casi totalmente ocupada por la bandeja de entrada en ~/Mail (o donde sea que se haya configurado). Si hay correos, estos aparecerán aquí. Con las flechas se puede navegar para seleccionar un mensaje, y con INTRO para verlo.

D permite borrar el mensaje seleccionado

q permite salir

? proporciona la ayuda, más completa que esta, del programa.

Notas finales
Y ahora es tiempo de terminar de configurar el MTA, como se había dicho en el post correspondiente. Aún faltaba el detalle de permitir que Gmail enviara correos a nombre del servidor, sin usar el remitente con la dirección de Gmail.

Ya se explicó cómo configurar Gmail para esto, pero faltaba validar el proceso.
Si todo se realizó correctamente, tuvo que haber llegado a la bandeja de entrada un correo de parte de Gmail para validar. Habrá que acceder a una URL para terminar la validación, o copiar un código de verificación y usarlo en la misma configuración de Gmail para terminar.

Hecho esto, la dirección de correo especificada, usuario@dominio, deberá de aparecer en la lista de orígenes válidos de Gmail, y en adelante los correos enviados desde el servidor deberían de llegar a sus destinos como proviniendo del servidor, no de Gmail (aún cuando Gmail se siga usando como relay para poder enviar dichos correos).

Y listo, con esto ya se tiene un sistema de correo funcional para enviar y recibir correos. Aún vamos a configurar un par de programas que resultarán muy útiles para terminar este tutorial.

Empecemos con Fetchmail...