Blog ElCodiguero

Slackware 13.37: Instalación y configuración básica

Alvaro Martínez — Tue, 27 Sep 2011 23:44:14 -0300

Slackware es la distribución de GNU/Linux más antigua entre las que siguen desarrollándose. Se caracteriza por su fama de complicada, sin embargo una vez que el sistema está configurado el mantenimiento necesario es mínimo, y resulta tan sencilla de manejar como cualquier otra distribución. Lo único que el sistema pide a cambio de su estabilidad y facilidad de mantenimiento es algo de tiempo leyendo manuales y ayudas para comprender lo que sucede y por qué. La instalación, configuración y uso de este sistema es probablemente la mejor forma de aprender a manejar un sistema Unix.

Este artículo es una actualización del anterior sobre Slackware 13.1, con cosas nuevas para 13.37.

Instalación

La instalación en sí no es un problema, recomiendo esta guía de instalación para aquellos que no hayan realizado este proceso antes. La guía es para la distribución ZenWalk, pero el proceso es casi el mismo ya que ZenWalk es una de las tantas distribuciones derivadas de Slackware.

Para iniciar el proceso, arranca con el DVD de Slackware y sigue las instrucciones en pantalla. Una vez iniciada la consola de root, ejecuta el programa setup. Una vez aquí, debe iniciarse la instalación eligiendo la opción ADDSWAP en el menú, o TARGET. Estos pasos deben hacerse primero ya que son los que preparan el disco en el que se instalará, si no se hacen primero siempre se llega a un punto en la instalación en el que se debe iniciar todo el proceso de nuevo.

Y esto siempre requiere salir del programa de instalación y abrirlo de nuevo, ya que la autodetección del disco CD/DVD de instalación funciona solamente la primera vez que se hace.

De todas formas, la instalación con las opciones por defecto (full install, instalar todos los paquetes disponibles) puede iniciarse en menos de 5 minutos y terminarse en más o menos media hora.

Al terminar la copia de archivos se hacen algunos pasos para la configuración inicial del sistema, principalmente lo que respecta a la ubicación geográfica, la configuración de red y la instalación del gestor de arranque (LILO). Una vez finalizados estos pasos, el programa de instalación se cierra y se nos indica que debemos reiniciar el sistema.

Configuración inicial

Al arrancar el sistema, a diferencia de lo que sucede con otras distribuciones, el entorno gráfico no se inicia por defecto. Se nos presenta una pantalla de inicio de sesión en modo texto, en la que deberemos entrar como el usuario root y con la contraseña correspondiente (que habremos indicado en uno de los últimos pasos de la instalación).

Una vez dentro, hay varias tareas a realizar.

Arrancar por defecto el entorno gráfico

Esto se hace editando el archivo /etc/inittab y cambiando el nivel de ejecución predeterminado. Lo haremos con vim

root@alvaro:/# vim /etc/inittab

Una vez que se abra el archivo, hay que ir a la línea que contiene

# Default runlevel. (Do not set to 0 or 6)
id:3:initdefault:

vim no se parece en nada a los editores normales, por lo que para quien lo usa por primera vez puede resultar bastante extraño. La forma más sencilla de editar lo necesario y salir es llevar el cursor hacia el 3 en la línea mencionada antes, y presionar la siguiente secuencia de teclas:

r : Pondrá el editor en el modo adecuado para reemplazar un caracter
4 : escribirá un 4, reemplazando al 3
:wq : este comando guarda el archivo y sale de vim

Con esto, se indica que el nivel de ejecución por defecto debe ser el nivel 4. Normalmente cualquier documentación de GNU/Linux que se encuentre indica que el nivel 4 no se utiliza, y además casi todas las demás distribuciones utilizan el nivel 5 para el modo gráfico. En esto Slackware es diferente, en tanto que utiliza el nivel 4 para el modo gráfico y no utiliza el nivel 5.

Crear un usuario sin privilegios

La forma usual de utilizar el sistema es como usuario sin privilegios. Esto es, sin permiso para instalar programas o modificar el sistema, únicamente se tiene permiso para hacer modificaciones en la carpeta asignada al usuario. Este modo es ideal por la seguridad y para evitar errores fatales, que casi todos hemos cometido alguna vez. Añadiremos un usuario, entonces, con el comando adduser y escribiendo la información que el comando solicita.

Para que este usuario sea usable, es necesario añadirlo a varios grupos: audio (para que pueda utilizar la tarjeta de sonido), cdrom, disk, plugdev (para que pueda utilizar dispositivos extraíbles), y video. Esto se puede hacer facilmente; en uno de los pasos adduser muestra la siguiente línea:

Additional groups (comma separated) []:

Si se presiona la flecha hacia arriba, se obtiene una lista de los grupos necesarios.

Utilizar el kernel generic en lugar de huge

Para la instalación, y por defecto en la instalación completa, Slackware instala un núcleo Linux que tiene compilado casi todos los controladores disponibles. Esto implica que el núcleo por defecto es bastante grande e ineficiente, aunque en una instalación funciona bien. Para el uso diario es mejor cambiar a un núcleo que incluya solamente lo mínimo, y en el que los controladores estén incluidos en forma de módulos (de tal forma que solamente se cargarán aquellos que sean necesarios). Este cambio requiere de varias modificaciones, que quizás sea mejor hacer desde el entorno gráfico (se requiere edición de archivos, y es más fácil usar kwrite que vim.) Por lo que reiniciar en este momento e iniciar sesión como root en el entorno gráfico puede ser la mejor idea.

Vincular al kernel correcto

Desde la consola, el siguiente comando

cd /boot ; ls -l

Debería mostrar algo como esto (eliminé algunas líneas innecesarias):

lrwxrwxrwx  1 root root      35 2008-12-18 00:49 System.map -> System.map-huge-smp-2.6.37.6-smp
-rw-r--r--  1 root root  965704 2008-11-21 02:20 System.map-generic-smp-2.6.37.6-smp
lrwxrwxrwx  1 root root      32 2008-12-18 00:49 vmlinuz -> vmlinuz-huge-smp-2.6.37.6-smp
-rw-r--r--  1 root root 2347888 2008-11-21 02:20 vmlinuz-generic-smp-2.6.37.6-smp

Los archivos System.map y vmlinuz son enlaces que apuntan a las versiones huge del núcleo (esto puede verse indicado por las flechas -> junto al nombre del archivo). Debemos vincularlas a las versiones generic. Para esto, se utilizan los siguientes comandos:

rm System.map vmlinuz
ln -s vmlinuz-generic-smp-2.6.37.6-smp vmlinuz
ln -s System.map-generic-smp-2.6.37.6-smp System.map

Obviamente conviene hacer uso del autocompletado en bash, para no tener que recordar todo el nombre del archivo (presionar tecla tabulador).

El siguiente paso es crear el archivo initrd correspondiente. Dado que el núcleo genérico no tiene los controladores en el núcleo mismo sino como módulos, es necesario brindarle algunos controladores iniciales para que pueda encontrar el disco duro, leerlo, y cargar el resto de los módulos que necesita. Estos controladores iniciales se guardan en el archivo initrd. Las instrucciones necesarias para crear este archivo están en el archivo README.initrd dentro de la carpeta /boot. Básicamente, para un sistema cuya partición principal es de tipo ext3, y está en /dev/sda1 (la primera partición primaria del primer disco SATA), el comando necesario es

mkinitrd -c -k 2.6.27.7-smp -m mbcache:jbd:ext3 -f ext3 -r /dev/sda1

(dentro de la carpeta /boot)

El último paso ahora es configurar LILO para que cargue este archivo initrd. Habrá que editar el archivo /etc/lilo.conf, buscar la sección correspondiente y agregar una línea al bloque

# Linux bootable partition config begins
image = /boot/vmlinuz
root = /dev/sda1
label = Linux
read-only
# Linux bootable partition config ends

que deberá quedar como

# Linux bootable partition config begins
initrd = /boot/initrd.gz
image = /boot/vmlinuz
root = /dev/sda1
label = Linux
read-only
# Linux bootable partition config ends

Ya que estamos editando el archivo lilo.conf, conviene también editar el tiempo que se espera antes de arrancar el sistema, en la pantalla de selección de SO. Por defecto este tiempo es 2 minutos, recomiendo cambiarlo a un tiempo que sea corto pero permita interrumpir el proceso en caso de ser necesario (por ejemplo, medio segundo). Habrá que ir hacia el principio del archivo lilo.conf y cambiar:

# This is given in tenths of a second, so 600 for every minute:
timeout = 1200

por

# This is given in tenths of a second, so 600 for every minute:
timeout = 50

Una vez realizados estos cambios, hay que re-instalar LILO. Este proceso es simplemente ejecutar el comando lilo en la terminal. Recomiendo ejecutar primero lilo -t (hacer una simulación de la instalación) y luego, si no hay errores (puede haber advertencias), ejecutar lilo.

Ahora, reiniciar el sistema nuevamente para cargar el núcleo genérico.

Configurar el idioma predeterminado del teclado

El idioma del teclado puede configurarse por separado desde los escritorios (KDE o XFCE), pero también puede configurarse para el sistema entero. Por un lado, la terminal de texto tendrá el idioma configurado durante la instalación, con lo cual no se requieren más cambios. Pero el servidor X estará por defecto con teclado inglés a menos que lo configuremos para que utilice otro.

Esta configuración se debe hacer en un archivo xorg.conf (dentro de /etc/X11). Se debe agregar lo siguiente:

Section "InputClass"
     Identifier     "keyboard-all"
     Driver         "evdev"
     Option         "XkbLayout" "es"
     MatchIsKeyboard "on"
EndSection

No importa si el archivo no contiene nada más (de hecho probablamente haya que crearlo, ya que inicialmente no es requerido), ya que hoy en día casi todo es automáticamente detectado por el servidor X. Una vez agregado esto, el servidor X debería iniciar con el teclado en español.

Configuración de una computadora portátil

Si tienes una computadora de escritorio, no se requieren más detalles de configuración, todo debería haber sido reconocido y autoconfigurado. El resto será cuestión de configurar los detalles del entorno gráfico. Pero si como yo tienes una computadora portátil, habrá otros detalles a configurar.

Red inalámbrica

Es muy probable que el dispositivo de red inalámbrica no tenga controladores para Linux. En este caso habrá que apelar a ndiswrapper, un programa que es capaz de utilizar los controladores de Windows que estos dispositivos incluyen. ndiswrapper no está incluido en la distribución de Slackware, pero puede conseguirse sin dificultad en SlackBuilds.org. También se pueden encontrar allí otros controladores nativos para Linux, por ejemplo el controlador para las tarjetas Broadcom.

Vale la pena notar, sin embargo, que ndiswrapper no puede funcionar correctamente en un sistema de 64bit, no es capaz de cargar un controlador de 32bit de Windows en un sistema de 64bit. Así que, aún si tu equipo lo admite, asegúrate de tener los controladores necesarios antes de instalar Slackware64.

Para el control de la red inalámbrica Slackware incluye el programa wicd en la carpeta /extra. Bastará entonces con instalar el paquete desde esa carpeta. Algo importante a recordar es que, para que wicd funcione correctamente, es necesario darle permisos de ejecución al archivo /etc/rc.d/rc.wicd, y remover la configuración que se encuentra en el archivo /etc/rc.d/rc.inet1.conf. Para lograr esto simplemente se agrega una almohadilla # a toda línea de este archivo que no comience con una.

Si todo va bien entonces, al reiniciar habrá un ícono de wicd al lado del reloj, pronto para conectarse a alguna de las redes detectadas.

En mi computadora el controlador necesario es de Ralink (rt5390sta). Si bien la empresa ha proveído un controlador abierto, en mi caso no funcionó bien hasta que lo instalé desde el paquete de openSuSE (usando rpm2tgz, y compilando con las instrucciones del archivo .spec)

Synaptics, el controlador para el touchpad

El controlador synaptics viene incluido en Slackware, y el nuevo X.Org incluido en Slackware 13.37 lo carga correctamente sin que haya que configurar nada. Pero por defecto desactiva funciones como el hacer clic tocando la superficie del touchpad. Para corregir este comportamiento, se pueden seguir varios caminos. Uno es editar el archivo xorg.conf, como se ha hecho toda la vida. El otro es configurar el touchpad desde el panel de control de KDE (Preferencias del Sistema). Recomiendo usar esta última.

Configuración de ahorro de energía

Desde KDE4 se pueden configurar sin problemas casi todos los aspectos de ahorro de energía, excepto por un detalle: qué se hace cuando se presiona el botón de encendido/apagado (nota: esto era cierto en versiones anteriores, aún no probé el último KDE en Slackware 13.37).

En esta página se explica cómo se debe configurar esto, el artículo es viejo y la mayor parte de lo que se explica ya no es necesario. Los pasos para que al presionar el botón la computadora hiberne en vez de apagarse son los siguientes:

Cambiar a la carpeta /etc/acpi
Dejar en esta carpeta únicamente el archivo acpi_handler.sh y crear las carpetas events and actions en caso de ser necesario.
Crear un archivo /etc/acpi/actions/pwrbtn.sh con permisos de ejecución, y con el siguiente contenido:
```
#!/bin/sh
pm-hibernate
```
Crear un archivo /etc/acpi/events/pwrbtn con el siguiente contenido:
```
event=button[ /]power
action=/etc/acpi/actions/pwrbtn.sh
```

