I'm 01100110 01100101 01100101 01101100 01101001 01101110 01100111 00100000 01101100 01110101 01100011 01101011 01111001 00001010

I had previously written (in Spanish, for La Columna de Perl), how to quickly decode this "way" of binary writing with Perl's chr and oct. So, to find out what was Google really tweeting, run:

perl -e 'map { print chr oct "0b".$_; } split /\s/, "01100110 01100101 01100101 01101100 01101001 01101110 01100111 00100000 01101100 01110101 01100011 01101011 01111001 00001010";'

So, what's really happening with this snippet? Well, the zeroes-ones string is being passed to the split function that explodes the string with a whitespace delimiter and passes that exploded string, a list, to map. map takes each one of the elements, the 8-character substring, one by one and preppends "0b" so that oct can understand it as an octal string and returns the value for that character. Then, that value is passed to chr that takes the numerical representation of a given character and returns that character. Then, it's just passed to print that, surprise, prints out that value.

How do you do it in your language of choice?

Estoy trabajando con algunos contadores. Tengo que agregar un nuevo contador por hora e ir sumando el contador principal durante la hora actual, sin mucho problema, ¿no? Sin embargo, si la hora actual no existe en la base de datos, tengo que crear un nuevo registro. Debido a mi pésima capacidad bajo cualquier cosa que contenga las siglas SQL, tuve que platicar con alguien más para que diera una idea simple y clara de qué hacer.

Intento sumar el contador dada la hora actual, pero si no afectó a ninguna fila, entonces creo la fila. Ese concepto es mucho mejor que hacer un count(*) primero, validar si existe la fila, crearla si no, actualizarla si sí. Para verificar si mi primer query (el "UPDATE") afectó a alguna columna, podemos usar el método do() que provee DBI y que hereda tu DBD favorito, en mi caso, pues no tengo otra alternativa y a final de cuentas me termina valiendo un pepino por el momento, uso DBD::mysql.

do() regresa, en contexto escalar, el número de filas afectadas por el query que se le haya pasado. Sin embargo, y aquí viene lo interesante y el tip del día, utiliza un valor llamado "0E0", una cadena. Si fueron afectadas, digamos, 3 filas por el query, do() regresará ese número, pero si no fue afectada ninguna fila, es decir, cero filas, regresa el valor "0E0", que es básicamente "cero, pero cierto".

Como bien se sabe (y si no sabes, deberías saber), valores como cadenas vacías o ceros, se evalúan como falsas en las operaciones binarias en Perl. Sin embargo, "0E0" se traduce a cero, pero con un valor verdadero, lo cual es muy útil para muchos otros casos en los que obtener un cero podamos usar como valor verdadero.

En mi ejemplo, usé:

my $aff_rows = $sth->do($query);

