Hay una herramienta que facilita la instalación y el manejo de distintas versiones de Perl de forma simultanea en una misma máquina App::Perlbrew. Esta aplicación se encarga de crear un entorno completo de Perl en nuestro directorio home, que podemos manejar sin necesidad de tener permisos de administrador, esto trae muchas ventajas ya que nos permite probar cualquier cosa sin necesidad de utilizar (dañar) nuestro sistema base. Todo lo que instalemos (módulos CPAN) estará dentro de este entorno, las aplicaciones que quisiéramos probar usarán este entorno también, entonces podemos ver el funcionamiento de la misma en distintas versiones de Perl, con distintas versiones de módulos, etc. las posibilidades son muchas. Incluso podremos tener una versión antigua de Perl, quizás la 5.8, ya que existe mucha gente que aún no ha migrado a la 5.10 y así podemos asegurarnos que nuestros programas corran en cualquiera de las distintas versiones de Perl.

La instalación es bastante sencilla, no se necesita permisos de administrador y todo será almacenado en el directorio de nuestro usuario. Lo recomendable para la instalación es obtenerlo directamente desde el sitio del desarrollador:

curl -LO http://xrl.us/perlbrew

luego darle permisos de ejecución al script:

chmod +x perlbrew

y finalmente ejecutar el script:

./perlbrew install

Ya con eso tenemos instalado perlbrew y podemos empezar a usarlo, para las configuraciones básicas ejecutamos el siguiente comando:

perlbrew init

y seguimos las instrucciones que nos aparecen, que en realidad es agregar algunas variables de entorno al archivo .bashrc. Una vez realizado este paso de configuración, estamos listos para instalar cualquier versión de Perl que necesitemos, por ejemplo:

perlbrew install perl-5.12.1

luego de esperar que la descargue y configure, podemos hacer uso de esa versión de Perl de la siguiente manera:

perlbrew switch perl-5.12.1

esto cambiara nuestro entorno, la documentación recomienda que se ejecute el comando hash -r para limpiar el cache de la variable PATH, luego de esto al ejecutar perl -v deberíamos estar trabajando con la versión de Perl recientemente instalada. Todo lo que instalamos usando CPAN estará dentro de este entorno.

Si luego queremos “desactivar” este entorno podemos ejecutar el comando:

perlbrew off

y volveremos a nuestra aburrida instalación de Perl del sistema base.

Podemos instalar la cantidad de versiones que queramos, para listar cuales hemos instalado ejecutamos el comando:

perlbrew installed

Esta es una buena forma de empezar a probar Perl, si es que aún no lo has hecho ya.

Para instalarlo podemos hacerlo directamente desde CPAN, ejecutando el comando:

sudo cpan Dancer


No hay aún paquetes oficiales para Debian (o derivados), yo hice el paquete y las dependencias que necesita, pueden descargarlos desde aquí:

libhttp-server-simple-perl, se necesita la versión >=0.42, en Debian aún está la 0.41
libhttp-server-simple-psgi-perl
libdancer-perl

Luego de tener Dancer instalado, crear una aplicación nueva es tan simple como:

dancer -a miaplicacion


Este comando crea una estructura sencilla de la aplicación, lo siguiente sería modificar las rutas que se van a usar, en este caso eso está en el archivo miaplicacion.pm:

1
2
3
4
5
6
7
8
9
10
11

use Dancer;
 
get '/' => sub {
    return 'Hola Mundo!'
};
 
get '/hola/:nombre' => sub {
  return "Hola " . params->{nombre};
};
 
dance;

Dancer tiene muchas más opciones, como por ejemplo devolver el contenido en formatos JSON, XML, YAML directamente sin necesidad de procesar o ejecutar acciones distintas (piensa en un webservice que devuelve contenido en JSON para otra aplicación…), uso de plantillas, manejo de sesiones, etc. Además que se puede integrar con otros módulos de CPAN para lograr aplicaciones más elaboradas.

Una buena opción para aplicaciones sencillas, y sin mucho esfuerzo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#!/usr/share/bin/perl
 
use Modern::Perl;
use Math::MatrixReal;
 
say"Indique el valor de N, se creara un grid NxN: ";
my $n = <STDIN>;
chomp($n);
say "Indique la cantidad de iteraciones: ";
my $iter = <STDIN>;
chomp($iter);
 