Listo, al presionar el botón de encendido la computadora hibernará en vez de apagarse. ¿Pero cómo restaurar? Lo que hace la hibernación es mover el contenido de la memoria RAM y de algunas otras cosillas a la partición swap. Para poder restaurar el sistema es necesario indicarle al núcleo la partición de swap. Hay que editar el archivo lilo.conf de nuevo, buscar la sección de Linux y añadirle la siguiente línea:

append = "resume=/dev/sda2"

(donde /dev/sda2 es la partición de swap). Para finalizar, hay que volver a ejecutar el comando lilo (como antes, primero lilo -t para asegurarse de que todo es correcto, luego lilo para hacer la instalación). Con esto, si la máquina fue hibernada, el núcleo restaurará el estado. En caso de que la máquina haya sido apagada, se hará un arranque normal. En mi caso tengo configuradas dos secciones idénticas, una con el resume y otra sin él, simplemente para hacer pruebas de vez en cuando.

Pasos siguientes

Instalación de programas

Slackware no tiene repositorios de paquetes, todos los paquetes oficiales están en el DVD de instalación. Para instalar programas externos se recomienda utilizar SlackBuilds, que son scripts que automatizan la generación de paquetes a partir de archivos de código fuente. El repositorio más grande de SlackBuilds es slackbuilds.org, y la forma más sencilla de utilizar ese repositorio es a través de una herramienta llamada sbopkg. La mayor parte de los programas tienen su SlackBuild, pero no todos. Para estos últimos lo mejor es descargar el código fuente y crear un paquete con src2pkg. En la mayoría de los casos la compilación será exitosa. Si no lo es, no queda otra opción más que pedir ayuda en algún foro para intentar resolver el problema.

Existen también repositorios extraoficiales de paquetes binarios, siendo los más grandes LinuxPackages y Slacky.

GNOME

Por defecto Slackware no incluye el escritorio GNOME. Hay varias formas de incluirlo, la mejor hoy en día es GNOME SlackBuild. Incluye no solamente el escritorio sino también programas relacionados con él, como Rythmbox, Brasero, Mono y muchos más. Vale la pena tener disponibles los repositorios para incluir también programas que no son de GNOME pero Slackware no incluye y GSB sí, como OpenOffice.

Paquetes casi oficiales

Algunos miembros del equipo de Slackware proveen paquetes adicionales, no oficiales. El repositorio de rworkman contiene paquetes extra para XFCE (y otros), mientras que el repositorio de AlienBob contiene paquetes como VLC, las últimas versiones de KDE, y lo necesario para convertir a Slackware64 en un SO capaz de ejecutar programas de 32 bit.

Algunos enlaces interesantes:

SlackwareCL: comunidad de usuarios de Slackware de Chile, tienen una guía que puede resultar interesante.
Slacky: comunidad de usuarios de Italia.

Se supone que esta es solamente una guía básica para tener el sistema más o menos funcionando. Si algo no termina de quedar bien, recomiendo el excelente foro de Slackware en LinuxQuestions, o el no tan grande pero igualmente útil foro de Sistemas Unix en Foros del Web

Copiar y pegar con el ratón en CMD

Alvaro Martínez — Sun, 17 Apr 2011 16:14:26 -0300

Copiar y pegar en la interfaz de línea de comandos de Windows es un proceso algo engorroso. Con la configuración predeterminada, hay que:

Hacer un clic con el botón secundario y seleccionar “Marcar”
Seleccionar el texto haciendo clic y moviendo el puntero hacia la posición deseada
Presionar el botón derecho para copiar la selección en el portapapeles
Seleccionar “Pegar” en el menú contextual

Es bastante molesto, al menos bastante más molesto que el proceso normal de copiar y pegar en otro programa de Windows. Pero no tiene por qué ser así, Windows ofrece una configuración que resultará familiar a quienes sean usuarios de PuTTY.

Primero hay que ir a una ventana cualquiera de CMD, por ejemplo vía Inicio, Ejecutar, cmd. Luego hay que hacer clic en el ícono de la barra de título (a la izquierda) o bien presionar Alt+Espacio. En el menú que aparece, seleccionar Predeterminados.

Aparece la ventana Propiedades de Consola de Windows, como en la imagen siguiente.

Basta seleccionar Modalidad de edición rápida en el cuadro Opciones de edición, aceptar y salir. Este cambio habilita selección de texto normal en la consola (arrastrar el ratón sobre el texto), copia con el botón derecho, y pegado con el botón derecho. Mucho más rápido y práctico que antes.

La ventana Propiedades de Consola de Windows también permite cambiar la tipografía (fuente) de la consola y su tamaño, algo interesante para todos aquellos a quienes alguna vez nos molestó que la consola no se pueda agrandar a lo ancho.

Eliminar objetos repetidos de una lista

Alvaro Martínez — Sun, 30 Jan 2011 16:27:18 -0200

En Python las listas y tuplas permiten elementos duplicados. Cuando se quiere manejar elementos únicos, se recurre normalmente a conjuntos (set), o a diccionarios (donde lo que debe ser único es cada clave, no hay restricciones en el contenido).

Pero si se recibe una lista con duplicados y queremos eliminarlos, ¿cuál es la forma más sencilla?

Con un bucle for

Si no se conoce de antemano un método, uno podría pensar en resolver el problema recorriendo la lista, y construyendo una segunda lista solamente con los elementos que no pertenezcan ya a ella, algo así:

1 lista_nueva = []
2 for i in lista_original:
3     if i not in lista_nueva:
4         lista_nueva.append[i]

Si bien esta solución es simple, vale notar que es O(n^2) peor caso (cuando no hay duplicados), ya que por cada elemento de la lista original se debe recorrer potencialmente toda la lista nueva. Como ventaja se puede mencionar que preserva el orden de la lista original.

Pero vamos, ¡esto es Python! ¡Debe haber un método mejor! :-)

Con un diccionario

Aprovechando que los diccionarios no pueden contener claves duplicadas, se puede crear un diccionario tal que cada una de sus claves es un elemento de la lista. Luego, con el método keys se obtiene una lista de las claves.

dict.fromkeys(lista_original).keys()

Este método es O(n), pero tiene la desventaja de que no preserva el orden de los elementos de la lista original.

Usando conjuntos

Este método es muy similar al anterior, de hecho tiene tiene la misma ventaja (es O(n)) y la misma desventaja (no preserva el orden de la lista original). Se trata de crear un conjunto a partir de la lista, y luego (en caso de requerirlo) volver a convertir el conjunto a una lista. Los conjuntos no pueden contener elementos repetidos, por lo que se eliminan los duplicados.

list(set(lista_original))

Usando comprensión de listas

Este es un ejemplo útil y eficiente aunque complejo, que encontré en bytes.com. La idea es utilizar las propiedades de los diccionarios para eliminar los elementos duplicados.

[ d.setdefault(x,x) for x in lista_original if x not in d ]

Para cada elemento de la lista original, si el elemento no es una clave del diccionario (x not in d) se agrega al diccionario via setdefault. Este método tiene la particularidad de que si la clave no existe, la agrega (por lo que no se la volverá a agregar gracias al x not in d) y devuelve el valor que se le pasó como segundo parámetro, generando efectivamente una lista de elementos únicos y preservando el orden original.

Como los diccionarios (también los conjuntos) son O(1) caso promedio para la búsqueda de elementos (por estar implementados como tablas hash), el costo de este método es O(n), por el recorrido de los elementos de la lista.

En general preferiría usar conjuntos, ya que es la forma más sencilla. Pero si hay que preservar el orden de la lista original, sin duda este es un buen método, y no es tan complejo como parece a primera vista.

Enlaces relacionados

Comentar bloque de código con ViM

Alvaro Martínez — Thu, 20 Jan 2011 21:21:16 -0200

ViM es uno de los editores más conocidos en el mundo UNIX, y sin duda alguna es uno de los más completos y potentes una vez que se lo conoce bien. Es posible usarlo durante años y seguir aprendiendo formas en las que nos ahorra trabajo.

Cómo comentar un bloque de código

Me refiero a, en general, agregar un caracter cualquiera al principio de varias líneas, sin tener que editar línea por línea. Para esto, hay que posarse en la primera columna de la línea, cambiar a modo comando (con Esc) y presionar Ctrl+V para ingresar en el modo Bloque visual, que se indicará en la parte inferior de la pantalla como — VISUAL BLOCK — o — BLOQUE VISUAL —.

Una vez en este modo, nos desplazamos hacia abajo (o hacia arriba) con las flechas del teclado, cubriendo todas las líneas que queramos comentar.