if($arr_rows == 0) { # Este bloque se ejecuta }

Que es diferente a usar:

my $aff_rows = $sth->do($query);

if(!$arr_rows){ # Este bloque no }

El if evalúa si el valor de $arr_rows es cero, que en muchos casos sería validar si es cierto o falso, pero como $aff_rows es en realidad "cero pero cierto", entonces la condición resulta verdadera. En el segundo if, se valida si el valor de $arr_rows no es verdadero, que en casos comunes sería lo mismo que el primer if, pero la validación resulta falsa y no se ejecuta el bloque. Chido, ¿no?

• La Columna.pl #4
  • Automatización en web con WWW::Mechanize
    • Introducción
    • Script
    • Fin
    • Referencias Útiles
  • Autor
  • Licencia de uso
• Sobre La Columna.pl

La Columna.pl #4

Automatización en web con WWW::Mechanize

Introducción

WWW::Mechanize

es un módulo muy interesante. Básicamente nos permite automatizar o mecanizar una conversación a través de una página web. Es decir, poder automatizar el procesamiento de enlaces, imágenes, formas, etc. En realidad WWW::Mechanize actúa como una subclase de LWP::UserAgent, que es el mítico LWP en Perl.

Hay que entender que todo lo que hacemos en un navegador web, o casi todo, es posible automatizarlo por medio de scripts, debido a que lo que en realidad sucede es que trabajamos con cabeceras y cuerpo HTTP, tanto en petición como en respuesta. Todo es a través del protocolo HTTP.

Mi trabajo actual requiere mucha interacción automatizada con páginas web y WWW::Mechanize me ha permitido hacer desarrollos muchos más rápidos, mucho mejor encapsulados y con un nivel de abstracción menor.

En esta cuarta columna, quiero hacer algo para mostrar de qué es capaz WWW::Mechanize y que ustedes, amables lectores, vean su utilidad real. Lo que haré será un proceso de autenticación en el wiki del proyecto Debian y la obtención de una de sus páginas. Básicamente es loguearme en el wiki y obtener el valor de uno de los campos de una forma. Lo interesante en este asunto viene al automatizar el login en un sistema basado en web, escribir en una forma y enviar forma, obtener campos, etc: WWW::Mechanize lo hace muy simple.

Manos a la obra.

Script

Vamos a empezar por invocar a nuestro intérprete de Perl activando warnings, así como el pragma strict.

 #!/usr/bin/perl -w

 use strict;

Como necesitaremos un nombre de usuario y contraseña para acceder el wiki en Debian (es necesario para editar páginas), vamos a tomarlos como argumentos:

 my $username = $ARGV[0] || die "ERR: Es necesario especificar un nombre de usuario", "\n";

 my $password = $ARGV[1] || die "ERR: Es necesario especificiar una contraseña", "\n";

Los argumentos vienen en el arreglo @ARGV: El primer argumento de nuestro programa será el nombre de usuario y el segundo será la contraseña. Si no existen, entonces nuestro programa morirá.

A continuación llamamos al módulo WWW::Mechanize y creamos un objeto de ese tipo.

 use WWW::Mechanize;

 my $mech = WWW::Mechanize->new;

Bastante simple.

Ahora tenemos que ver qué es lo que haríamos desde un navegador convencional para hacer lo que queremos. Lo más lógico es que entráramos a la página del wiki de Debian, cuya URL es http://wiki.debian.org/. Vamos a hacerlo de la misma manera en el script.

 $mech->get('http://wiki.debian.org/');

 unless($mech->success) {

  die "Tuvimos problemas al acceder la página de Debian", "\n";

 }

Básicamente estamos utilizando dos métodos disponibles en Mechanize: get() y success(). El primero hará que nuestro objeto viaje hasta la página que le indiquemos. En cualquier caso, el método success() nos indica por medio de un valor booleano si la última operación que se realizó en Mechanize, fue exitosa o algo falló, lo cual nos sirve para tener más control del flujo de nuestra aplicación. Si no tenemos problemas con get(), entonces el programa no morirá con el mensaje especificado; sin embargo si sí hubo problema, es decir, success() regresa falso, entonces entrará en acción el die(). Continuemos.

Una vez que estamos en Firefox (u Opera, o Internet Explorer, no sé) en la página http://wiki.debian.org/, ¿qué es lo siguiente? Bueno, lo normal, que es al no estar logueados, nos aparezca un link que dice "Login". En un proceso común tendríamos que dar clic en él para continuar con el proceso de autenticación. Eso mismo haremos:

 $mech->follow_link(text => 'Login') or die "ERR: No pude dar clic en login", "\n";

Así de simple. Con el método follow_link() y el parámetro 'text', podemos indicarle a Mechanize que donde estamos actualmente, que sería la página frontal del wiki, siga el enlace cuyo texto es 'Login'. Mechanize nos permite incluso acomodar regex en estos campos, lo cual nos facilitaría aún más al lidiar con contenido dinámico o situaciones más complejas. Como follow_link() regresa realmente un objeto HTTP::Response en caso de éxito, también provee un retorno en caso de falla, que es undef. Así que si hubo una falla al intentar seguir el enlace, moriremos con el mensaje de error especificado.

Una vez que dimos clic en 'Login', podemos ver en nuestro navegador convencional que la página donde nos encontramos es aquella con la URL 'http://wiki.debian.org/UserPreferences'. En realidad pudimos habernos evitado algo de código al empezar nuestro primer get() con esta URL pero intentaba mostrar un poco de las bondades de Mechanize. ¿Qué tal si en tu script no sabes en qué URL se encuentra tu navegador de Mechanize? Puedes usar el método uri() e incluso el método response(). Eso te ayudará a analizar bien el flujo de tu programa.

En fin, en esa página de UserPreferences podemos ver que tenemos una forma para introducir "Name", "Password", etc. En realidad esos dos campos son los que realmente nos interesan. Para ésto, nos puede servir mucho la extensión WebDeveloper de Firefox, pues con ella podemos ver la información detallada de las formas en las páginas. Lo que queremos saber es cuál es nombre de la forma para ingresar el nombre de usuario y la contraseña, y además, el nombre de estos dos campos (hay que recordar que comúnmente las formas en HTML llevan un parámetro "name"). O incluso puedes intentar buscar estos parámetros viendo el código HTML directo desde la página.

Luego de ver el HTML (o de usar la extensión de Firefox) nos damos cuenta que en la página de autenticación de Debian hay tres formas, sin embargo, la forma donde se introducen el nombre de usuario y la contraseña, ¡no tiene nombre! Mechanize sabe que algunos webmasters no colocan esta información, así que provee otra forma en que puedes usar esas formas: Por número. Puedes especificar si trabajarás con la primera, segunda, tercera o enésima forma. En nuestro ejemplo, la forma de autenticación es la tercera:

 eval {

  $mech->form(3);

  $mech->submit_form('username' => $username, 'password' => $password);

 };

 die "ERR: Problemas al enviar la forma: $@", "\n" if $@;

Un bonito pedazo de código aquí. Lo primero que notamos es que usamos un bloque eval{} para encapsular dos métodos, form() y submit_form(). form() selecciona la forma con la que trabajaremos, en este caso la tercera y submit_form() envía esa forma con los campos indicados. Es bastante intuitivo, ¿no crees? Y ya, básicamente eso es lo único que necesitamos para autenticarnos. En caso de falla con submit_form(), la aplicación muere, sin embargo, eso lo intentamos evitar usando eval{}. Si algo dentro del bloque de eval fallara y muriera, eval{} llena una variable especial, $@ con el mensaje de error y ya después nosotros podemos morir o hacer lo que queramos. Bonito, ¿no es así?

Una vez que mandamos la forma, tenemos que asegurarnos que no nos haya mandado mensaje de password erróneo o algo así. Una cosa es que el envío de la forma con sus parámetros sea exitoso o no, y otra diferente que la información de usuario y contraseña sean incorrectos. ¿Cómo saber lo que necesitamos para identificar ésto? Podemos intentar en nuestro Firefox poniendo información errónea en estos campos e intentar loguearse. Al hacer pruebas de este tipo veo que es diferente si el usuario no existe o si la contraseña es errónea.

Si el usuario no existe, la página nos manda un error que dice: "Unknown user name: "sdfsdfsdf". Please enter user name and password.". Si la contraseña está mal (o sea, el usuario existe, pero la contraseña es errónea), la página despliega: "Sorry, wrong password.". Vamos a ver cómo controlaríamos dichos mensajes:

 die "Unknown user name!", "\n" if $mech->content =~ /Unknown user name/;

 die "Wrong password!", "\n" if $mech->content =~ /Sorry, wrong password/;

¡Qué sencillo! Morimos en caso de que el método content(), que nos regresa la cadena con todo el HTML de la página actual, contiene alguna de ambas cadenas. Código simple para regexs simples. Si no tenemos ninguno de ambos, asumimos que estaremos ya bien logueados.

Ahora, ¿qué es lo que queremos hacer? Digamos que queremos obtener lo que nuestra propia página tiene escrito. Las páginas de los usuarios son simples páginas del wiki con nuestro nombre de usuario, en mi caso, "http://wiki.debian.org/DavidMorenoGarza", o lo que es lo mismo "http://wiki.debian.org/$username":

 $mech->get("http://wiki.debian.org/$username");

Estando en dicha página hay en enlace que dice "Edit", ese es en el que tendríamos que dar clic para entrar a la forma directa de nuestra página:

 $mech->follow_link(text => 'Edit');

Y una vez en la página de edición, nos encontramos con una forma nuevamente, que es básicamente la caja de edición de la página. Al leer el HTML o usando WebDeveloper, nos encontramos con que la forma sí tiene nombre y la caja con el texto de la página se encuentra en un campo llamado "editor-textarea". Pues vamos a obtener ese texto:

 $mech->form_name('editor');

 my $pagetext = $mech->value("editor-textarea");

Con eso seleccionamos la forma cuyo nombre es "editor" y con value(), seleccionamos el valor de "editor-textarea" y lo guardamos en la variable $pagetext.

¿Qué más podemos hacer? Lo que queramos, quizás queremos usar ese valor y escribirlo en un archivo, modificarlo y volverlo a guardar, obtener el preview luego de modificarlo, etc, etc. En realidad desde aquí la imaginación es el límite.

Fin

Una regla de oro que he aprendido luego de usar mucho WWW::Mechanize es que casi todo lo que puedas hacer en un navegador convencional, lo puedes hacer también con este módulo. No, no puedes interpretar JavaScript, pero muchas veces no lo necesitas si saber leer bien el HTML de una página y entiendes lo que estás realmente haciendo. A final de cuentas si entiendes perfectamente lo que pasa en una conversación por HTTP quizás ni siquiera necesites Mechanize, pues como un amigo me comentaba, Mechanize es simplemente una rompecabezas armado de muchos módulos alrededor de LWP.

Hazme llegar tus preguntas o comentarios a mi correo, damog@espiral.org.mx. Estaré encantado de saber qué usos le das a Mechanize.

Referencias Útiles

• http://search.cpan.org/~petdance/WWW-Mechanize-1.30/lib/WWW/Mechanize.pm
• http://search.cpan.org/~gaas/libwww-perl-5.808/lib/LWP/UserAgent.pm
• http://wiki.debian.org/
• http://wiki.debian.org/UserPreferences
• http://search.cpan.org/~petdance/WWW-Mechanize-1.30/lib/WWW/Mechanize/Examples.pod

Autor

Durante el día, David Moreno Garza (http://www.damog.net/) desarrolla aplicaciones, sistemas y proyectos para una incipiente empresa norteamericana;; adicionalmente es consultor independiente en empresas mexicanas y extranjeras utilizando Perl. Durante la noche intenta salvar al mundo del mal usando expresiones regulares y netiquette.

Licencia de uso

Copyright © 2007 David Moreno Garza.

This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/).

Sobre La Columna.pl

La Columna.pl

es una columna quincenal que escribe el autor alrededor de Perl. Está inspirada en las columnas que Randal L. Schwartz ha escrito desde hace varios años. Por medio de recetas, consejos, instructivos y guías, el autor pretende propiciar interés en la gente para que conozca un poco más a fondo este apasionante lenguaje de programación y así fomentar una comunidad más sólida alrededor de él.

Visite http://www.damog.net/la-columnapl.

Redirecciones

Bueno, el ofrecer disculpas por tardanzas tan prolongadas en la entrega de esta columna, ya se está haciendo costumbre, ¡y apenas van tres columnas! Por ahora mejor tomaré otro approach para las próximas liberaciones de la misma: Se harán nuevas entregas cuando estén listas. Un enfoque plenamente debianero.

Como sea, durante el mes pasado estuve principalmente preparándome, asistiendo y recuperándome de la Debian Conference que se llevó a cabo en las tierras del whisky, Escocia (pueden ver fotografías en mi galería). Como éste era un viaje que había planeado con mucha antelación, cuando supe que el YAPC::NA se realizaría en Houston, no pude dejar de lamentarme semanas y semanas por que estaría destinado a no asistir. En fin, a ver qué tal el próximo año. Gracias a las personas que preguntaron sobre el paradero de ésta, su columna de confianza.

En fin.

En los últimos días estuve revisando un sitio que implementaba cosas interesantes. Entre ellas, una aplicación que hacía redirecciones en web. Éstas son algo populares, pero no muy conocidos: Una aplicacioncita web que nos permite crear URLs del tipo: http://www.midominio.com/cgi-bin/forward.cgi?url=damog.net. Básicamente, es un CGI que recibe un argumento y hace una redirección hacia ese sitio, ¿muy simple? Quizás sí, pero nosotros podemos agregarle mucha más funcionalidad muy interesante. Es cierto que dichas redirecciones pueden hacerse con mod_rewrite de Apache o similares, pero obviamente no le podemos agregar tanta flexibilidad y triques como con un script en Perl.

Lo que quiero, entonces, es un redireccionador que en primer lugar, verifique que la URL sea válida, quizá escribir en un log o una base de datos y haga la redirección. Además, utilizaremos un poco de rewrites para añadirle un poco de atractivo visual al asunto.

Empezaré a escribir el redir.cgi:

 #!/usr/bin/perl

use strict;
use warnings;

use CGI qw(:standard);
use Data::Validate::URI qw(is_http_uri is_https_uri);

my $url = param('url') || 'http://www.damog.net/‘;
$url =~ s/^http(s?)://http$1:///;

&wrong($url) unless is_http_uri($url) || is_https_uri($url);

# Más código…
# Quizás escribir a un log, etc..
print “Location: $url”, “\n\n”;

sub wrong {
my ($url) = shift;
print “Content-Type: text/plain”, “\n\n”;
print “It looks like $url is not a valid URL!”;
exit;
}

Es un código bastante corto y simple. Usamos un par de pragmas, un par de módulos, procesamos el parámetro que recibiremos, validamos y redireccionamos. Vamos por partes. Para poder realizar este ejemplo, necesitaremos tener habilitada la ejecución de CGIs en nuestro servidor web. Para más información al respecto, puedes revisar la información de Apache o Cherokee al respecto, la explicación de tal procedimiento está fuera de contexto en esta columna. Encuentra enlaces útiles más abajo, en la sección de Referencias útiles.

 #!/usr/bin/perl

use strict;
use warnings;

Desde luego, nuestro CGI necesitará saber dónde encontrar el intérprete para la ejecución. Además, como buena práctica de programación, añadiremos los pragmas strict y warnings. Desde un personal punto de vista, una vez que nuestra aplicación en desarrollo haya quedado limpia de errores fatales o advertencias, podríamos deshabilitar ambos pragmas, los cuales podrían volverse a cargar cuando se haga debugging o algo similar; pero a final de cuentas es sólo un punto de vista personal que cada quién seguirá teniendo sus propias razones y necesidades.

 use CGI qw(:standard);
use Data::Validate::URI qw (is_http_uri is_https_uri);

Utilizamos dos módulos. El primero es un módulo que pertenece a Perl y que nos permite un manejo muy sencillo de, claro, CGIs y todo alrededor de ellos. Nosotros realmente lo utilizamos para obtener el parámetro que se le mande al script, con la función param(), que de hecho puede recibir los parámetros tanto en HTTP GET o POST. También podríamos obtener dicho parámetro desde el hash %ENV, pero hay que hacer un poco más de talacha, así que mejor usaremos CGI.pm y listo.

Data::Validate::URI es un módulo que encontré en CPAN que hace mínimamente lo que necesitamos, validar URIs. Si una cadena es una URI de HTTP o HTTPS, se valida y regresará falso en dado que no lo sea. Eso es más que suficiente. La explicación sobre la instalación de módulos de CPAN queda fuera del contexto de esta columna.

 my $url = param('url') || 'http://www.damog.net/‘;
$url =~ s/^http(s?):/{1,2}/http$1:///g;

Creamos la variable $url con el parámetro GET o POST que nos traen al CGI. En caso de que no exista dicho valor, colocaremos alguna otra cadena, en mi caso, mi sitio. La siguiente línea tiene un poco de truco. Resulta que me idea era procesar este script pasándolo por una regla de Rewrite de Apache. Sin embargo, cuando mod_rewrite recibe en la URL la cadena ‘http://’, la cambia, por seguridad y motivos similares, a ‘http:/’, entonces cuando estaba haciendo pruebas con este redireccionamiento, el script fallaba pues intentaba entrar a digamos, ‘http:/google.com’; entonces la segunda línea es un hack para este comportamiento. ¿Pero qué hace la expresión regular? Bueno, hace un search and replace, en la cadena busca aquello que empieza con ‘http’, después puede contener o no (es decir, cero o una vez) la ’s’ -y ésto a su vez lo cachamos con un paréntesis-, seguido de dos puntos y una diagonal, que puede estar una o dos veces. Todo eso lo cambiamos por ‘http’, el valor que cachamos en el paréntesis, $1, dos puntos y dos diagonales. Lo hacemos las veces que sea necesario implementando el modificador ‘g’. Entonces, si recibimos ‘https:/google.com’ lo cambiará a ‘https://google.com’; y si recibimos ‘http://www.damog.net’, lo cambiará a, exactamente lo mismo, ‘http://www.damog.net’.

 &wrong($url) unless is_http_uri($url) || is_https_uri($url);

Llamamos a la subrutina wrong(), pasándole la URL, a menos que sea una URI de HTTP o de HTTPS válida. is_http_uri e is_https_uri nos devolverán indefinido, en caso de que falle la validación y lanzarán wrong, que lo único que hace realmente es imprimir un error en el browser. Veremos la subrutina unas cuantas líneas abajo. Antes pudimos haber guardado en base de datos, utilizar la variable $ENV{REMOTE_ADDR} o muchas cosas, usted decida.

 print "Location: $url", "\n\n";

Éste es un header que tenemos que colocar en la respuesta del cliente, para que el servidor tome la nueva URL y se haga una redirección. El usuario siempre debe recordar que los headers son colocados hasta cuando se encuentren dos nuevas líneas. De otra forma, nuestro servidor web local no definirá dónde acaban las cabeceras y no terminará la ejecución con error. Hasta este punto pasamos las validaciones y le aplicamos el hack para corregir el inconveniente con mod_rewrite. Desde luego que verificar si la URL es válida, es decir, que la URL nos lleve realmente a algún lado o página con contenido válido o que el servidor remoto esté efectivamente funcionando, está fuera del contexto de esta columna, nosotros simplemente cuando nos llega la petición tomamos la URL y colocamos un encabezado en nuestra respuesta en la comunicación HTTP. ¿Lindo, no? Puedes usar algunos otros métodos para validar si la URL remota realmente es válida, quizás usando Net::Ping.

Ahora, veamos la subrutina wrong.

 sub wrong {
my ($url) = shift;
print "Content-Type: text/plain", "\n\n";
print "It looks like $url is not a valid URL!";
exit;
}

Tomamos la variable $url con la URL que le pasamos. shift saca el primer elemento de un arreglo, en este caso @_. Y listo, imprimimos un mensaje en pantalla. Hay que colocar una cabecera Content-Type, dejar doble línea y ponemos el mensaje. Luego buscamos la puerta de salida y terminamos.

Hasta ahora es bastante simple y bien programado. Podemos probar la funcionalidad yendo hacia: http://www.damog.net/cgi-bin/redir.cgi?url=http://www.google.com o cualquier otra URL, inténtelo. Incluso podríamos poner una formita web, pues param() puede tomar, como ya lo decía argumentos POST o GET, indistintamente.

Como quiero empezar a usar este método para hacer ligas desde mi sitio a otros y quiero que tenga una mejor apariencia que esa URL larga y fea, hago uso de mod_rewrite y coloco un .htaccess en mi servidor web:

 <IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule ^->(.*)$ /cgi-bin/redir.cgi?url=$1 [L]
</IfModule>

Con dicha regla lo que hago es que cuando reciba una URL con una flechita (`->’), tomaré lo que venga a continuación y lo consideraré una URL, que es lo que le pasaré al redir.cgi. Entonces, puedo llamar http://www.damog.net/->http://www.google.com y hará lo que quiero que haga, la ejecución del CGI con la URL como parámetro, y con la flechita se ve muy intuitivo.

¿Qué tal implementar además, logs o escritura en base de datos, o algo así? Inténtalo, la imaginación es el límite. Me gustaría mucho leer sus comentarios.

Referencias útiles

• http://httpd.apache.org/docs/2.0/howto/cgi.html
• http://www.cherokee-project.com/doc/CGI_executing.html
• http://search.cpan.org/~sonnen/Data-Validate-URI-0.01/lib/Data/Validate/URI.pm
• http://search.cpan.org/~bbb/Net-Ping-2.31/lib/Net/Ping.pm
• http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
• http://httpd.apache.org/docs/2.0/mod/mod_rewrite.html
• http://www.damog.net/gallery/v/edinburgh

Autor

Durante el día, David Moreno Garza (http://www.damog.net/) desarrolla aplicaciones, sistemas y proyectos para una incipiente empresa internacional de telecomunicaciones; adicionalmente es consultor independiente en empresas mexicanas y extranjeras utilizando Perl. Durante la noche intenta salvar al mundo del mal usando expresiones regulares y netiquette.

Licencia de uso

Copyright © 2007 David Moreno Garza.

This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/).

Sobre La Columna.pl

La Columna.pl

es una columna quincenal que escribe el autor alrededor de Perl. Está inspirado en las columnas que Randal L. Schwartz ha escrito desde hace varios años ya. Por medio de recetas, consejos, instructivos y guías, el autor pretende propiciar interés en la gente para que conozca un poco más a fondo este apasionante lenguaje de programación y así fomentar una comunidad más sólida alrededor de él.

Visite http://www.damog.net/columnapl.

La Columna.pl #1 – Mayo 21, 2007.

Recientemente, por algunas de las necesidades que tuvimos en el trabajo, necesitamos manejar de alguna forma fechas y horas desde nuestros scripts y aplicaciones en Perl. Hace no-sé-cuántos años, los franceses propusieron un sistema decimal para manejar el tiempo, pero el método fue impopular entre la comunidad científica. Si hubiera sido así, manejar las fechas y horas en cualquier sistema, hubiera sido tan fácil que no habría tantas implementaciones para trabajar con él, como hoy en día. Pero bueno, el hubiera no existe.

En Perl a veces nos confunde sobre si necesitamos usar localtime, time, gmtime, DateTime.pm, etc. para trabajar con el tiempo. En realidad es mucho más sencillo de lo que parece. Espero que estas minirecetas le sirvan a alguien cuando encuentre este texto buscando por ahí en la red el manejo del tiempo con Perl. Lo haré a manera de FAQ.

¿Cómo obtengo la fecha actual?
La función localtime nos devuelve la fecha actual, pero lo hace en forma de una lista de 9 elementos que podemos obtener de una manera sencilla:

my @fecha = localtime; # La lista tiene el formato (seg, min, hora, día mes, mes, año, día sem, día año, DST).

De esta forma, cada uno de los elementos del arreglo @fecha, será, por orden, el de ese formato, de ahí podrías usar $fecha[0] para obtener el segundo, $fecha[1] para los minutos, y así sucesivamente. Puedes obtener más información en perldoc -f localtime.

¿Y time? ¿Qué es? ¿Cuándo lo utilizo? ¿localtime no se mandaba llamar como localtime(time)?

La función time nos regresa la cantidad de segundos desde el epoch, léase, el 1 de enero de 1970, UTC, como en la mayoría de los sistemas actuales. time realmente lo hace desde cualquier epoch de acuerdo a la arquitectura de la máquina, pero supondremos que ese no es el caso.

damog@cochina:~$ perl -e ‘print time.”\n”;’
1179168385
localtime toma como parámetro una cierta cantidad de segundos. Por default, toma el valor de time. Así que podemos usar tanto localtime como localtime(time) cuando usemos dicha función.

Pero lo que yo quiero es obtener la fecha en el formato que yo quiera.

Tienes dos opciones. Una, es usar el contexto escalar de localtime, es decir, tratar lo que nos regresa localtime como una variable escalar, no como una lista. Ejemplo:

damog@cochina:~$ perl -e ‘$fecha = localtime; print $fecha, “\n”;’
Wed May 16 19:29:55 2007
damog@cochina:~$

Sencillo, ¿no? Lo cual es lo mismo que usar la función scalar, sin tener que asignar forzosamente a una variable escalar:

damog@cochina:~$ perl -e ‘print scalar localtime, “\n”‘
Wed May 16 19:30:55 2007
damog@cochina:~$

Puedes echar un ojo a perllocale si es que la fecha te interesa en otro idioma.

Lo más sencillo, desde mi muy personal punto de vista, y la otra opción, es usar strftime. No hay que temer a usarlo, básicamente utiliza la misma sintaxis que su predecesor, strftime de C. A final de cuentas es bien sencillo (incluso a veces yo echo un rápido vistazo a la página de strftime de PHP que explica cómo usar la función y es la misma implementación). Esta función se encuentra en el módulo estándar POSIX, que podría ser que ya tengas cargado en tu distribución o sistema operativo. Lo que strftime necesita, es el formato en el que necesitas la fecha, y el tiempo en segundos desde el epoch.

Supongamos que queremos la fecha del día de hoy, en el formato AAAA-MM-DD:

damog@cochina:~$ perl -e ‘
> use POSIX qw(strftime);
> print strftime(”%Y-%m-%d”, localtime), “\n”;
> ‘
2007-05-17
damog@cochina:~$

¿Muy simple, no?

Incluso, si queremos hacer un poco de matemáticas con días, lo podemos hacer con strftime, por ejemplo, queremos la fecha de ayer en formato AAAA-MM-DD hh-mm-ss:

damog@cochina:~$ perl -e ‘
> use POSIX qw(strftime);
> print strftime(”%Y-%m-%d %H:%M:%S”, localtime(time – 86400)), “\n”;
> ‘
2007-05-16 10:14:06
damog@cochina:~$
Como que no entendí muy bien eso de los contextos de localtime. ¿Me lo podrías aclarar?

Claro. localtime es manejado por Perl desde dos conceptos para su valor de retorno. Uno es el contexto de escalar y uno en el contexto de lista (como sabes, Perl utiliza estos dos tipos -u otros- de conceptos para el manejo de sus variables). El contexto escalar de localtime es el que nos regresa una fecha formateada (puedes echar un ojo también a la función scalar, si tienes duda al respecto); el contexto de lista de localtime nos regresa un arreglo, donde cada uno de sus elementos, corresponde a un atributo de la fecha, como la documentación de la función nos lo indica y como lo indicaba líneas arriba. Es bien simple.

De hecho, los conceptos de escalar y lista es muy simple. Una variable escalar puede contener cadenas, valores numéricos, referencias, etc. Una variable de lista son arreglos, los cuales, a su vez, contienen elementos escalares, listados en ellos. Como una nota al margen, actualmente las variables escalares de las listas son manejadas de la forma $arreglo[2], por ejemplo, así es como Perl 5 lo maneja. En Perl 6 se utilizarán los elementos de las listas de la forma @arreglo[2], lo cual es mucho más intuitivo y natural, pero mientras Perl 6 no vea la luz oficialmente, esta nota queda sólo como una acotación adicional

Aún se me hace un poco complicado, ¿no hay una forma más fácil?

¡Desde luego! There is more than one way to do it. Hay una cantidad enorme de módulos de fecha y hora disponibles en CPAN, sin embargo, el que ha gozado de gran aceptación por su buena implementación y diseño, es DateTime.

Con DateTime podemos manejar fechas y tiempos en una forma mucho más natural e intuitiva, podemos hacer operaciones matemáticas de una forma mucho más lingüística, que puede terminar ayudando mucho más la naturaleza y la lógica de nuestros programas:

¿Cómo puedo obtener la hora actual con DateTime?

Bien simple:

damog@cochina:~$ perl -e ‘
> use DateTime;
>
> my $hoy = DateTime->now();
> print $hoy, “\n”;
> ‘
2007-05-17T16:26:12
damog@cochina:~$

Sin embargo, hay que ser un poco cuidadosos al usar el método now() pues nos regresa la fecha en UTC. Para eso, podemos crear el objeto $hoy, especificando nuestra zona horaria:

damog@cochina:~$ perl -e ‘
> use DateTime;
> my $hoy = DateTime->now(time_zone => “America/Chicago”);
> print $hoy, “\n”;
> ‘
2007-05-17T11:29:51
damog@cochina:~$

Ese objeto, puede ser utilizado para muchas más cosas. Por ejemplo, a una fecha, sumarle un mes, no es lo mismo que sumarle 28 días, ó 30, ó 31. Mira este ejemplo, donde crearemos un objeto DateTime con una fecha en el pasado y le sumaremos un mes y luego le restaremos dos años:

damog@cochina:~$ perl -e ‘
> use DateTime;
> my $fecha = DateTime->new(
> year => 1984,
> month => 8,
> day => 8,
> hour => 2,
> minute => 0);
> print $fecha->add(months => 1), “\n”;
> print $fecha->add(years => -2), “\n”;
> print “DateTime es la onda!\n”;
> ‘
1984-09-08T02:00:00
1982-09-08T02:00:00
DateTime es la onda!
damog@cochina:~$

Podemos ver que creamos un objecto DateTime llamado $fecha que apunta hacia el 8 de agosto de 1984, 2 de la mañana. A él, le sumamos un mes y luego le restamos dos años. Simple, ¿no crees?

¿Y cómo puedo hacer una diferencia de fechas?

Creo que lo más sencillo para utilizar, es Date::Manip. Observa este ejemplo:

damog@cochina:~$ perl -e ‘
> use Date::Manip;
> my $hoy = ParseDate(”today”);
> my $fecha_nacimiento = ParseDate(”1984-08-08 02:00:00″);
> $delta = DateCalc($fecha_nacimiento, $hoy, \$err, 1);
> print $delta, “\n”;
> ‘
+22:9:1:2:9:55:34
damog@cochina:~$

Básicamente, creamos dos cadenas, $hoy y $fecha_nacimiento y luego las pasamos por &DateCalc, que requiere ambas fechas, una referencia a una variable de error y la variable 1, como modo de operación que nos hará la diferencia entre ambas fechas. Esto nos regresa una cadena parseable para el método &ParseDateDelta, cuyo formato nosotros podemos utilizar y parsear:

my ($anos, $meses, $semanas, $dias, $horas, $minutos, $segundos)

= $delta =~ /^\+(\d+):(\d+):(\d+):(\d+):(\d+):(\d+):(\d+)$/;

Echando rápidamente una mirada a la cadena, podemos saber que en el momento de escribir esta guía, tengo 22 años, 9 meses, 1 semana, 2 días, 9 horas, 55 minutos y 34 segundos de vida.

¿Pero y si quiero convertir una cierta fecha a segundos desde el epoch?

El módulo POSIX también proporciona una función bien sencilla llamada mktime que puede ser usada para precisamente esto.

Como puede verse en la documentación de esta función, la sintaxis es la siguiente:

mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0);

Quiero saber la cantidad de segundos hasta el momento que mis padres me han dicho que nací, 2 am, del 8 de agosto de 1984. El valor mon es contabilizado desde 0, el cual es enero, y así sucesivamente hasta el 11 que es diciembre. De forma similar con wday y yday. El argumento year, empieza desde 1900. Dicho lo anterior, podemos calcular:

damog@cochina:~$ perl -e ‘
> use POSIX qw(mktime);
>
> print mktime(0, 0, 2, 8, 7, 84), “\n”;
> ‘
460800000
damog@cochina:~$

Ahí utilizamos 0 para el segundo, 0 para el minuto, 2 para la hora, 8 para el día del mes, 7 para el mes del año (agosto, recordemos que empiezan desde cero) y 84 para el año desde 1900. Nací en el segundo 460800000 desde el epoch. Pero vamos a ver si eso es cierto, usaremos una combinación de mktime y localtime, en su contexto escalar:

damog@cochina:~$ perl -e ‘
> use POSIX qw (mktime);
>
> print scalar localtime(mktime(0, 0, 2, 8, 7, 84)), “\n”;
> ‘
Wed Aug 8 02:00:00 1984
damog@cochina:~$

Parece que así es Nací en el segundo 460800000. Era miércoles

Como puedes ver, no es la gran cosa procesar fechas y horas en Perl, realmente es sencillo y sólo es cosa de excarvarle un poquito por aquí y por allá y usar cinta adhesiva para obtener lo que queremos de una forma eficiente y útil.

Ojalá te sirva, espero que te hayas divertido aprendiendo un poquito sobre el tiempo en Perl así como yo me divertí escribiendo. Puedes hacerme llegar tus comentarios a <damog@ciencias.unam.mx>.

Información extendida recomendada:

• The Many Dates and Times of Perl
• How to tell the current time in Perl
• Getting a date with Perl
• DateTime Project FAQ

Sobre el autor: Durante el día, David Moreno Garza (damog) desarrolla aplicaciones, sistemas y proyectos para una incipiente empresa internacional de telecomunicaciones; adicionalmente es consultor independiente en empresas mexicanas y extranjeras utilizando Perl. Durante la noche intenta salvar al mundo del mal usando expresiones regulares y netiquette.

Copyright © 2007 David Moreno Garza.This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/).

• La Columna.pl #2
  • Pequeñas herramientas para grandes necesidades
    • Referencias útiles
  • Autor
  • Licencia de uso
• Sobre La Columna.pl

La Columna.pl #2

Pequeñas herramientas para grandes necesidades

Se han pasado muy rápidamente estos últimos 15 días. Entre algunas pláticas, trabajo y otras cosas, pareciera que el tiempo simplemente se esfuma tan, tan rápidamente.

Como sea, ya estamos en la segunda entrega de La Columna.pl. En esta quincena quiero tocar un tema bien interesante que son esas pequeñas herramientas que nos pueden llenar de una manera muy especial alguna de nuestras necesidades. ¿Hay algo por ahí que quieras automatizar pero no te decides? Inténtalo.

El ejemplo que voy a poner aquí es acerca de una pequeña utilidad que hice para revisar el estado de la batería de mi laptop. Como es bien sabido por algunos de ustedes, amables lectores, utilizo una máquina PowerBook G4, sobre Debian GNU/Linux: En esta máquina hago la mayoría de mi trabajo, que se basa principalmente en desarrollo de software y algo de administración de sistemas. La mayoría de mi trabajo lo hago en esta máquina que es casi tan estable como una piedra. En fin, las computadoras Apple, como ésta, utilizan un microcontrolador que gestiona las funcionalidades de energía, tales como el control de suspensión, el nivel de batería y otras similares, llamado PMU. Lamentablemente las aplicaciones actualmente existentes que monitorean los atributos de PMU, en Linux sobre estas computadoras no me satisfacen del todo: Algunas son unas aplicaciones en GTK verdaderamente estorbosas; otras están integradas al panel de control de GNOME o KDE, del cual no utilizo ninguno. Opté por utilizar el control de batería de GKrellM, que es algo modesto, pero que de todas formas a veces no quería tener siempre en mi escritorio – que para empezar, no es que tenga un escritorio como tal, pues de un escritorio sólo utilizo algunos escritorios virtuales y algo de soporte de systray. Finalmente no estaba muy seguro de lo que necesitaba. Lo único seguro era mi inseguridad en el caso

¡Una pequeña aplicación en Perl! Claro, desde un emulador de terminal podría llamar esta aplicación y me diría qué porcentaje tengo de batería restante en mi máquina, sería lo más simple, sencillo y a mi gusto, sería perfecto. Pues vamos a poner las manos a la obra.

En mi máquina, la información de la batería se encuentra en /proc/pmu/battery_0, que luce así:

 flags      : 00000011 charge     : 3535

max_charge : 3537

current    : 0

voltage    : 12495

time rem.  : 0

El archivo indica diferentes valores para amperaje y voltaje. Los que me interesan son los valores de charge y max_charge que indican miliampers/hora de la carga actual que tiene la pila y la máxima.

Lo que hay que hacer es bastante simple. Obtener el valor de charge, el de max_charge y obtener un porcentaje del primero con respecto al segundo. En esta columna tocaré algunos temas básicos pero que pueden ser de utilidad para entender algunos conceptos más adelante en otras columnas.

 #!/usr/bin/perl use warnings;

use strict;

Mando llamar al intérprete de Perl que en la mayoría de las distribuciones con binarios precompilados irá a dar a /usr/bin/perl e inmediatamente mando llamar dos pragmas de Perl: El primero, warnings, para controlar advertencias y el segundo, strict, para restringir construcciones inseguras. Es bueno siempre llamar ambos pragmas para educarnos un poco al programar. Un pragma es únicamente un indicador para el momento de la compilación, podremos estudiar un poco los pragmas en futuras columnas.

 my $pmufile = '/proc/pmu/battery_0';

Declaro la variable $pmufile que indicará la ruta absoluta del archivo que mencionaba anteriormente.

 my $filecont; {

local $/ = undef;

open(PMU, $pmufile) or die $!;

$filecont = <PMU>;

}

Aunque el uso de local ya no se aconseja mucho, es bueno a veces para utilizarlo en bloques específicos donde sólo tengamos que modificar, quizás, una variable especial, como en este caso, la variable especial $/. Esta variable nos sirve para definir el input record separator, que por default, es una línea nueva. Modificarlo nos permite hacer cosas interesantes, sobre todo cuando efectuamos un ciclo while() hacia un filehandle. En este caso, indefinimos su valor, por lo cual, luego de abrir el archivo $filename a lectura, vaciamos todo el contenido del archivo en una sola variable, $filecont, que habíamos declarado antes del bloque. En alguna columna futura tengo pensado tratar a fondo las variables especiales, que son algo muy interesante dentro de Perl.

 my($charge) = $filecont =~ /charges+:s(d+)/; my($max_charge) = $filecont =~ /max_charges+:s(d+)/;

Aquí creamos las variables $charge y $max_charge y les asignamos el valor que nos arroja nuestra expresión regular como la variable especial $1, en ambas líneas.

 my $porc = int (($charge/$max_charge) * 100);

Dividimos $charge entre $max_charge y multiplicamos el resultado por cien, para obtener el porcentaje. Sin embargo, este resultado nos arrojaría más de diez decimales, después del punto. Por ello, utilizamos la función de Perl, int, que nos regresa el valor entero de su parámetro (mi incipiente naturaleza matemática me hace hacer notar que un número entero no es necesariamente un número natural ).

 print "t", "Restante: $porc %", "n";

print

en realidad requiere una lista como argumento, lo que generalmente hacemos en enviarle un sólo parámetro (por ejemplo, print "Hola mundo";), sin embargo, para una notación mucho más intuitiva, ponemos el salto de línea y el tabulador como primer y tercer parámetro, una lista, precisamente.

¡Y listo! Le agrego un bit de ejecución al script, lo renombro a pila, lo pongo en /usr/local/bin o algo similar y puedo correrlo fácilmente:

 damog@cochina:~$ pila         Restante: 86 %

damog@cochina:~$

Ya luego podría usar ese comando para hacer otras cosas: parsear el valor y podría enviarme un correo avisándome que ya se me va a acabar la pila, o mandar un mensaje al systray o quizás conectarme al IRC y avisarle a mi nick al respecto; hay muchas cosas más que Perl nos facilita hacer, ¡tu imaginación es el límite!

De otras muchas formas habríamos podido abrir el archivo y leer el contenido de charge y max_charge. ¿Tú de qué forma lo hubieras hecho? ¿Quizás ciclar el filehandle hasta toparse con /^max_charge/? ¿Quizás usar alguna combinación con ejecución externa de cat o de grep?

Te invito a que me envíes tus comentarios. Nos leemos dentro de quince días.

Referencias útiles

• http://perldoc.perl.org/index-pragmas.html
• http://perldoc.perl.org/perlvar.html
• http://perldoc.perl.org/functions/int.html
• http://perldoc.perl.org/perlop.html#Integer-Arithmetic-integer

Autor

Durante el día, David Moreno Garza (http://www.damog.net/) desarrolla aplicaciones, sistemas y proyectos para una incipiente empresa internacional de telecomunicaciones; adicionalmente es consultor independiente en empresas mexicanas y extranjeras utilizando Perl. Durante la noche intenta salvar al mundo del mal usando expresiones regulares y netiquette.

Licencia de uso

Copyright © 2007 David Moreno Garza.

This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/).

Sobre La Columna.pl

La Columna.pl

es una columna quincenal que escribe el autor alrededor de Perl. Está inspirado en las columnas que Randal L. Schwartz ha escrito desde hace varios años ya. Por medio de recetas, consejos, instructivos y guías, el autor pretende propiciar interés en la gente para que conozca un poco más a fondo este apasionante lenguaje de programación y así fomentar una comunidad más sólida alrededor de él.

Visite http://www.damog.net/columnapl.

• La Columna.pl #1. 26 de mayo de 2007. Manejo del tiempo con Perl.
• La Columna.pl #2. 7 de junio de 2007. Pequeñas herramientas para grandes necesidades.
• La Columna.pl #3. 9 de julio de 2007. Redirecciones.
• La Columna.pl #4. 5 de septiembre de 2007. Automatización en web con WWW::Mechanize.

La Columna.pl de esta semana trata, como su título bien lo apunta, sobre el manejo del tiempo con Perl. El tiempo es algo que no siempre es lo suficientemente intuitivo para trabajar, su propia naturaleza lo hace complejo. Sumar una fecha con otra no es tan sencillo como puede parecer: Hay que tomar en cuenta muchas cosas, los meses con 30 ó 31 días, por ejemplo, los años bisiestos, incluso si hay un cambio de zonas horarias, pueden ser calculadas con el pasar de los años. El tiempo es a veces algo confuso cuando se maneja con Perl, pero es sólo por apariencia, en realidad es de lo más sencillo y divertido. Los invito a que estén al pendiente de La Columna.pl, cada quince días, pues pongo esfuerzo, dedicación y amor en este trabajo, para obtener un producto de calidad que le guste y le sirva a la gente.

Naturalmente, le agradezco a mi reina su apoyo en este proyecto, pues ella fue mi inspiración inicial; y asimismo, le agradezco a Marco Antonio Manzo por sus siempre puntuales observaciones y apoyo para la difusión de Perl. Y desde luego, a merlyn, por servir como modelo a seguir.

http://www.damog.net/columnapl