|
|
La mayoría de los sistemas operativos basados en Unix vienen con una versión de Perl instalada, dependiendo de que tan actualizado este el sistema podemos tener la última versión del lenguaje. Por ejemplo en Debian Testing (Squeeze aún) tenemos la versión 5.10.1, en Mac OSX Snow Leopard la versión 5.10.0 (pongo estos 2 ejemplos por que son los sistemas operativos que uso). Si quisiéramos probar alguna versión más nueva de Perl podríamos instalar desde las fuentes o quizás usando los paquetes .deb en el caso de Debian, pero quizás tengamos algunos problemas con las dependencias y podríamos dañar nuestro sistema base.
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.
Dancer es un framework web ligero, que nos permite hacer aplicaciones de forma rápida y sencilla. Es una alternativa excelente cuando no quieras escribir los scripts CGI a mano y Catalyst es demasiado engorroso para implementar. Como cualquier otro framework trae un servidor web embebido para hacer pruebas y puede correr con otros servidores web usando PSGI/Plack.
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 
Revisando algunos archivos guardados de trabajos que hice para las clases en la universidad, conseguí un programa que hice en Perl para un curso que se llamaba Computación Emergente. Es una implementación de el juego de la vida bastante sencilla, lo interesante de esto es que nadie en el curso conocía algo sobre Perl, y todos hicieron la implementación en Matlab, por que según era más fácil para manejar las matrices, y hacer las iteraciones, etc, etc .. así que pensé en hacerlo usando otras herramientas, y esto fue lo que salió, la idea es crear una matriz de N x N y ejecutar todas las reglas o algoritmos en un determinado número de iteraciones. El código quizás se pueda mejorar, pero con esto bastó para sacar 20 en esta asignación :
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.
 OpenERP es una de las mejores soluciones en software libre para el sector empresarial y de negocios. Tiene muy bien estructurado el esquema de extensiones de modulos y puede adaptarse fácilmente a cualquier escenario de negocios.
Existen paquetes preparados para instalarlo en Debian Squeeze (testing), pero no los hay para Debian Lenny (stable), se puede instalar desde las fuentes bajando algunas dependencias a mano y haciendo algunos ajustes, pero esa no es la Debian Way . Se puede descargar los paquetes de Squeeze a mano e instalarlos pero igual hay que resolver algunas dependencias, así que una opción es utilizar directamente los repositorios de Squeeze en Lenny. Esto podría ocasionar algunos problemas en algún servidor en producción, por que algunos paquetes pueden ser actualizados a versiones más recientes y romper dependencias con otros, por eso hay que tener en cuenta esto antes de hacer algo así y estar atento a los cambios que se van a realizar antes de instalar cualquier cosa.
- 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
Existe una (mala) costumbre de almacenar datos en archivos excel en muchas organizaciones, grandes o pequeñas, esto funciona cuando los datos no son muchos y se pueden manejar rápidamente, pero por lo general esta información va creciendo y se va haciendo más difícil mantener la integridad de los datos, a veces se tienen varias versiones del archivo .xls, a veces se pierden o se borran por equivocación, etc.
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.
|
|