my ($x,$y);
 
my $grid = Math::MatrixReal->new_random($n,$n,{bounded_by=>[-1,2], integer=>1});
$grid->display_precision(0);
 
system('clear');
say "INICIO";
impgrid($grid);
sleep(2);
 
for (my $it = 1; $it <= $iter; $it++) {
my $gridtemp = $grid->clone();
$gridtemp->each( sub{ 	my (undef,$i,$j) = @_; 
			#say "$i -- $j";
			my $newval = evalua($i,$j);
			$gridtemp->assign($i,$j,$newval); 
		} 
		);
 
system('clear');
$gridtemp->display_precision(0);
say "Iteracion = $it";
impgrid($gridtemp);
sleep(1);
 
 
$grid = $gridtemp ;
$grid->display_precision(0);
 
}
 
sub impgrid {
	my $pgrid = shift;
	for (my $i=1; $i<=$n; $i++) {
	 for (my $ii =1; $ii <= $n; $ii++) {
	 	my $valc = $pgrid->element($i,$ii);
		my $printc = "*";
		$printc = " " if $valc == 0;
		print "$printc ";
	 }
	 print "\n";
	}
}
 
sub evalua {
	$x= shift;
	$y = shift;
	my $tot = 0;
	my ($xant,$xsig,$yant,$ysig) = vecinos($x,$y);
	my $newval = 0;
	my $celula = $grid->element($x,$y);
	$tot = $tot + $grid->element($xant,$y);
	$tot = $tot + $grid->element($xant,$ysig);
	$tot = $tot + $grid->element($x,$ysig);
	$tot = $tot + $grid->element($xsig,$ysig);
	$tot = $tot + $grid->element($xsig,$y);
	$tot = $tot + $grid->element($xsig,$yant);
	$tot = $tot + $grid->element($x,$yant);
	$tot = $tot + $grid->element($xant,$yant);
	$newval = 1 if ( (($celula == 1) && (($tot == 2) || ($tot == 3))) || (($celula == 0) && ($tot == 3)) );
	return $newval;
}
 
sub vecinos {
	my $x = shift;
	my $y = shift;
	my $xant = ( $x == 1 ) ? $n : ( $x - 1 );
	my $xsig = ( $x == $n ) ? 1 : ( $x + 1 );
	my $yant = ( $y == 1 ) ? $n : ( $y - 1 );
	my $ysig = ( $y == $n ) ? 1 : ($y + 1);
	return ($xant,$xsig,$yant,$ysig);
}

Estoy usando el modulo Math::MatrixReal que permite interactuar de una manera rápida y sencilla con matrices.

• Lo primero que hacemos es modificar la lista de repositorios y agregar una línea con algún repositorio de Squeeze, puede ser una de las mismas que tenemos en “/etc/apt/sources.list” y se cambia “stable” o “lenny” por “squeeze“, guardamos los cambios y actualizamos la lista de paquetes con “aptitude update”.
• OpenERP trabaja con PostgreSQL así que vamos a necesitar instalarlo, este se instala como una recomendación de OpenERP y al estar usando los repositorios de Squeeze va a solicitar instalar la ultima versión disponible, a la fecha es la 8.4, así que si ya se tiene instalado el servidor PostgreSQL se usa la siguiente línea para instalar solo el servidor de OpenERP y las dependencias necesarias:aptitude install --without-recommends openerp-server
  Con esto instalamos solo lo necesario para tener el servidor de OpenERP corriendo.
• Luego podemos instalar algunas otros paquetes de los recomendados por el paquete openerp-server
  aptitude install python-imaging python-openssl python-pyparsing libxslt1-dev
• Necesitamos un usuario postgresql para el servidor openerp, lo podemos crear con el siguiente comando:
  su - postgres -c "createuser --createdb --no-createrole --pwprompt openerp"
  Con esta línea estamos creando un usuario llamado “openerp” se puede usar otro nombre, además va a pedir una contraseña que es la que vamos a utilizar posteriormente para hacer la conexión a la BD
• Tenemos que editar el archivo /etc/openerp-server.conf para agregar el password del usuario de la BD
• Reiniciamos el servicio openerp:
  /etc/init.d/openerp-server restart