El tercer paso es presionar I (i mayúscula) y escribir el texto que deba ir al principio de la línea (por ejemplo, # o //). Esto agregará el texto a la línea en la que se ubique el cursor.

Al presionar la tecla Esc se modificarán todas las líneas marcadas. Dependiendo de la versión de ViM, puede ser necesario esperar unos segundos o mover el cursor para ver el cambio.

Para borrar los caracteres (descomentar) se sigue un proceso similar, pero en vez de escribir, una vez seleccionadas las líneas hay que apretar d para borrar el o los caracteres que se quieran quitar de cada línea.

Sitios web con Python, virtualenv y fastcgi

Alvaro Martínez — Thu, 30 Dec 2010 19:49:44 -0200

A la hora de crear un sitio web con Python, la opción más sencilla es usar un framework y algunas de las muchas aplicaciones y bibliotecas ya disponibles. Pero ¿qué sucede si usamos una biblioteca que no está disponible en la cuenta de alojamiento que contratamos?

virtualenv

La respuesta a esta pregunta es virtualenv. Se trata de un paquete que permite instalar otros paquetes y bibliotecas en un directorio cualquiera, sin depender de la carpeta global de Python o heredando los paquetes instalados en ella.

En mi cuenta de Valcato tuve que utilizar virtualenv para instalar django-cms y el blog Zinnia, ya que no estaban entre los paquetes disponibles.

En mi caso, virtualenv no estaba instalado en la carpeta global, pero esto no es un problema: basta con descargar el archivo .zip y descomprimirlo en una carpeta cualquiera del servidor. Luego simplemente ejecutando python virtualenv.py funciona perfectamente.

Crear el entorno virtual

Para crear el entorno virtual, debemos conectarnos a la cuenta de alojamiento vía SSH, usando PuTTY o un programa similar. Esto es necesario porque se requiere ejecutar comandos. Una vez conectados y en la línea de comandos del servidor, basta con ejecutar el comando virtualenv con un parámetro que indica el nombre de la carpeta en la que se copiarán los archivos necesarios:

# virtualenv mi_entorno_virtual

Para evitar problemas, conviene tener dos puntos en consideración:

El entorno virtual no puede ser cambiado de directorio, por lo que hay que crearlo en la carpeta desde donde vaya a funcionar siempre.
Existe una opción —no-site-packages que desvincula completamente al entorno virtual de la carpeta global. Ideal si queremos evitar cualquier clase de conflicto.

Activar el entorno

Luego de crearlo, y antes de poder utilizarlo, hay que activar el entorno virtual recién creado. Esto hace que las siguientes llamadas a python o a programas hechos en python encuentren las carpetas del entorno virtual y sea posible instalar paquetes allí. La activación requiere otro comando simple:

# . mi_entorno_virtual/bin/activate

Es importante ejecutar el comando anterior tal cual se muestra, incluyendo el punto inicial (el # es simplemente una forma genérica de representar el indicador de la línea de comandos o prompt). Obviamente cambia el nombre de la carpeta donde el entorno virtual fue creado. Lo importante es que luego de esto, las llamadas a python ejecutarán mi_entorno_virtual/bin/python, y mi_entorno_virtual/lib/python/site-packages estará en sys.path (de forma simple: lo que esté en mi_entorno_virtual tendrá precedencia sobre lo que esté en la carpeta global de Python en el sistema)

Instalando programas y bibliotecas

Una vez activado el entorno virtual, se dispone de los comandos pip y easy_install para instalar paquetes de python en él, sin afectar lo que esté instalado en el directorio global. En mi caso necesitaba instalar django-blog-zinnia, así que simplemente usé la siguiente orden:

# pip install django-blog-zinnia

pip no solamente instala el paquete indicado sino que instala también sus dependencias, por lo que una vez finalizada su tarea ya queda todo listo para usar.

Modificando la configuración de FastCGI

Para poder usar el entorno virtual desde la línea de comandos, se requiere ejecutar el programa bin/activate, pero FastCGI no tiene una línea de comandos. Entonces ¿cómo indicarle que utilice los paquetes allí instalados? La respuesta está en la biblioteca estándar de Python, y es el módulo site.

site.addsitedir

El método addsitedir del módulo site sirve para lo que necesitamos: agregar una nueva carpeta al entorno de ejecución de Python para que sea considerada como otra site-packages.

Si ya estás usando Django con FastCGI, seguramente tengas un archivo con extensión .fcgi y con contenido similar a lo siguiente:

1 #!/usr/bin/env python2.6
2 import sys, os
3 
4 sys.path.insert(1, "/ruta/a/tu/proyecto/django")
5 os.environ['DJANGO_SETTINGS_MODULE'] = "proyecto.settings"
6 
7 from django.core.servers.fastcgi import runfastcgi
8 runfastcgi(method="threaded", daemonize="false")

Entonces, para que FastCGI encuentre y use los paquetes instalados en el entorno virtual, se importa el módulo y se invoca a addsitedir antes de hacer el sys.path.insert:

import site
site.addsitedir('/ruta/al/entorno/virtual/lib/python2.6/site-packages')

Conflictos con el site-packages global

Si no hay conflictos de paquetes entre el directorio global y el entorno virtual, lo anterior es suficiente para que todo funcione correctamente. Sin embargo, en caso de conflictos pueden surgir problemas. Esto es porque addsitedir agrega los directorios del entorno virtual después de los directorios globales en sys.path, y sin un orden predefinido. Si tu archivo .fcgi utiliza addsitedir y un día de repente algo no funciona, o funciona mal, podría ser producto de un conflicto de versiones del mismo paquete entre el entorno virtual y el entorno global del servidor.

El problema está más detallado en el sitio de mod_wsgi. La solución es básicamente reordenar sys.path para que los directorios agregados por addsitedir aparezcan primero. El resultado final en el archivo de FastCGI es algo como esto:

 1 #!/usr/bin/env python2.6
 2 import sys, os, site
 3 
 4 # Remember original sys.path.
 5 prev_sys_path = sys.path[:]
 6 
 7 # Add each new site-packages directory.
 8 site.addsitedir('/ruta_al_entorno_virtual/elcodiguero-env/lib/python2.6/site-packages')
 9 
10 # Reorder sys.path so new directories at the front.
11 new_sys_path = []
12 for item in sys.path:
13     if item not in prev_sys_path:
14         new_sys_path.append(item)
15         sys.path.remove(item)
16 sys.path[:0] = new_sys_path
17 
18 sys.path.insert(1, "/ruta_al/proyecto_django/")
19 os.environ['DJANGO_SETTINGS_MODULE'] = "proyecto.settings"
20 
21 from django.core.servers.fastcgi import runfastcgi
22 runfastcgi(method="threaded", daemonize="false")

Una vez cumplidos estos pasos, nuestro sitio Django tendrá disponibles todos los paquetes que queramos instalar en el entorno virtual.

Definición de funciones en Javascript

Alvaro Martínez — Sun, 01 Aug 2010 00:19:56 -0300

Las funciones son un elemento vital en cualquier lenguaje de programación. Pero no todos los lenguajes las manejan de la misma forma; en muchos son tipos de datos especiales que solamente pueden definirse y luego llamarse con (o sin) parámetros, pero otros como Javascript las tratan como simples variables que pueden ser llamadas. A continuación intento describir de forma sencilla lo que se puede hacer con las funciones en Javascript.

Funciones con nombre y funciones anónimas

En todos los lenguajes se pueden declarar funciones con nombre, en javascript esto es tan simple como hacer:

function mi_funcion(parametros) { }

Esto crea una función de nombre mi_funcion, que luego puede llamarse con los parámetros adecuados.

Algunos lenguajes, además, permiten declarar funciones anónimas: funciones que no tienen un nombre y que sirven para esas ocasiones en las que no se quiere crear una función para usarla solamente una vez. En javascript una situación como esta puede ser crear una función que responda a un evento:

window.onload = function() {}

El código anterior crea una función sin nombre que se asigna al objeto onload, y que puede ejecutarse luego haciendo una llamada a window.onload()

Métodos de objetos

Las funciones anónimas se usan también para agregar métodos a objetos, de hecho es la única forma de hacerlo ya que Javascript no posee una construcción del lenguaje para crear clases.

var miobjeto = { un_metodo : function(parametros) { }};

En este caso miobjeto posee un método un_metodo, que al llamarse como miobjeto.un_metodo(parametros) ejecuta la función anónima. Esto es posible gracias a que en Javascript las variables son un `tipo de dato de primera clase`_

Tipo de dato de primera clase

Se puede encontrar una descripción en Wikipedia de lo que significa ser un tipo de dato de primera clase, pero puesto en términos sencillos quiere decir que las funciones son datos como cualquier otro y que pueden por tanto asignarse, crearse, pasarse como parámetro y manipularse casi de cualquier forma. Así, en Javascript suelen pasarse objetos de función a algunas construcciones comunes del lenguaje, por ejemplo:

1 function mi_funcion() {
2     /* código */
3 }
4 
5 setTimeout(mi_funcion, 1000);
6 setInterval(mi_funcion, 10);
7 algun_elemento.onclick = mi_funcion;

Enlaces relacionados

¿Javascript, o «script de Java»?

Alvaro Martínez — Sat, 30 Jan 2010 02:15:12 -0200

He escuchado demasiadas veces la frase script de Java referida a Javascript. Probablemente se trate de una mala traducción que desafortunadamente fue considerada correcta, pero la verdad es que escucharla de un ingeniero en sistemas me choca, y mucho. Saber que gente que sabe piensa que Javascript es simplemente un subconjunto de Java es muy frustrante. Por eso es mi intención ahora mismo nombrar alguna de las diferencias que se me vienen a la mente, simplemente para tenerlo como referencia la próxima vez que me toque explicarle a alguien por qué Javascript NO significa script de Java.

Exponer las diferencias entre Java y Javascript se ha hecho muchas veces antes, pero tengo la sensación de que la mayoría de las veces que se escribió sobre el tema se hizo siendo Javascript un lenguaje despreciado y considerado casi un juguetito de las páginas web. Javascript es mucho más que un Java básico y con algunas cosas raras, e intentaré hacer valer eso en este artículo.

Historia

Dejaré que Wikipedia mencione los detalles sobre la historia del lenguaje. Lo principal en esta historia es que el lenguaje que hoy conocemos como Javascript comenzó su vida llamándose LiveScript: el cambio de nombre fue únicamente (según algunos) para aprovechar la publicidad que se hacía en la época a Java y el impulso comercial que éste estaba teniendo.

Ejecución

Partiendo en ambos lenguajes de un código fuente válido, el proceso que sigue un programa en Java es bastante diferente al que sigue un programa en Javascript.

Java

Un programa Java se compila, generando un archivo .class por cada clase o un JAR que incluye todas las clases. Es la JVM (Máquina Virtual de Java) la que luego ejecuta el programa.

Javascript (en un navegador)

El código fuente Javascript se incluye en la página HTML mediante una etiqueta <script> o <link> en el caso de un archivo externo. El navegador interpreta el código y lo ejecuta en un entorno restringido a la página desde la cual es vinculado.

Sintaxis

Tanto Java como Javascript utilizan una sintaxis basada en la de C. Se podría decir que Java se parece más a C++, mientras que Javascript se parece más a C.

Tipos de datos

Java incluye los tipos de datos básicos integer (y derivados), String, boolean, float y double. Además, cada clase es un tipo de dato con el que podemos crear variables. Una variable de un tipo no puede redefinirse como de otro (a menos que otro sea superclase de uno), y se aplican comprobaciones estrictas de tipos. A esto se le llama tipado estático.

Javascript solamente posee los tipos de datos number, object, string, function. Las variables se definen sin tipo, serán del tipo que sea aquello que se les está asignando. A una variable definida de cierto tipo se le puede asignar un valor de otro tipo (por ejemplo, a una variable entera puede asignársele una cadena), y el tipo de dato de la variable cambia. A esto se le llama tipado dinámico. Veamos un par de ejemplos para ver la diferencia. Primero, código Java:

String variable = "Hola"; // variable se declara de tipo String
variable = 1; // dará un error de compilación, no se puede asignar un entero.

Y ahora un código equivalente en Javascript:

var variable = "Hola"; // variable se declara sin tipo. Como se le asigna una cadena, tendrá el tipo String
variable = 1; // variable es ahora de tipo entero. No hay errores

Ámbito de las variables

Java, al igual que la mayoría de los lenguajes basados en C, tiene variables de bloque. Es decir, que una variable definida en un bloque de código (delimitado por las llaves { y }) existirá solamente dentro de ese bloque. En caso de producirse ambigüedad (una variable local al bloque se llama igual que una variable externa) tiene prioridad el espacio de nombres local.

En Javascript, por otra parte, solamente las funciones generan su propio espacio de nombres. Los bloques de código utilizan las variables definidas fuera, y si definen alguna variable ésta no desaparecerá cuando el programa salga del bloque, sino que seguirá definida en el espacio de nombres global (o de la función en la que esté el bloque). Esto es algo bastante molesto en realidad, ya que puede fácilmente generar conflictos y es una de las principales razones (por si no hubiera ya suficientes) para evitar las variables globales.

Funcional

En java las funciones NO son un tipo de datos. En Javascript sí: una función es una variable como cualquier otra, que se puede pasar como parámetro a otra función o asignar a una variable. Incluso se pueden declarar funciones anónimas para utilizarlas una sola vez y que no ocupen el espacio de nombres. Se dice que una función es un tipo de dato de primera clase. Esto, junto con otras características, hacen que javascript pueda considerarse un lenguaje funcional, y, en palabras del experto Douglas Crockford, el primer lenguaje lambda en llegar a utilizarse masivamente. (donde lambda proviene del cálculo lambda, y es otro nombre para una función anónima.)

Orientación a Objetos

Java es orientado a objetos, como todos sabemos, y utiliza una orientación a objetos clásica, es decir, basada en clases. Los objetos son ejemplares de una clase (disculpen pero detesto utilizar instancia como traducción de instance), y la herencia se da entre clases.

Javascript es también orientado a objetos, pero no usa clases, aunque hay formas de simularlas y se utiliza algo similar a una clase al crear un objeto de tipo Date. En Javascript la herencia se da directamente entre objetos, mediante prototipos. Todo objeto contiene un atributo oculto que lo vincula a su objeto padre, formando una cadena hasta el objeto padre Object (que en los navegadores es window).

Un objeto hereda todos los métodos y atributos de su objeto padre, y si al objeto padre se le agrega un método o atributo, los objetos hijos podrán ver inmediatamente el nuevo miembro añadido. Todo objeto contiene un atributo prototype al que se puede agregar miembros (atributos o métodos) para que todos los objetos hijos puedan verlos. Por ejemplo, si agrega un método metodo a String.prototype, todas las cadenas contendrán el método.

Conclusión

Espero que este repaso por algunas de las principales diferencias entre Java y Javascript sirva de algo, con un poco de suerte estaré ayudando a que ya nadie piense en Javascript como un hermanito menor de Java. Para aquellos que quieran profundizar en el lenguaje, recomiendo los videos disponibles en el YUI Theater y el libro Javascript: The Good Parts de Douglas Crockford.

Slackware 13.1: Instalación y configuración básica

Alvaro Martínez — Sat, 30 Jan 2010 01:59:20 -0200

Nota: Este artículo trata sobre Slackware 13.1, que no es la última versión. Si bien la mayoría de lo que menciona sigue siendo válido, existe un artículo más nuevo sobre Slackware 13.37

Queda claro que le tengo un aprecio bastante grande, sin embargo soy capaz de reconocer que, como todo, esta distribución no es perfecta y tiene sus problemas. Y para solucionar los problemas suele requerirse un conocimiento de lo que se hace. Es por eso que quiero compartir mi experiencia instalando Slackware 13.0 en mi computadora Dell Vostro 1000.

Instalación

La instalación en sí no es un problema, recomiendo esta guía de instalación para aquellos que no hayan realizado este proceso antes. La guía es para la distribución ZenWalk, pero el proceso es casi el mismo ya que ZenWalk es una de las tantas distribuciones derivadas de Slackware.

Un punto a recordar es que, una vez en el programa de instalación, debe iniciarse el proceso eligiendo la opción ADDSWAP en el menú, o TARGET. Estos pasos deben hacerse primero ya que son los que preparan el disco en el que se instalará, si no se hacen primero siempre se llega a un punto en la instalación en el que se debe iniciar todo el proceso de nuevo.

Y esto siempre requiere salir del programa de instalación y abrirlo de nuevo, ya que la autodetección del disco CD/DVD de instalación funciona solamente la primera vez que se hace.

De todas formas, la instalación con las opciones por defecto (full install, instalar todos los paquetes disponibles) puede iniciarse en menos de 5 minutos y terminarse en más o menos media hora.

Configuración inicial

Una vez dentro, hay varias tareas a realizar.

Arrancar por defecto el entorno gráfico

Esto se hace editando el archivo /etc/inittab y cambiando el nivel de ejecución predeterminado. Lo haremos con vim

root@alvaro:/# vim /etc/inittab

Una vez que se abra el archivo, hay que ir a la línea que contiene

# Default runlevel. (Do not set to 0 or 6)
id:3:initdefault:

vim no se parece en nada a los editores normales, por lo que para quien lo usa por primera vez puede resultar bastante extraño. La forma más sencilla de editar lo necesario y salir es llevar el cursor hacia el 3 en la línea mencionada antes, y presionar la siguiente secuencia de teclas:

r : Pondrá el editor en el modo adecuado para reemplazar un caracter
4 : escribirá un 4, reemplazando al 3
:wq : este comando guarda el archivo y sale de vim

Crear un usuario sin privilegios

Para que este usuario sea usable, es necesario añadirlo a varios grupos: audio (para que pueda utilizar la tarjeta de sonido), cdrom, disk, plugdev (para que pueda utilizar dispositivos extraíbles), y video. Esto se puede hacer facilmente; en uno de los pasos adduser muestra la siguiente línea:

Additional groups (comma separated) []:

Si se presiona la flecha hacia arriba, se obtiene una lista de los grupos necesarios.

Utilizar el kernel generic en lugar de huge

Para la instalación, y por defecto en la instalación completa, Slackware instala un núcleo Linux que tiene compilado casi todos los controladores disponibles. Esto implica que el núcleo por defecto es bastante grande e ineficiente, aunque en una instalación funciona bien. Para el uso diario es mejor cambiar a un núcleo que incluya solamente lo mínimo, y en el que los controladores estén incluidos en forma de módulos (de tal forma que solamente se cargarán aquellos que sean necesarios). Este cambio requiere de varias modificaciones, que quizás sea mejor hacer desde el entorno gráfico (se requiere edición de archivos, y es más fácil usar kwrite que vim). Por lo que reiniciar en este momento e iniciar sesión como root en el entorno gráfico puede ser la mejor idea.

Vincular al kernel correcto

Desde la consola, el siguiente comando

cd /boot ; ls -l

Debería mostrar algo como esto (eliminé algunas líneas innecesarias):

lrwxrwxrwx  1 root root      35 2008-12-18 00:49 System.map -> System.map-huge-smp-2.6.29.6-smp
-rw-r--r--  1 root root  965704 2008-11-21 02:20 System.map-generic-smp-2.6.29.6-smp
lrwxrwxrwx  1 root root      32 2008-12-18 00:49 vmlinuz -> vmlinuz-huge-smp-2.6.29.6-smp
-rw-r--r--  1 root root 2347888 2008-11-21 02:20 vmlinuz-generic-smp-2.6.29.6-smp

Los archivos System.map y vmlinuz son enlaces que apuntan a las versiones huge del núcleo (esto puede verse indicado por las flechas -> junto al nombre del archivo). Debemos vincularlas a las versiones generic. Para esto, se utilizan los siguientes comandos:

rm System.map vmlinuz
ln -s vmlinuz-generic-smp-2.6.27.7-smp vmlinuz
ln -s System.map-generic-smp-2.6.27.7-smp System.map

Obviamente conviene hacer uso del autocompletado en bash, para no tener que recordar todo el nombre del archivo (presionar tecla tabulador).

El siguiente paso es crear el archivo initrd correspondiente. Dado que el núcleo genérico no tiene los controladores en el núcleo mismo sino como módulos, es necesario brindarle algunos controladores iniciales para que pueda encontrar el disco duro, leerlo, y cargar el resto de los módulos que necesita. Estos controladores iniciales se guardan en el archivo initrd. Las instrucciones necesarias para crear este archivo están en el archivo README.initrd dentro de la carpeta /boot. Básicamente, para un sistema cuya partición principal es de tipo ext3, y está en /dev/sda1 (la primera partición primaria del primer disco SATA), el comando necesario es

mkinitrd -c -k 2.6.27.7-smp -m mbcache:jbd:ext3 -f ext3 -r /dev/sda1

(dentro de la carpeta /boot)

El último paso ahora es configurar LILO para que cargue este archivo initrd. Habrá que editar el archivo /etc/lilo.conf, buscar la sección correspondiente y agregar una línea al bloque

# Linux bootable partition config begins
image = /boot/vmlinuz
root = /dev/sda1
label = Linux
read-only
# Linux bootable partition config ends

que deberá quedar como

# Linux bootable partition config begins
initrd = /boot/initrd.gz
image = /boot/vmlinuz
root = /dev/sda1
label = Linux
read-only
# Linux bootable partition config ends

# This is given in tenths of a second, so 600 for every minute:
timeout = 1200

por

# This is given in tenths of a second, so 600 for every minute:
timeout = 50

Ahora, reiniciar el sistema nuevamente para cargar el núcleo genérico.

Configuración de una computadora portátil

Red inalámbrica

Para el control de la red inalámbrica Slackware incluye el programa wicd en la carpeta /extra. Bastará entonces con instalar el paquete desde esa carpeta. Algo importante a recordar es que, para que wicd funcione correctamente, es necesario darle permisos de ejecución al archivo /etc/rc.d/rc.wicd, y remover la configuración que se encuentra en el archivo /etc/rc.d/rc.inet1.conf. Para lograr esto simplemente se agrega una almohadilla (#) a toda línea de este archivo que no comience con una.

Si todo va bien entonces, al reiniciar habrá un ícono de wicd al lado del reloj, pronto para conectarse a alguna de las redes detectadas.

Synaptics, el controlador para el touchpad

El controlador synaptics viene incluido en Slackware, y el nuevo X.Org incluido en Slackware 13 lo carga correctamente sin que haya que configurar nada. Pero por defecto desactiva funciones como el hacer clic tocando la superficie del touchpad. Para corregir este comportamiento, se pueden seguir dos caminos. El primero es editar el archivo xorg.conf, como se ha hecho toda la vida. El segundo es modificar la configuración de HAL, lo cual es más acorde a la nueva forma de funcionar de X.Org.

El segundo camino es algo más complicado que el primero, pero requiere conocer menos datos. Si se opta por modificar xorg.conf deben conocerse entre otras cosas el nombre de dispositivo y el protocolo a usar. Sin embargo, modificando la configuración de HAL se indica al sistema qué opciones dar por defecto a un dispositivo que use el controlador synaptics.

En mi caso habilité el botón primario (izquierdo) al tocar con el dedo la superficie del touchpad, el secundario (derecho) en la esquina superior derecha, y el botón central en la esquina inferior derecha. También habilité el desplazamiento (scroll) horizontal y vertical deslizando el dedo sobre los bordes inferior y derecho respectivamente. El archivo completo está aquí. Las opciones posibles se detallan en la página del manual de synaptics. Este archivo debe copiarse a la carpeta /etc/hal/fdi/policy.

Configuración de ahorro de energía

En KDE4, el Gestor de Energía Guidance y el módulo de Gestión de Energía en Preferencias del Sistema pueden configurar sin problemas casi todos los aspectos de ahorro de energía, excepto por un detalle: qué se hace cuando se presiona el botón de encendido/apagado.

En esta página se explica cómo se debe configurar esto, el artículo es viejo y la mayor parte de lo que se explica ya no es necesario (gracias a la combinación Guidance/Preferencias del sistema mencionada antes) Los pasos para que al presionar el botón la computadora hiberne en vez de apagarse son los siguientes:

Cambiar a la carpeta /etc/acpi.
Dejar en esta carpeta únicamente el archivo acpi_handler.sh y crear las carpetas events and actions en caso de ser necesario.
Crear un archivo /etc/acpi/actions/pwrbtn.sh con permisos de ejecución, y con el siguiente contenido:
```
#!/bin/sh
pm-hibernate
```
Crear un archivo /etc/acpi/events/pwrbtn con el siguiente contenido:
```
event=button[ /]power
action=/etc/acpi/actions/pwrbtn.sh
```

append = "resume=/dev/sda2"

(donde /dev/sda2 es la partición de swap). Para finalizar, hay que volver a ejecutar el comando lilo (como antes, primero lilo -t para asegurarse de que todo es correcto, luego lilo para hacer la instalación). Con esto, si la máquina fue hibernada, el núcleo restaurará el estado. En caso de que la máquina haya sido apagada, se hará un arranque normal. En mi caso tengo configuradas dos secciones idénticas, una con el resume y otra sin él, simplemente para hacer pruebas de vez en cuando.

Pasos siguientes

Instalación de programas

Slackware no tiene repositorios de paquetes, todos los paquetes oficiales están en el DVD de instalación. Para instalar programas externos se recomienda utilizar SlackBuilds, que son scripts que automatizan la generación de paquetes a partir de archivos de código fuente. El repositorio más grande de SlackBuilds es slackbuilds.org, y la forma más sencilla de utilizar ese repositorio es a través de una herramienta llamada sbopkg. La mayor parte de los programas tienen su SlackBuild, pero no todos. Para estos últimos lo mejor es descargar el código fuente y crear un paquete con src2pkg. En la mayoría de los casos la compilación será exitosa. Si no lo es, no queda otra opción más que pedir ayuda en algún foro para intentar resolver el problema.

Existen también repositorios extraoficiales de paquetes binarios, siendo los más grandes LinuxPackages y Slacky.

GNOME

Algunos enlaces interesantes:

SlackwareCL: comunidad de usuarios de Slackware de Chile, tienen una guía que puede resultar interesante.
Slacky: comunidad de usuarios de Italia.

Consejos para evitar el SPAM

Alvaro Martínez — Mon, 18 Jan 2010 22:53:26 -0200

Introducción

El spam, o correo basura es sin duda alguna la parte más molesta de trabajar con correo electrónico. Otros términos que se usan frecuentemente son UCE (siglas en inglés de Correo electrónico comercial no solicitado) o UBE (siglas en inglés de Correo electrónico masivo no solicitado). La peor parte del correo basura es que los costos para quien lo envía es casi nulo. Quien debe asumir el costo de transporte, almacenamiento y filtrado (automático y manual) de los mensajes es el proveedor de correo del destinatario. También hay que considerar la pérdida de tiempo que insume el filtrado manual de los mensajes, sobretodo cuando la cuenta de correo ha sido comprometida y recibe grandes cantidades de basura.

Si bien los proveedores de correo tienen cada vez mejores filtros automáticos que nos evitan tener que eliminar manualmente la mayoría de los mensajes basura, aún hay muchas precauciones y buenas prácticas que uno puede tomar para evitar que la casilla se inunde. Sobretodo es importante conocer y difundir las mejores prácticas, y enseñar a los novatos a reconocer las amenazas que el spam trae consigo (fraudes, estafas, venta de productos ilegales, etc). Aunque parezca increíble, hay mucha gente sin experiencia que cae con facilidad en estos engaños.

¿Cómo obtienen las direcciones de correo los spammers

Direcciones de correo visibles en la web

Los spammers (aquellos quienes envían el correo basura) utilizan varios métodos para recolectar nuestras direcciones de correo. Uno de ellos es el uso de robots que recorren las páginas web buscando direcciones. Es decir, si mi dirección de correo electrónico está públicamente visible en una página web, tarde o temprano un robot spammer la encontrará.

Cadenas

Por regla general las cadenas deberían eliminarse sin prestarles mucha atención. Sin embargo, las personas suelen reenviarlas a todos sus contactos, lo cual provoca que luego de 4 o 5 reenvíos el cuerpo del mensaje contenga decenas de direcciones. Si de casualidad el mensaje sigue reenviándose, podría caer eventualmente en poder de un spammer, muchas veces debido a troyanos u otra clase de programas maliciosos.

Sin entrar en los medios técnicos (que deberían estar a cargo de los administradores de los servidores de correo, no de los usuarios), aún hay algunas prácticas que pueden seguirse para evitar el daño causado por el correo basura.

Evitar el spam antes de que llegue

La mejor manera de evitar el correo basura es evitar que nuestra dirección de correo electrónico termine en la base de datos de algún delincuente (en muchos países del mundo el envío de spam es un delito).

Una buena práctica es tener al menos dos cuentas diferentes, una para uso personal y otra para suscripciones a sitios web. Con esto se expone solamente una de las cuentas, que además como no se utiliza para temas personales se puede reemplazar de forma sencilla si comienza a recibir gran cantidad de mensajes basura.

En conjunción con esta práctica, es importante dejar la dirección de correo solamente en sitios medianamente confiables, ya que uno nunca sabe qué puede hacer el creador del sitio con la información almacenada.

Otro punto a considerar es el de las cadenas, como se mencionó arriba. Todos tenemos algún conocido o amigo que no conoce (o pasa por alto) el problema que conlleva el reenviar correo incluyendo todas las direcciones en el campo Para, y sin borrar las cabeceras del mensaje que quiere reenviar. Entonces, para evitar que nuestra cuenta termine en alguna máquina infectada por un troyano (que a su vez envíe la información al servidor de un spammer), es importante explicarle a la gente lo importante que es NO reenviar cadenas, o si se reenvían hacerlo con los cuidados necesarios: enviando solamente el contenido y no las cabeceras de los mensajes anteriores, y poniendo las direcciones en el campo CCO (copia oculta) en vez de en CC para que así cada destinatario no vea las direcciones de los demás.

Qué hacer cuando ya se está recibiendo correo basura

La mayoría de las veces la precaución no es suficiente: la cuenta comienza a recibir correo basura de todas formas. La estrategia en este punto deja de ser unicamente la protección de la cuenta (aunque claramente esto se debe seguir haciendo) para pasar a ser el pretender que la cuenta no existe. Esto es, cualquier respuesta que se envíe a los spammers solamente logrará que nos llegue aún más basura. Por este motivo nunca, bajo ningún concepto, se debe responder a ningún correo no solicitado.

Pero no responder no es suficiente para fingir que la cuenta no existe: el cliente de correo que usemos nos puede traicionar (Thunderbird, Outlook Express, o incluso los clientes web de Gmail o Yahoo). Por esto se recomienda NO abrir mensajes sospechosos, o abrirlos únicamente si el cliente de correo está configurado para mostrarlos en modo texto. El motivo es sencillo: si el cliente de correo admite formato de texto, admitirá imágenes y otras clases de archivos externos. Es muy sencillo incluir un código extra para que a la vez que se envía la petición para obtener esa imagen o archivo externo, se envíe una confirmación de que la cuenta de correo es válida.

No deberíamos tampoco hacer clic en ningún enlace que el correo incluya. En el pasado ha habido fallos en todos los clientes de correo y navegadores, que permiten ir hacia un sitio falseando su dirección. Es decir, cuando uno piensa que está en el sitio de su banco, al que llegó a través de un enlace en un correo, bien podría estar en realidad en un sitio fraudulento.

Una de las reglas generales que siempre deberían seguirse es: si el mensaje no fue solicitado, proceder con precaución. No importa si parece venir de una empresa o sitio web conocido, las direcciones de correo electrónico son fácilmente falseables. Incluso algo tan confiable a primera vista como soporte@microsoft.com podría ser en realidad un fraude.

Afortunadamente para nosotros los hispanohablantes, la mayoría del correo basura se envía en inglés. Por lo que si no tenemos ningún conocido que hable en inglés, se puede descartar con seguridad cualquier correo que no esté en español.

Nunca comprar

Hay que reconocerlo, a veces las ofertas de lo que se vende son interesantes. Pero con el bajo costo que tiene enviar un correo, una sola compra seguramente compense el envío de millones de mensajes no solicitados. Por este motivo es fundamental no comprar nada que se oferte a través de spam, ya que las ventas que se consiguen son el principal motivo para enviarlo (y eso sin contar que en la mayoría de los casos no se trata de comerciantes sino de estafadores, por lo que solamente terminaríamos perdiendo el dinero).

Sustitución de cuentas

A pesar de todo lo comentado, hay que saber reconocer cuando nos han vencido: si la cuenta de correo recibe demasiada basura, no queda otra opción que reemplazarla. Por esto es importante tener una cuenta para asuntos personales y otra para lo demás, es de suponer que la cuenta utilizada solamente para asuntos personales estará más protegida, menos gente la conocerá.

Lamentablemente, debido a los delincuentes una herramienta tan útil como el correo electrónico a veces se vuelve inusable. Es imprescindible entonces poner todos un granito de arena para evitar que la plaga se vuelva aún peor.

Enlaces relacionados

Wikipedia: Spam

¿Cómo escribir un archivo robots.txt?

Alvaro Martínez — Mon, 18 Jan 2010 22:42:11 -0200

Un archivo robots.txt es un archivo de texto simple, que sirve para indicar a los robots (en especial a los robots de los buscadores) qué partes del sitio no debería indexar. Se considera que se puede indexar cualquier carpeta o archivo que no esté explícitamente prohibido por este archivo.

Los buscadores más importantes lo respetan (de otra forma su utilidad sería bastante escasa).

Hay varios motivos para usar un archivo robots.txt:

Evitar el indexado de las imágenes
Evitar que un robot consuma demasiado ancho de banda
Dirigir a los buscadores a las páginas especialmente preparadas para ellos

¿Cómo crearlo?

El archivo robots.txt es un archivo de texto simple, que se ubica en la raíz del sitio. El formato del archivo es extremadamente simple, consta de 1 o más conjuntos, separados por una línea en blanco, de:

Una línea User-agent, indicando el nombre de un robot o “*”; (todos los robots).

Si bien la especificación de robotstxt.org no impone que se respeten mayúsculas y minúsculas, para máxima compatibilidad es mejor respetarlas. Esto es: escribir User-agent con la U mayúscula, y escribir el nombre del robot tal cual se identifica.

Otro detalle a considerar es que no se aceptan expresiones regulares, solamente el nombre de un robot (y solo uno) o el asterisco “*” para que coincida con todos.
Una o más líneas Disallow (no permitir), cada una indicando una carpeta o archivo del sitio que no se quiere que el robot (indicado por la línea User-agent) indexe. En esta línea tampoco se admiten comodines, debe darse la ruta completa. Cada línea Disallow debe contener solamente una ruta.

He aquí un ejemplo, en el que se niega a todos los robots el acceso a la carpeta /admin y al Googlebot el acceso a la carpeta /imagenes y al archivo /javascript/ultrasecreto.js

User-agent: *
Disallow: /admin/

User-agent: Googlebot
Disallow: /imagenes/
Disallow: /javascript/ultrasecreto.js

Los robots que respetan sus directivas lo buscan cada vez que se conectan a un servidor, así que si el archivo no existe se generarán muchos errores 404 causados por robots buscándolo.

¿Cómo saber el nombre que hay que usar para un robot?

La mayoría de los robots “serios” acompañan su cabecera User Agent con una URL en la que se puede encontrar información sobre ellos, que suele incluir los datos necesarios para guiar al robot usando el robots.txt.

Seguridad

Es importante destacar que aunque sirva para indicar a los robots por qué partes del sitio no deben entrar, el archivo robots.txt no debe ser usado como mecanismo de seguridad. Los robots reciben la indicación de no entrar, pero nada les impide hacerlo. Además, todas las rutas que se indiquen quedan visibles para cualquiera que quiera verlas, nada impide a cualquier usuario ver el archivo, sobretodo considerando que siempre se encuentra en la misma ubicación (la raíz del sitio).

Si se necesita seguridad, se necesita un sistema basado en programación del lado del servidor, como siempre (ya sea un paquete PHP o autenticación HTTP)

Enlaces relacionados

Validar una dirección de correo electrónico

Alvaro Martínez — Mon, 11 Jan 2010 23:21:45 -0200

Cualquier sistema que utilice el correo electrónico debería tener algún tipo de validación para evitar errores y datos basura. Pero ¿cómo validar correctamente? Antes que nada hay que tener por seguro que no hay forma (rápida y práctica) de comprobar que una dirección de correo existe y tiene a un usuario detrás, solamente se puede comprobar que la dirección tiene una forma válida y apunta a un dominio activo.

Como suele suceder, el problema puede atacarse de diferentes formas. Hay sistemas que simplemente validan que la información ingresada contenga una arroba, hay otros que usan expresiones regulares complejas que fallan en cuanto la dirección ingresada no es común (aunque sea válida). La forma que voy a plantear no es novedosa, y es bastante sencilla, a la vez que efectiva.

Una expresión regular permisiva

Debe poder validar a cualquier dirección de correo válida, esto quiere decir que debe ser también bastante genérica. El patrón debe validar que exista una arroba, un nombre de usuario, y una parte que indique el dominio. A pesar de que probablemente nunca se usen nombres de usuario complejos en una dirección de correo, la verdad es que se puede usar cualquier caracter en esta parte de la dirección. Por lo que la expresión regular que debe validar esto no puede ser otra que

.+

Que representa a una cadena conteniendo al menos 1 caracter.

El dominio es un poco más complicado. Muchos cometen el error de solamente permitir dos o tres partes separadas por punto, o rechazar direcciones cuya última parte contenga más de 3 caracteres. Con esto se supone que incluyen a todos los dominios de primer nivel (.com, .net, .org… y los de los países, que tienen 2 letras). Pero se olvidan que Internet cambia, y ya tenemos TLD .info y .aero (de cuatro letras) e incluso .museum (de seis).

Debido a esto, y considerando que lentamente están apareciendo los dominios con ñ y letras acentuadas, y que quizás pronto las direcciones comiencen a aceptar más caracteres UTF-8, es que también para validar el dominio se debe utilizar un patrón genérico. El único requisito en este paso es que contenga al menos 2 secuencias de caracteres separadas por un punto. Debe haber al menos un punto, ya que no hay dominios que no desciendan de alguno de los TLD (en realidad sí hay direcciones válidas en entornos de red local que pertenecen a máquinas sin nombre de dominio, pero una dirección así no sirve en internet).

.+\..+

Este patrón representa a una secuencia de caracteres no vacía, seguida de un punto, y seguida de otra secuencia de caracteres no vacía.

Finalmente, juntando las partes el patrón queda:

^.+@.+\..+$

Validación del dominio con PHP

Una versión anterior de este artículo recomendaba validar el dominio con checkdnsrr(). Esta parte ha sido eliminada, y el motivo es bastante simple, a decir verdad.

La función checkdnsrr solamente puede determinar si un dominio está registrado, y con el parámetro adecuado permite saber si el dominio tiene un registro MX (Mail eXchange) asociado (es decir, si es capaz de recibir correo). Pero una entrada DNS correcta no implica que realmente haya un servidor funcionando en el dominio. Otras opciones, como gethostbyname por ejemplo, tienen sus propios problemas:

Pueden fallar si el servidor remoto está temporalmente fuera de servicio, lo cual no es tan extraño en servidores pequeños.
Si el equipo remoto no existe, la llamada a gethostbyname demora mucho en completarse, no por PHP sino por la forma en la que funciona el protocolo DNS.
Podría haber un fallo de conectividad temporal de parte del servidor que ejecuta el programa PHP, lo cual provocaría que la función fallase.

Por estos motivos es que la validación del dominio funcionará en la mayoría de los casos pero fallará en otros, y si no se puede saber que será exitosa en todos los casos, no se puede confiar en ella.

De todas formas se incluyen los enlaces a las páginas del manual de PHP que corresponden a estas funciones, para que cada uno decida si hacer la validación o no.

Vale recordar lo que se mencionó al principio: no existe forma práctica de comprobar con certeza que la dirección es válida aún cuando se pudiese validar el dominio, dado que la dirección podría ser válida en forma pero no existir en el servidor, o podría estar mal escrita por error. La única manera de saber con seguridad si la dirección es válida es enviar un correo de confirmación antes de habilitar al usuario a continuar en el sitio. Pero esto tampoco es la solución en todos los casos; a veces solicitar confirmación al usuario no tiene sentido (por ejempo en un formulario de contacto).

A continuación el código de mi función de validación:

1 <?php
2 function validar_correo($correo) {
3     return preg_match('/^.+@(.+\..+)$/', $correo);
4 }

A modo de resumen: la validación de direcciones de correo es compleja y no vale la pena intentar validar más que la forma. La mayoría de los métodos más estrictos con los que uno se puede llegar a encontrar suelen rechazar direcciones perfectamente correctas (aunque relativamente raras).

Enlaces relacionados

Validar parámetros enteros con PHP

Alvaro Martínez — Fri, 08 Jan 2010 00:01:49 -0200

Introducción

¿Cómo hacer para estar seguro de que un parámetro obtenido por GET (o POST) es un número entero? Intentando resolver esta pregunta he intentado varias técnicas a lo largo del tiempo, y haciendo esas pruebas he llegado a entender más sobre cómo funcionan las comparaciones y las conversiones automáticas de tipos en PHP.

Convirtiendo a un valor entero

intval es una función que obtiene el valor entero de lo que se le pase como parámetro. Es equivalente a forzar una conversión anteponiendo (int) a un valor. Es decir, las siguientes dos líneas son equivalentes:

1  <?php
2  $valor = intval($parametro);
3  $valor = (int) $parametro;

De esta forma se obtiene un valor entero en todos los casos, aunque no necesariamente este valor es igual al que queremos validar, ya que cualquier cadena puede ser convertida a un entero, incluso una cadena que no contenga números (si no comienza con números, su valor es cero).

Pero una conversión no es una validación, así que debemos hallar una forma de asegurarnos de que el valor almacenado en $parametro es un número entero.

Primer intento: is_int

La primera idea es comprobar con la función is_int. Esta función, como su nombre lo indica, comprueba que una variable sea de tipo entero, devolviendo true en caso de que lo sea, y false en caso contrario.

Parece ideal, sin embargo hay un problema: los valores que se reciben vía GET o POST son siempre cadenas, sin importar su contenido. El manual de la función lo advierte:

Para probar si una variable es un número o una cadena numérica (como en el caso de la entrada de un formulario, que es siempre una cadena), debe usar is_numeric().

Lo podemos comprobar fácilmente: Supongamos que $_GET[‘var’] tiene el valor 12, es decir, recibimos una URL conteniendo &var=12.

En estas condiciones,

1  <?php
2  gettype($_GET['var']); // devuelve "string"
3  is_int($_GET['var']); // devuelve false

Segundo intento: is_numeric

La función is_numeric toma cualquier una variable (o valor) de cualquier tipo, y comprueba si tiene formato de número. Esto es, si es una cadena que representa un entero, o un flotante en cualquiera de las notaciones válidas para PHP. Serviría para nuestro propósito si no fuese porque no acepta solamente enteros sino también números con coma (punto, en realidad), y por lo tanto devolverá true para un valor como 10.33, por ejemplo.

Tercer intento: comparación con entero

Otra opción puede ser hacer una comparación como

1 <?php
2 $_GET['var'] == (int) $_GET['var'];

En teoría funcionaría, pero no es así. PHP es un tanto especial en lo que refiere a las conversiones de tipos: si uno de los valores a comparar es entero, convertirá al otro en entero antes de compararlos. Por lo tanto, la comparación propuesta siempre será cierta, ya que el lado izquierdo de la comparación será convertido. El resultado es que el código anterior es equivalente al siguiente, que es siempre verdadero y por lo tanto no nos sirve:

1 <?php
2 (int) $_GET['var'] == (int) $_GET['var'];

Cuarto intento: comparación de idénticos

Uno podría pensar que si PHP convierte a entero ambos lados y por eso no sirve el ejemplo anterior, bastaría con usar el operador === (comparación sin conversión) para saltear el problema. Pero no es así. Los valores siempre serán de tipos diferentes (ya que las variables GET son siempre cadenas) y por lo tanto la comparación sería siempre falsa.

Quinto intento: complicado pero funciona

Finalmente decidí probar algo más complejo pero que evita todos los problemas de los casos anteriores.

¿Qué hacer? La comparación con un entero es necesaria, porque después de todo lo que necesitamos es un entero, pero no podemos comparar una cadena con un entero porque la cadena será convertida. La solución que se me ocurrió es simplemente volver a convertir al entero en una cadena:

1 <?php
2 $_GET['var'] == (string) intval($_GET['var']);

1 <?php
2 $_GET['var'] == (string) (int) $_GET['var'];

Por ejemplo, si $_GET[‘var’] tiene el valor “12”, el proceso sería:

1 <?php
2 intval("12") # --> entero 12
3 (string) intval("12") # --> cadena "12"
4 "12" == "12" # --> verdadero, contienen el mismo valor.

Si ahora $_GET[‘var’] tiene el valor “hola”:

1 <?php
2 intval("hola") # --> entero 0
3 (string) intval("hola") # --> cadena "0"
4 "hola" == "0" # --> falso, la cadena pasada no es un entero.

Y finalmente, el caso que hace que las conversiones fallen: una cadena con valores numéricos y letras. Supongamos que $_GET[‘var’] tiene el valor “12hola”.

1 <?php
2 intval("12hola") # --> entero 12
3 (string) intval("12hola") # --> cadena "12"
4 "12hola" == "12" # --> falso. Al evitar la conversión automática, no hay problemas.

Solución correcta: ctype_digit

Esta es una actualización de este artículo. Luego de mucho tiempo, di casi de casualidad con esta función, que sirve justamente para validar si una cadena contiene únicamente dígitos. Es increíble cómo uno puede utilizar un lenguaje durante años, y seguir encontrando cosas que no conocía, en particular esta función que no es para nada nueva, existe desde PHP 4.0.4

Es importante aclarar que esta función sirve solamente para variables de tipo cadena, ya que lo que hace es comprobar que cada caracter en el valor pasado como parámetro está en el rango ASCII que corresponde a los dígitos del 0 al 9 (valores entre 48 y 57 inclusive). No sirve para datos de tipo entero, y esto está claramente especificado en su página del manual. También es preciso tener en cuenta que un enterno negativo no será admitido, debido a que “-” no es un dígito.

Todo el trabajo que pasé intentando validar un entero se reduce, entonces a:

1 <?php
2 if (ctype_digit($variable)) {
3     echo "La variable es entera";
4 }

Enlaces relacionados

CSV: simple y versátil

Alvaro Martínez — Thu, 07 Jan 2010 22:09:38 -0200

¿Qué es un archivo CSV?

CSV es un tipo de archivo de texto que contiene son archivos de valores separados por comas (de ahí su nombre). Es un formato bien simple y práctico. No tiene una documentación oficial, pero buscando en internet encontré el RFC 4180, Common Format and MIME Type for Comma-Separated Values (CSV) Files. Al contrario de muchos RFC, que son especificaciones completas de formatos y protocolos, este parece ser simplemente un resumen de las características de los CSV, y un intento por documentar formalmente el formato.

Hay 5 reglas básicas que definen un archivo CSV, a saber:

Cada campo se separa con una coma, al último de la fila no le sigue una coma
No se toman en cuenta posibles espacios entre las comas separadoras.
Cada fila se separa con un salto de línea (CRLF, aunque se soporta también LF)
Los campos pueden o no estar delimitados por comillas (necesario en particular cuando se necesita incluir una coma en el campo o un salto de línea).
Si se necesita incluir comillas “, hay que duplicarlas: para que se tome “b” como el campo completo, hay que escribirlo como ”“b”“

Detalles

En caso de querer ponerlo para descargar, es bueno saber que el tipo MIME del formato es text/csv.

La codificación de caracteres por defecto se toma como US-ASCII, pero puede usarse el parámetro charset de la cabecera Content-Type para especificar otra. Si no se usa charset, el programa que trabaje con el archivo CSV deberá decidir qué codificación usa. Este es el caso más común, ya que cuando uno abre el archivo con un programa como Excel u OpenOffice Calc, no existe una cabecera que indique el tipo MIME.

PHP provee 2 funciones para el manejo de estos archivos: fputcsv y fgetcsv. fgetcsv extrae los campos separados por comas de un archivo, línea por línea, mientras que fputcsv permite hacer el proceso contrario.

Python incluye el módulo csv, que permite leer y escribir fácilmente tuplas y listas hacia CSV y viceversa.

Siendo un formato tan simple, resulta muy práctico para transmitir o almacenar información que luego debe ser procesada por otro sistema. También es la forma más sencilla de generar un archivo que pueda ser leído por los programas de hojas de cálculo (Excel, Calc, Gnumeric, etc), aunque no guarda información de formato de texto (negritas, colores, tamaños de letra, etc).

En caso de que no sea suficiente, siempre se puede recurrir a formatos más complejos, como XML o JSON.

Enlaces relacionados:

Transacciones en MySQL

Alvaro Martínez — Sat, 02 Jan 2010 19:11:36 -0200

Hay situaciones en las que necesitamos hacer más de una consulta al mismo tiempo, y todas tienen que ser correctas para que los datos sean consistentes y tengan sentido, de otro modo tendríamos información “colgada” y desvinculada. En el mejor de los casos esta información provocaría un desperdicio de espacio en la base de datos, pero lo más probable es que además lleve a errores a la hora de mostrarse y de hacer cálculos con ella.

Parte de este problema se resuelve teniendo una buena estructura de base de datos, con claves foráneas relacionando los campos correspondientes.

Pero para mayor seguridad, es bueno usar lo que en jerga databasera se conoce como transacciones.

Las transacciones sirven para asegurar la consistencia de la información, asegurando que un conjunto de sentencias se ejecuten correctamente, o no se ejecuten.

En un principio MySQL no las soportaba, esto cambió a partir de la versión 4, y con el uso de tablas InnoDB. Nótese que el motor por defecto para las tablas en MySQL hasta las versiones 5.* era MyISAM, que no soporta transacciones.

Un ejemplo

Supongamos que un sitio web bancario tiene 2 usuarios, ambos trabajando sobre la misma cuenta.

El usuario 1 pide incrementar su saldo en 10, mientras que el usuario 2 pide disminuirlo (a través de un formulario, por ejemplo)

El programador del sistema no puede decidir el orden en el que se ejecutarán las consultas, así que bien podría suceder lo siguiente:

bal1 := ... SELECT balance FROM cuentas WHERE cuenta=X -- usuario 1
bal2 := ... SELECT balance FROM cuentas WHERE cuenta=X -- usuario 2

En este punto, existen dos copias de la aplicación que contienen una variable $balance cada una. Supongamos que ambas necesitan actualizar el valor en la base de datos:

UPDATE cuentas SET balance=(bal1+10) WHERE cuenta=X -- usuario 1
UPDATE cuentas SET balance=(bal2-10) WHERE cuenta=X -- usuario 2

El resultado es que ambas copias del programa ejecutaron sus consultas con la información de balance que tenían, por lo que el resultado final es como si la consulta del usuario 1 no se hubiera ejecutado nunca, ya que el usuario 2 actualiza el registro con información vieja. Al final, en vez de quedar con el mismo saldo, la cuenta termina perdiendo 10.

Lo que se necesita para este conjunto de consultas, es lo que se denomina ACID, un acrónimo inglés que quiere decir Atomicidad, Consistencia, Aislamiento y Durabilidad. Recomiendo leer la información de Wikipedia para entender de qué se trata esto, pero lo importante es lo siguiente: las transacciones son un conjunto de consultas que se ejecutan como si fuesen una. Y por esto, permiten asegurar la consistencia de los datos, ya que si en mitad del proceso una consulta falla, todos los cambios producidos por consultas anteriores pueden ser revertidos.

¿Cómo usar transacciones?

Usar transacciones es muy simple: antes de ejecutar la primer consulta, se ejecuta una que solamente contiene BEGIN. Luego se ejecutan las consultas que deban ejecutarse. Si éstas resultan exitosas, se termina la transacción con COMMIT, lo cual provoca que los cambios hechos por las consultas anteriores sean permanentes. Si las consultas fallan en algún paso, se puede volver al estado anterior al comienzo de la transacción ejecutando ROLLBACK

Aunque los datos no sean realmente escritos a la o las tablas involucradas hasta ejecutar el COMMIT, las consultas devuelven lo mismo que si lo fueran, es decir, para saber si una consulta falló basta con ver el valor de retorno de mysql_query y para ver el número de filas afectadas sigue valiendo usar mysql_num_rows

Mientras la transacción está ejecutándose, los datos (en el caso de InnoDB las filas y en el caso de MyISAM las tablas) afectados quedan bloqueados, nadie puede acceder a ellos. Cualquier consulta que tenga que ver con los mismos datos será demorada hasta que la transacción termine. Esto implica que usar transacciones es un poco más lento que no usarlas, pero a la vez implica que los datos involucrados no pueden ser modificados por otra copia de la aplicación, y por lo tanto se evita la situación planteada al principio como ejemplo.

Dicha situación, implementada de forma “transaccional” en PHP, quedaría:

 1 <?php
 2 mysql_query("BEGIN");
 3 $balance = ..... mysql_query("SELECT balance FROM cuentas WHERE cuenta=X");
 4 $resultado = mysql_query("UPDATE cuentas SET balance=$balance+10 WHERE cuenta=X");
 5 
 6 if ($resultado !== false)
 7     // la consulta fue exitosa
 8     mysql_query("COMMIT");
 9 else
10     mysql_query("ROLLBACK");

(falta revisar que la consulta que obtiene el balance sea exitosa, pero de todas formas esto es solo un ejemplo)

autocommit

MySQL tiene una variable de entorno llamada autocommit, que por defecto tiene el valor 1. Configurado de esta manera no se pueden usar transacciones, porque MySQL automáticamente hace un COMMIT luego de cada consulta.

Para usar transacciones entonces, hay que poner autocommit a 0 (desactivarlo).

Nota: si autocommit se pone a cualquier número N > 1, MySQL hace un COMMIT automático luego de N consultas.

Para cambiar el valor de autocommit, simplemente se usa

SET autocommit = 0;

He aquí lo que sé sobre las transacciones. Es un tema interesante y cualquiera que programe un sistema relativamente complejo debería considerar si necesita transacciones para asegurar la “salud” de sus tablas y datos.

Enlaces relacionados

Como lamentablemente suele suceder, las versiones en inglés de los artículos de Wikipedia contienen información más detallada que las versiones en español.

Manejando archivos .INI con PHP

Alvaro Martínez — Thu, 31 Dec 2009 21:31:03 -0200

¿Qué es un archivo .INI?

Se puede leer una descripción del formato INI en la Wikipedia.

Puesto de forma sencilla, un archivo INI es un archivo de texto con un formato bastante simple: cada línea es de la forma

campo = "valor"

con posibilidad de contener secciones, declaradas con una línea [nombre_sección]. Son archivos bastante simples y pueden llegar a ser útiles, aunque no sean demasiado flexibles.

Un ejemplo de archivo INI es el archivo de configuración de la base de datos para Zend Framework:

[base_de_datos]
db.adapter = PDO_MYSQL
db.config.host = servidor
db.config.username = usuario
db.config.password = contraseña
db.config.dbname = base

¿Cómo leer un archivo INI?

Los archivos INI pueden ser transformados en matrices de PHP usando la función parse_ini_file.

Esta función admite 2 parámetros: El primero es el nombre del archivo a procesar y el segundo, opcional, indica si se deben procesar las secciones del archivo.

Por defecto las secciones no se procesan. La diferencia entre ambas formas es que si se procesan las secciones se genera una matriz multidimensional, una matriz para cada sección.

Por ejemplo, aplicar la función al archivo de configuración mostrado antes:

<?php
var_dump(parse_ini_file('archivo.ini'));

Produce la siguiente salida:

array(5) {
    ["db.adapter"]=>
        string(9) "PDO_MYSQL"
    ["db.config.host"]=>
        string(9) "servidor"
    ["db.config.username"]=>
        string(4) "usuario"
    ["db.config.password"]=>
        string(0) "contraseña"
    ["db.config.dbname"]=>
        string(6) "base"
    }

Mientras que aplicar la función indicando que deben procesarse las secciones:

<?php
var_dump(parse_ini_file('archivo.ini', true));

Devuelve lo siguiente:

array(1) {
    ["base_de_datos"]=>
        array(5) {
            ["db.adapter"]=>
                string(9) "PDO_MYSQL"
            ["db.config.host"]=>
                string(9) "servidor"
            ["db.config.username"]=>
                string(4) "usuario"
            ["db.config.password"]=>
                string(0) "contraseña"
            ["db.config.dbname"]=>
                string(6) "base"
        }
    }

¿Cómo escribir un archivo INI?

PHP no tiene integrada una función para realizar el proceso inverso, es decir, convertir una matriz en un archivo INI. Es extraño, porque en realidad es un proceso muy simple, si se hace uso de foreach.

Este fragmento de código es todo lo que se necesita para generar el archivo:

1 <?php
2 $salida = '';
3 foreach($matriz as $clave => $valor) {
4     $salida .= $clave.' = "'.$valor.'"'.SALTO;
5 }

Para cada uno de los elementos de la matriz, se escribe la clave, un signo de igualdad (“=”) y el valor entre comillas.

No es necesario que el valor vaya entre comillas, pero “no molesta” y además sí es necesario si el valor tendrá más de una línea. La constante SALTO guarda el valor correcto para el salto de línea (“\n” o ”\r\n”).

Para escribir las diferentes secciones, se asume que se trata con una matriz multidimensional. Entonces, simplemente se recorre la primera matriz, y para cada uno de sus elementos:

Se escribe la clave entre []
Se recorre la matriz que contiene, con el mismo código anterior
Se escribe un salto de línea más. No estoy seguro de que sea necesario para separar secciones, pero sí que resulta en un archivo más prolijo y legible.

 1 <?php
 2 $salida = '';
 3 foreach($matriz as $clave => $matriz_interior) {
 4     $salida .= '['.$clave.']'.SALTO;
 5 
 6     foreach($matriz_interior as $clave2 => $valor) {
 7         $salida .= $clave2.' = "'.$valor.'"'.SALTO;
 8     }
 9 
10     $salida .= SALTO;
11 }

Finalmente, solo queda encargarse de cómo se abrirá el archivo y se guardarán los datos.

En mi función escribe_ini, si se pasa una matriz unidimensional para guardar, la misma se copia en otra, de forma de trabajar siempre con una matriz multidimensional. Creo que es la mejor manera de no repetir código.

 1 <?php
 2 function escribe_ini($matriz, $archivo, $multi_secciones = true, $modo = 'w') {
 3     $salida = '';
 4 
 5     # saltos de línea (usar "\r\n" para Windows)
 6     define('SALTO', "\n");
 7 
 8     if (!is_array(current($matriz))) {
 9         $tmp = $matriz;
10         $matriz['tmp'] = $tmp; # no importa el nombre de la sección, no se usará
11         unset($tmp);
12     }
13 
14     foreach($matriz as $clave => $matriz_interior) {
15         if ($multi_secciones) {
16             $salida .= '['.$clave.']'.SALTO;
17         }
18 
19         foreach($matriz_interior as $clave2 => $valor)
20             $salida .= $clave2.' = "'.$valor.'"'.SALTO;
21 
22         if ($multi_secciones) {
23             $salida .= SALTO;
24         }
25     }
26 
27     $puntero_archivo = fopen($archivo, $modo);
28 
29     if ($puntero_archivo !== false) {
30         $escribo = fwrite($puntero_archivo, $salida);
31 
32         if ($escribo === false) {
33             $devolver = -2;
34         } else {
35             $devolver = $escribo;
36         }
37 
38         fclose($puntero_archivo);
39     } else {
40         $devolver = -1;
41     }
42 
43     return $devolver;
44 }

Los parámetros que recibe son:

$matriz - La matriz que se escribirá en el archivo
$archivo - La ruta al archivo que se escribirá / creará
$multi_secciones - Indica si se deben crear secciones o no.
$modo - Se pasa directamente a fopen(), indica cómo se abre el archivo.

Y los valores de retorno:

-1: Error al abrir el archivo para escritura. El motivo más frecuente es que el usuario no tiene permisos para escribir en el directorio.
-2: Error al escribir en el archivo.
otro valor: el número de bytes escrito por fwrite()

Enlaces relacionados

Páginas de error HTTP

Alvaro Martínez — Thu, 31 Dec 2009 21:19:01 -0200

Los errores HTTP se ven bastante seguido, pueden suceder en cualquier sitio, en cualquier momento. El sitio falla, alguien copia mal un enlace que le pasa a un amigo, alguien escribe mal la dirección a la que quiere ir. Incluso puede pasar que un motor de búsqueda tenga un enlace viejo en su índice.

Se podría decir que estos errores son inevitables, pero eso no es excusa para no saber manejarlos. Un estudio reciente concluyó que el 18% de las personas que ven una página de error 404 cree que se trata de un error debido a que el sitio está mal hecho. ¿Volverías a un sitio que consideras mal hecho si tuvieras una alternativa?

Es muy importante saber qué poner en una página de error, cómo tratar al visitante e intentar retenerlo, y cómo configurar el servidor para que muestre la página que uno quiere que se muestre, en vez de la fea página por defecto.

Hace poco se hizo un artículo sobre el tema en MaestrosdelWeb. En este artículo se mencionan algunas instrucciones a tener en cuenta para crear una página de error que sirva a los intereses del sitio. Es decir, ya que el error se produce y no lo podemos evitar, debemos intentar que la página de error sea útil al visitante que se la encuentra.

Pero el error 404 no es el único que existe (de hecho, en la mayoría de los casos y según la norma HTTP, debería usarse 410 y no 404) Hay otros errores comunes que pueden darse en casos de restricciones de páginas (403 Forbidden) o errores del servidor (500 Internal Server Error).

¿Cómo se hace para especificar una página diferente a la página por defecto?

La forma más sencilla en servidores Apache (la mayoría) es editar el archivo .htaccess ([punto]htaccess) de la raíz del sitio.

Este archivo puede ubicarse en cualquier carpeta, pero hay que tener en cuenta que las directivas que contenga solo se aplicarán a la carpeta que lo contiene, y a sus subcarpetas. Por lo tanto, si se cambian las páginas de error en un archivo .htaccess ubicado dentro de una carpeta cualquiera, solamente se estarán redirigiendo los errores que ocurran en archivos dentro de esa carpeta.

La forma de especificar una página “personalizada” para los errores es la siguiente:

ErrorDocument [código de error] [ruta absoluta a la página que se quiere usar]

Por ejemplo,

ErrorDocument 404 /error404.htmlErrorDocument 500 /error500.html

Puede usarse la misma página para todos los errores, aunque es recomendable especificar lo que sucedió: no es lo mismo un error temporal (la base de datos no está disponible, por ejemplo), que un error permanente como el 404. También es importante crear y lanzar errores que correspondan con el error real: un problema al conectar con la base de datos no provocará por si mismo un error 500 (“Error interno del servidor”) pero si encontramos y detectamos un problema como este, mostrar una página de error 500 puede ser lo apropiado, después de todo sí se produjo un error “interno”.

A la hora de personalizar las páginas de error no solo se pueden usar documentos estáticos, sino que se puede usar también un programa PHP (o en el lenguaje que sea). El servidor Apache pone a disposición de este programa las variables $\_SERVER[‘REDIRECT\_URI’] y $\_SERVER[‘REDIRECT\_STATUS’], que indican respectivamente la ruta que se envió y que causó el error, y el código del error que se produjo.

Por ejemplo, para generar el famoso

Error 404: No se pudo encontrar el archivo XXX en este sitio

Se podría hacer lo siguiente con PHP:

<?php
echo 'Error '.$_SERVER['REDIRECT_STATUS'].':No se pudo encontrar el archivo '.$_SERVER['REDIRECT_URI'].' en este sitio';

Según la documentación de Apache, también debe enviarse desde la página PHP al navegador una cabecera HTTP indicando el error, para asegurar que el navegador “se entere” de lo que realmente sucedió. Esto también se menciona en la página del manual de header(), que es la función de PHP que realiza el trabajo de enviar cabeceras HTTP al navegador.

Hay que tener en cuenta un detalle más: PHP puede funcionar en el servidor como módulo de Apache o como CGI. La información de cómo está funcionando PHP puede obtenerse ejecutando la función phpinfo(), y viendo la salida de “Server API“. Si pone “CGI“, PHP está funcionando como CGI, mientras que si pone “Apache Handler“, PHP está funcionando como módulo de Apache.

Debido a un pequeño fallo de PHP, estas 2 formas de funcionamiento tienen comportamientos ligeramente diferentes. En el caso de que PHP funcione como CGI, la cabecera a enviar es:

<?php
header( 'Status: 404 Not Found' );

mientras que si es módulo:

<?php
header( 'HTTP/1.0 404 Not Found' );

Como se ve, la diferencia está en que una versión usa Status: mientras que la otra usa HTTP/1.0 (o HTTP/1.1, con algunas diferencias). Esta diferencia no solamente se da con el error 404, sino también con el resto de los errores HTTP.

Parámetros de header()

La función header tiene 2 parámetros opcionales, que pueden servir para evitar las diferencias de funcionamiento entre las versiones de PHP.

Según el manual oficial, la sintaxis de la función es

void header ( string $string [, bool $replace [, int $http_response_code ]] )

El primer parámetro, $string, es el que usamos siempre: una cadena con el contenido de la cabecera. El segundo, $replace, indica si la cabecera enviada con header() debe sustituir a otra cabecera previa con el mismo nombre. Y el tercero e interesante, $http\_response\_code, indica el código de respuesta HTTP que estará asociado a la cabecera enviada. Por lo que, según pude leer en las notas de usuario del manual de PHP, en vez de usar header como siempre, se puede evitar el problema de saber cómo se ejecuta PHP usando simplemente:

<?php
header(' ', true, 404);

Según la persona que escribió la nota, el primer parámetro de la función no debe ser una cadena vacía, de ahí el uso de un espacio. Y en mis pruebas, esto genera una cabecera de error perfectamente válida.

Vale la pena leer las notas del manual de PHP, muchas veces se encuentran cosas muy interesantes. Y vale la pena también pensar un poco fuera de lo normal para encontrar soluciones prácticas a los problemas de todos los días.

Enlaces relacionados

Colores predefinidos en CSS

Alvaro Martínez — Thu, 31 Dec 2009 20:48:03 -0200

CSS provee varias formas de definir colores como valores de propiedades (fondo, color de letra, bordes, etc). Estas son:

rgb(RRR,GGG,BBB): Valores decimales para rojo, verde y azul, cada uno entre 0 y 255.
rgb(RR%, GG%, BB%): Valores en porcentajes de rojo, verde y azul. Indicar 0% es igual a poner 0 en la forma anterior, e indicar 100% es lo mismo que poner 255.
#RRGGBB: valores hexadecimales (tal y como se usan en HTML)
#RGB: Valores hexadecimales abreviados. Por ejemplo, #FFFFFF (blanco) se puede escribir como #FFF
color: Uno de los 16 colores predefinidos por la norma CSS.

Esta última opción es la más cómoda, pero también provoca algunos problemas: muchas veces uno prueba el nombre de un color cualquiera (por ejemplo “skyblue”, celeste), ve que funciona, y sigue diseñando tranquilamente. Pero al validar, el validador indica que “skyblue” no es un valor válido… Es bueno entonces tener una lista de los colores predefinidos, para evitar estos detalles.

Y los colores predefinidos en CSS2 son los siguientes:

white	black	aqua	blue
fuchsia	gray	green	lime
maroon	navy	olive	purple
red	silver	teal	yellow

No son muchos, pero son bastante variados. Y siempre es más cómodo escribir white que rgb(255,255,255)

CSS3 promete muchas más opciones a la hora de manejar los colores. Se podrá elegir el perfil de color, usar los colores predefinidos para SVG, y algunas otras cosas más.

Enlaces relacionados

Propiedades de fondo en CSS

Alvaro Martínez — Thu, 31 Dec 2009 20:27:59 -0200

Con CSS se puede especificar el fondo de un elemento cualquiera, y sus propiedades. Se puede especificar el color, la imagen que se usará, si esta imagen debe repetirse o no, y dónde debe ubicarse.

background-image : url(ruta a la imagen);

La imagen que se usará como fondo. Casi todos los navegadores actuales (excepto IE <= 8) soportan múltiples imágenes de fondo, que se superponen según sea necesario. Es decir, se puede colocar una imagen de fondo arriba a la derecha, otra abajo a la izquierda, y otra que se repita en toda la página. La posibilidad de especificar múltiples imágenes de fondo para un mismo elemento es parte de CSS 3.

background-repeat : repeat | no-repeat | repeat-x | repeat-y

Especifica si la imagen debe repetirse tanto vertical como horizontalmente.

repeat hace que se repita en mosaico en ambos sentidos
no-repeat hace que la imagen se muestre solo 1 vez
repeat-x hace que la imagen se repita horizontalmente
repeat-y hace que la imagen se repita verticalmente.

background-color : rgb(XXX,YYY,ZZZ) | #XXYYZZ | color

Especifica el color del fondo.

rgb(XXX,YYY,ZZZ) Valores decimales para rojo, verde y azul
#XXYYZZ valores hexadecimales (tal y como se usan en HTML)
color uno de los 17 colores predefinidos en CSS.

background-attachment : scroll | fixed

Especifica si la imagen de fondo debe desplazarse o no con el texto (scroll la deja moverse, fixed la deja fija).

background-position: posVertical posHorizontal

Especifica la posición en la que se ubica la imagen de fondo. La forma más fácil de especificarla es usando las palabras top (arriba), left (izquierda), right (derecha) y bottom (abajo). También pueden especificarse porcentajes, por ejemplo un valor de 15% 30% ubicará la imagen de fondo (su esquina superior izquierda) con un margen izquierdo de 15% del ancho de la página, y un margen superior de 30% de la altura de la página. Otros valores más usuales son, por ejemplo top left, o bottom right.

background

La forma corta, personalmente me parece difícil de recordar y más compleja que usar las propiedades largas, pero existe. Sirve para especificar todas las propiedades del fondo en una sola línea:

background: background-color || background-image || background-repeat || background-attachment || background-position

No es necesario especificar todas las propiedades, lo siguiente es perfectamente válido:

background: white url(fondo.png);

Y tampoco es necesario especificar las propiedades en el orden mostrado, lo siguiente también es válido (ejemplo mostrado en el sitio del W3C):

background: url("chess.png") gray 50% repeat fixed

Enlaces relacionados

¿Cómo hacer para ocultar y mostrar un elemento de la página?

Alvaro Martínez — Sat, 26 Dec 2009 17:03:23 -0200

Las propiedades display y visibility

Hacer que un elemento se oculte o se muestre según las acciones del usuario es un efecto muy práctico y que da una buena sensación de interactividad.

Para controlar la visibilidad de un elemento se dispone de las propiedades de CSS display y visibility. Ambas propiedades controlan la forma en que se muestra un elemento cualquiera de la página.

Si se considera el siguiente código HTML:

<div id="un_div">

Cambiando el valor de display se puede lograr:

Que se vea normalmente como una caja (modo por defecto)
```
#un_div { display : block; }
```
Que no se vea ni ocupe espacio en la página:
```
#un_div { display : none; }
```

Se puede jugar también con el valor de visibility. Esta propiedad controla si el elemento se ve o se vuelve transparente. No se puede decir que lo oculte, porque seguirá ocupando espacio normalmente. Esta es la principal diferencia con display, ya que un elemento oculto mediante ésta última propiedad no ocupa espacio en la página. En realidad la diferencia es bastante mayor, ya que display tiene el control de cómo se muestra el elemento (como una caja, como un elemento en línea, como una tabla, como una fila de tabla, etc).

Se puede ver un ejemplo del funcionamiento de ambas propiedades en esta página de ejemplo.

Controlar la visibilidad con Javascript

Supongamos que el “div” mostrado antes está oculto por CSS:

#un_div { display : none; }

El primer paso es obtener el nodo del div en una variable:

var div = document.getElementById("un_div");

Luego, acceder a los estilos del elemento con el atributo style

div.style.display = "block"

Y listo, aparece el div por arte de MagiaScript(tm) :-P

Para ocultarlo basta poner display a none:

div.style.display = "none"

Si se prefiere usar visibility, el procedimiento es idéntico, solo que se usarán el valor visible para que el elemento se vea, y hidden para que se oculte.

Notas:

No es necesario guardar el nodo en una variable, pero es más rápido hacerlo si se deben hacer más modificaciones en él.
Esto funciona de la misma forma en cualquier elemento de la página, no es necesario que sea un div

Enlaces relacionados

Registros aleatorios con PHP y MySQL

Alvaro Martínez — Sat, 26 Dec 2009 16:45:42 -0200

El problema

Obtener un registro al azar de una tabla es útil en diversas ocasiones, por ejemplo para mostrar imágenes o anuncios diferentes en cada carga de una página. Sin embargo no existe una forma eficiente de lograr esto en los motores de bases de datos, al menos no en MySQL.

A continuación se describen varios métodos que encontré buscando en Internet sobre este tema.

Método 1: ORDER BY RAND()

Esta es la forma ampliamente usada, se podría decir que es una solución normal para el problema. Sin embargo, en la mayoría de los casos, es la forma más lenta y menos eficiente de hacerlo. En la página del manual de MySQL sobre esta función, puede leerse:

Note that RAND() in a WHERE clause is re-evaluated every time the WHERE is executed.

Eso quiere decir que para cada registro que cumple con las cláusulas WHERE, se ejecuta una vez la función RAND(). Luego, cuando se tienen todos los registros, MySQL los ordena según el valor que RAND devolvió para cada uno. Cuando se usa junto a LIMIT, entra en juego lo que se dice en la página de optimización de LIMIT.

If you use LIMIT row_count with ORDER BY, MySQL ends the sorting as soon as it has found the first row_count rows of the sorted result, rather than sorting the entire result. If ordering is done by using an index, this is very fast. If a filesort must be done, all rows that match the query without the LIMIT clause must be selected, and most or all of them must be sorted, before it can be ascertained that the first row_count rows have been found. In either case, after the initial rows have been found, there is no need to sort any remainder of the result set, and MySQL does not do so.

Lo que esto quiere decir es que MySQL detendrá el proceso de selección y orden de las filas en cuanto encuentra la cantidad de filas pedidas, sobretodo si la consulta indica buscar y ordenar por un campo índice. Pero si necesita hacer un orden extra (como cuando se usa RAND()) no podrá hacer esta optimización: deberá procesar todas las filas de la tabla y ordenar luego, para finalmente devolver el número de filas pedidas.

El texto indica también que MySQL ordena solamente hasta encontrar los primeros row_count resultados (es decir, el número de resultados pedidos en la consulta). Si bien esto es una mejora de rendimiento, en general se cumple lo que la página dice, most or all of them must be sorted: deben ordenarse todos o la mayoría de los registros.

En tablas grandes puede ser muy lento. Por otro lado, en tablas pequeñas puede no notarse la diferencia. Pero en cualquier caso es útil saber que no es el método más eficiente.

Método 2: Usando COUNT y 2 consultas

Este método funciona bien cuando se necesita solamente un registro, o se necesitan n registros pero no importa si se obtienen consecutivos a partir de uno al azar.

Hace uso de COUNT(), una función que devuelve el número de filas afectadas por la consulta.

1 SELECT COUNT(*) as cantidad_de_filas
2 FROM tabla
3 WHERE .....

Nota: Con el asterisco, COUNT() devuelve el número de filas afectadas. También puede usarse COUNT(nombre_de_columna), que devuelve el número filas afectadas en las que el valor almacenado en nombre_de_columna no es nulo.

El valor de cantidad_de_filas se guarda en una variable, por ejemplo $cantidad.

Luego, se genera un número aleatorio entre 0 y $cantidad (ejemplo en PHP)

<?php
$aleatorio = rand(0,$cantidad-1);

(se usa cantidad -1 porque el número de resultados se numera de 0 a cantidad -1, en vez de de 1 a cantidad)

Finalmente:

SELECT ..... LIMIT $aleatorio, X

Cuando X es 1, se devuelve un registro aleatorio. Cuando es mayor que 1, se devuelven X registros consecutivos, comenzando desde $aleatorio. No es lo mismo que X registros aleatorios, pero sigue siendo más rápido que el método anterior en tablas grandes.

Cuidado con los casos de borde: si la cantidad total de registros es $resultados, $aleatorio debe ser menor que $resultados-X o el índice será rebasado y solo se devolverán ($resultados - $aleatorio) filas. Por ejemplo, si el máximo ID ($resultados) es 50 y la consulta queda

LIMIT 45,10

Los resultados devueltos serán solamente 5. Hay que asegurarse de que el programa sabe manejar esta situación.

Método 3: Generando los números aleatorios con PHP

Este método requiere conocer el mayor ID de la tabla, esto se puede hacer de 3 formas (al menos):

Forma 1:
```
SELECT MAX(id) ....
```

Forma 2 (campos auto increment):

SHOW TABLE STATUS LIKE 'nombre_de_la_tabla'

Forma 3:

1 SELECT AUTO_INCREMENT
2 FROM `information_schema`.`tables`
3 WHERE
4 TABLE_SCHEMA = 'nombreBBDD' AND TABLE_NAME = 'nombreTabla'

Las formas 2 y 3 solamente funcionan con MySQL (aunque otros motores tienen métodos equivalentes). Devuelven información administrativa de la tabla, en el caso de la segunda forma se devolverá un registro en el que uno de los campos es el valor de auto-increment que se otorgará al próximo registro que se ingrese, en la tercera forma se solicita este valor explícitamente. Basta reducirlo en 1 para obtener el mayor ID actual. El problema es que puede ser que este mayor id no exista por haber sido borrado, pero por contrapartida estos métodos no necesitan leer datos de la tabla, por lo que son más rápidos.

Sea cual sea la forma, se guarda el resultado en $max.

Suponiendo que se necesiten X registros, hay que generar X números aleatorios entre 1 y $max, para luego juntarlos en una lista separada por comas:

 1 <?php
 2 $aleatorios = array();
 3 while( sizeof($aleatorios) < X )
 4 {
 5     $nuevo = rand(0, $max);
 6     if (!in_array($nuevo, $aleatorios))
 7         $aleatorios[] = $nuevo;
 8 }
 9 
10 $lista = implode(',', $aleatorios);

Y finalmente hacer la consulta:

SELECT .... WHERE id IN ($lista)

El problema es que puede ser que algunos ID no existan, por haber sido borrados. Lo que implica que puede suceder que se devuelvan menos de X registros. La solución a este problema (parcial, ya que aún puede caerse en un valor faltante) es generar más de X números (5*X, por ejemplo), dependiendo de qué tan fragmentada esté la tabla. La probabilidad dice, sin embargo, que a menos que todos los ID estén en su lugar, o se generen $max números aleatorios, siempre existe la posibilidad de que se devuelvan menos de X registros.

No estoy seguro de que sea un método realmente más rápido, aunque no es necesario un orden sí es necesario comparar el ID con cada uno de los X (o X*N) valores (a menos que se lo encuentre antes, claro). Y sigue siendo necesario comprobar en cada paso de la generación de la lista, que el valor no esté en la matriz de valores.

Conclusión

Casi siempre que se pregunta cómo obtener un registro de forma aleatoria, la respuesta es algo similar al método 1. Que si bien es simple y directo para el programador, puede hacer que la base de datos tenga que trabajar mucho más de lo debido.

En mi opinión, y sin haber hecho pruebas (basicamente por no tener una tabla real lo suficientemente grande), nada mejor que el 2ª método para obtener un registro aleatorio. El 1ª sirve para tablas pequeñas, mientras que el 3ª método es un poco menos seguro, ya que no siempre devolverá la cantidad de registros pedida si la tabla está fragmentada (tiene valores borrados) o si se utiliza una cláusula WHERE (que para el caso resulta lo mismo que tener la tabla fragmentada). Requiere algo más de trabajo con el lenguaje de programación que se utilice, aunque por otro lado evita hacer búsquedas y ordenamientos innecesarios en MySQL.

Tengo entendido que en otros SGBD como Oracle, existe un índice numérico y secuencial de todas las filas generado por el gestor. Si existe esa posibilidad, el método 3 se vuelve ideal y pierde su desventaja principal. No he podido comprobar si esto mismo existe en MySQL, y luego de bastantes búsquedas asumo que no.

Pero más allá de estos truquitos, lo importante es intentar optimizar las consultas y aprender sobre cómo trabaja el SGBD que se esté usando. Es imprescindible para una aplicación eficiente generar los índices que necesite, para evitar que el gestor tenga que buscar en la tabla completa para encontrar lo que la consulta pide. El manual de MySQL tiene una sección dedicada a esto que vale la pena leer.

Enlaces relacionados

MySQL
MySQL: Función RAND()
MySQL: Optimización de LIMIT
MySQL: Optimización de consultas
PHP: Función rand()
Wikipedia: Sistema de Gestión de Bases de Datos
Una versión anterior de este mismo artículo, alojada en Taller Webmaster

Respuestas

cleptomano, usuario de ForoCreativo, contestó lo siguiente en tallerwebmaster:

Hola, como estan…

He leido el tutorial y me parece relamente interesante que hayan tantas formas de obtener un registro aleatorio

De los tres métodos propuestos, obviamente he descartado la tercera forma, quedandome solo la primera y la segunda.

Método 1: “ORDER BY RAND()” Esta es la forma ampliamente usada, no solo en MySQL pero en muchos otros sistemas también. Se podría decir que es una solución “normal” para el problema. Sin embargo, es probablemente la forma más lenta y menos eficiente de hacerlo.

Pues no… no es la más lenta ni la menos eficiente y voy a probarlo

 1 <?php
 2 function getUser(){
 3     $result = array();
 4 
 5     // Consulta SQL
 6     $sql = "
 7     SELECT
 8         c.id_contacto,
 9         c.email
10     FROM ts_contactos AS c
11     ORDER BY RAND()
12     LIMIT 1
13     ";
14 
15     $resp = mysql_query($sql);
16 
17     if(mysql_num_rows($resp) > 0){
18         $datos = mysql_fetch_assoc($resp);
19         $result = $datos;
20     }
21 
22     return $result;
23 }
24 
25 for($i=0; $i<100; $i++){
26     $user = getUser();
27     echo "<p>Registro <strong>".($i+1)."</strong></p>";
28     print_r($user);
29     flush();
30 }

Registros devueltos en 30 segundos: 9

 1 <?php
 2 function getUser(){
 3     $result = array();
 4 
 5     // Consulta SQL
 6     $sql = "
 7     SELECT
 8         COUNT(*) AS total
 9     FROM ts_contactos AS c
10     ";
11 
12     $resp = mysql_query($sql);
13     $total = mysql_result($resp,0);
14 
15     // Consulta SQL
16     $sql = "
17     SELECT
18         c.id_contacto,
19         c.email
20     FROM ts_contactos AS c
21     LIMIT ".mt_rand(0,$total-1).",1
22     ";
23 
24     $resp = mysql_query($sql);
25 
26     if(mysql_num_rows($resp) > 0){
27         $datos = mysql_fetch_assoc($resp);
28         $result = $datos;
29     }
30 
31     return $result;
32 }
33 
34 for($i=0; $i<100; $i++){
35     $user = getUser();
36     echo "<p>Registro <strong>".($i+1)."</strong></p>";
37     print_r($user);
38     flush();
39 }

Registros devueltos en 30 segundos: 4

Las 2 pruebas la hize sobre una tabla con 780mil registros, ahora… ¿cúal es mejor?

Ante esto, mi respuesta fue:

Hola cleptomano, Soy el autor del “tutorial”, me gusta mucho ver un comentario fundamentado y que me obliga a investigar más del tema.

Creo que la frase de “peor y menos eficiente” no debería estar ahí, es una de las cosas que voy a quitar cuando edite el artículo (estoy pensando en rediseñar mi sitio y reescribir algunas cosas). Estas cosas siempre dependen de la tabla y de los datos que tenga.

Me gustaría ver, en realidad, una prueba más: ¿qué pasa si mueves el COUNT() fuera del bucle? Debería cambiar las cosas

Otra cosa que he encontrado por ahí, investigando a raíz de tu comentario, es que las tablas InnoDB no guardan (o al menos, no guardaban) un número de filas, como sí lo hace MyISAM. Por lo que el rendimiento en consultas que incluyan COUNT sin WHERE siempre requiere un ‘full table scan’, lo cual lo hace más lento. ¿Será que tu tabla es InnoDB? http://www.mysqlperformanceblog.com/2006/12/01/count-for-innodb-tables/ Este mismo artículo sugiere (en el último comentario) que se puede forzar a MySQL a utilizar un índice.

Saludos y gracias de nuevo :-)