Con estos pasos ya tenemos configurado y funcionando el servidor OpenERP, lo que queda es configurarlo, eso lo podemos hacer utilizando el cliente OpenERP, existe una versión escrita en GTK, que se puede instalar directamente con: aptitude install openerp-client. La otra forma, es usar el cliente web, como estás usando un servidor lo podemos instalar en la misma máquina y acceder desde cualquier máquina directamente solo usando un navegador. No hay un paquete Debian aún para el cliente web, existe uno que están preparando, pero no funcionó bien luego de instalarlo, así que utilicé la opción de instalarlo a mano, los pasos para hacerlo funcionar serían los siguientes:

• Descargamos el cliente web de la página de OpenERP
• El cliente web está escrito en Python y necesitamos instalar algunas librerías para que pueda funcionar correctamente, podemos instalar estos paquetes con la siguiente línea:
  sudo aptitude install python-cherrypy3 python-formencode python-simplejson python-mako python-pybabel
• Este cliente ejecuta un servicio que corre por defecto en el puerto 8080, así que podemos ejecutarlo desde donde queramos, en mi caso copié el contenido de la carpeta en/opt/openerp-web/, desde ahí podemos probarlo ejecutando el comando: 
  python openerp-web.py
  Si no genera ningún error, ya esta funcionando perfectamente y podemos acceder desde cualquier navegador con la dirección: http://ip.del.servidor:8080, al ingresar la primera vez se necesita configurar la BD y crear la instancia que vamos a usar, además de poder crear usuarios.

Lo ideal sería configurar el cliente para que se inicie como un servicio del sistema y no tener que estar levantando cada vez que queramos usarlo, para esto podemos hacer lo siguiente:

• El cliente web provee un script que podemos utilizar para usarlo como un servicio del sistema, este script lo podemos copiar a la carpeta /etc/init.d :
  cp /opt/scripts/openerp-web /etc/init.d/
• Debes modificar ese script, buscamos la línea donde aparece “DAEMON” que contiene la ruta donde está el ejecutable del cliente web y ponemos la que corresponde con nuestra instalación:
  DAEMON=/opt/openerp-web/openerp-web.py
• Tambien es necesario copiar el archivo de configuración del cliente web a la carpeta /etc:
  cp config/openerp-web.cfg /etc/
• Esto es opcional, pero podemos crear la carpeta de logs y darle los permisos necesarios:
  mkdir -p /var/log/openerp-web
chmod -R openerp:adm /var/log/openerp-web
• Luego, lo más importante, configurar openerp-web para que sea cargado al arrancar el sistema, lo hacemos con el comando update-rc.d de Debian:
  update-rc.d openerp-web start 70 2 3 4 5 . stop 20 0 1 6 .
• Y listo, una vez realizado esto, simplemente podemos iniciar el servicio con el comando:
  /etc/init.d/openerp-web start

Con estos pasos podemos tener OpenERP completamente funcionando en un servidor con Debian Lenny, si hicieron la parte de utilizar directamente los repositorios de Debian Squeez debe volver a quitarlos del archivo /etc/apt/sources.list para evitar problemas en próximas actualizaciones.

Se puede configurar el cliente web para que funcione directamente con Apache, y poder accederlo usando https, eso lo estaré publicando en otra entrada

Luego de pasar por todos estos problemas, se decide implementar algún sistema de información que permite manejar todos los datos de manera más eficiente, y claro no van a empezar a generar los registros otra vez por que ya los tienen en muchos archivos .xls. Ahí es cuando se empiezan a buscar soluciones para poder extraer estos datos rápidamente, y ahí es cuando viene Perl al rescate . Existe un modulo (entre muchos) que nos permiten trabajar con archivos .xls sin necesidad de estar abriéndolos uno por uno Spreadsheet::ParseExcel, este modulo nos permite abrir archivos excel y extraer toda la información que contiene. Voy a poner un pequeño ejemplo del funcionamiento del modulo, supongamos que tenemos un archivo excel con la siguiente estructura:

Archivo Excel

Un archivo con 4 columnas, en este caso corresponden a la siguiente información: Nombre, Apellido, Cédula y Correo. Estos datos serán almacenados en la tabla “persona” en una BD Postgresql.

Se deben extraer los registros del archivo excel, identificar los campos, y luego almacenarlos en la BD, un ejemplo de como se puede hacer esto con Perl y SpreadSheet::ParseExcel es el siguiente script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#!/usr/bin/perl
use Modern::Perl;
use Spreadsheet::ParseExcel;
use DBI;
use DBD::Pg;
 
my $userbd = "prueba"; #Nombre de usuario para la BD
my $passbd = "prueba"; #Password del usuario
my $bd = "prueba"; #Nombre de la BD
#conexión a la BD
my $dbh = DBI->connect("dbi:Pg:dbname=$bd",$userbd,$passbd) or die $DBI::errstr;
#sentencia SQL a ejecutar
my $query = "INSERT INTO persona (nombre, apellido, cedula, email) VALUES (?, ?, ?, ?)";
#se crea un objeto nuevo
my $parser = Spreadsheet::ParseExcel->new();
#se utiliza el metodo "Parse" para indicar el archivo .xls a usar
my $workbook = $parser->Parse('personas.xls');
#si no puedo "parsear" el archivo se termina el programa
die $parser->error(), ".\n" if !defined $workbook;
#indicamos que vamos a trabajar con la primera hoja
my $worksheet = $workbook->worksheet(0);
#obtenemos el rango de las filas usadas en la hoja
my ( $row_min, $row_max ) = $worksheet->row_range();
 
for my $row ( 0 .. $row_max ) {
 
 my $nombre = $worksheet->get_cell( $row, 0 );
 my $apellido = $worksheet->get_cell( $row, 1 );
 my $cedula = $worksheet->get_cell( $row, 2 );
 my $email = $worksheet->get_cell( $row, 3 );
 
 my $sth = $dbh->prepare($query);
 $sth->execute($nombre->value(),$apellido->value(),$cedula->value(),$email->value());
 $sth->finish;
 say "Persona: ", $nombre->value()," ",$apellido->value(), " - Cedula: ", $cedula->value(), " - Email:", $email->value() ,"\n";
 
}

En la línea 2 estamos haciendo uso del modulo Modern::Perl, que activa varias opciones al usar Perl 5.10, para más información puedes ver el post en Perliscopio: Usando Perl Moderno. De la línea 7 a la 11 está toda la información relacionada a la BD. En la línea 21 especificamos con cual de las hojas del archivo .xls vamos a trabar, en este caso con la primera que correspondería a la número 0, se pueden usar varias hojas en caso de que existan, en vez de  “worksheet”  usaríamos “worksheets”.

En la línea 25 obtenemos el rango de columnas que son utilizadas en la hoja, con esto podemos conocer donde están los registros dentro de la hoja, se puede además conocer la cantidad de columnas utilizadas usando la opción “col_range”. Luego en la linea 27 empezamos un ciclo recorriendo todas las filas para obtener los datos, para acceder a una celda se usa el método “get_cell”, con esto podemos tener acceso a varios atributos de la celda entre las cuales está la que más nos interesa que la que contiene el dato que vamos a usar para guardar el registro, y al que podemos acceder directamente con el metodo “value”.

En las líneas 32 al 34 se hacen las operaciones en la BD utilizando los métodos tradicionales de DBI, quizás para algunos casos más complicados se podría usar DBIx::Class, pero como en este caso solo utilizamos una tabla no es necesario.

Esto es solo un ejemplo sencillo de como realizar una tarea tan tediosa como puede ser extraer información de este tipo de archivos, además que se puede sacar más provecho al usar un lenguaje con tanta flexibilidad como Perl.

La forma más fácil de instalar, si usas Debian, es agregar los repositorios de la rama inestable, con un simple: aptitude install  padre tendremos todo instalado y configurado, hacer la instalación manualmente desde CPAN es muy complicado ya que requiere muchas dependencias.

Padre tiene bastantes características interesantes, todas las que debe tener un editor decente y la posibilidad de agregarle plugins. Los plugins se pueden conseguir en CPAN o los puedes crear tu mismo. Unos de los plugins que mas me ha gustado es Padre::Plugin::Catalyst, que permite agregar al editor un menú contextual para crear/administrar aplicaciones creadas con Catalyst, algo así como una “interfaz gráfica” para el framework.

El equipo de desarrollo es bastante activo y estan haciendo un excelente trabajo, hay muchas ideas de agregados y funcionalidades que quieren ofrecer en las próximas versiones, vale la pena probarlo, otra alternativa más para programar en Perl.

Algunas capturas de Pantalla:

Crear aplicación Catalyst

Menu Contextual Catalyst