Aquí les dejo un script que me ayuda a mi a respaldar mi librería de música desde mi laptop a mi NSLU2 que por cierto esta a unas 30 millas (48 kilómetros) de distancia. El script usa Rsync sobre SSH. Démosle un vistazo a este script al cual he salvado como rsync_itunes.sh.

#!/bin/bash
#rsync -avx --delete --exclude='iTunes/iTunes\ Media/Movies/*' --progress ~/Music/iTunes -e "ssh -p22" usuario.aqui@host.remoto.aqui:~/
#rsync -avx --progress ~/Music/iTunes -e "ssh -p22" usuario.aqui@host.remoto.aqui:~/
rsync -avx --delete --progress ~/Music/iTunes -e "ssh -p22" usuario.aqui@host.remoto.aqui:~/

Como pueden ver tengo dos lineas comentadas las cuales las descomento de acuerdo con lo que quiera hacer. La primera omite el directorio ‘Movies’. La segunda no borra los archivos que he eliminado de iTunes o que ya no están en esa ubicación. La ultima que es la que no esta comentada borra y sincroniza la librería entera. Noten que -e “ssh -p22″ le dice a Rsync que va a ejecutar SSH por el puerto 22, útil en caso de que engan SSH corriendo en otro puerto.

Yo en particular lo tengo en ~/scripts y lo ejecuto así:
cd ~/
sh scripts/rsync_itunes.sh

Respaldar iTunes a un servidor remoto con Rsync es un articulo de: orvtech.com

Un proceso zombi es un proceso que ha completado su ejecución pero aun tiene una entrada en la tabla de procesos. Esta entrada aun es necesitada para permitir la lectura del estado de su estado de salida. El Termino zombi se deriva de la definición de un muerto viviente (se acuerdan de esa película?). Para ponerlo en términos simples y un poco mas técnicos, un proceso hijo ha terminado pero aun no se ha eliminado de la tabla de procesos y el comando kill no tiene efectos sobre él.

Identificarlos es fácil, podemos ejecutar el comando ps y buscamos cuales procesos tienen una “z” en la columna “STAT“. Los procesos zombi que permanecen por un periodo mas que corto por lo general es señal de un Bug en el proceso padre. Ahora bien, si el zombi aun existe después de que el proceso padre ha terminado esto por lo general indica un bug en el sistema operativo.

La salida de el comando top que muestra donde están los zombis

Un procesos zombi no es un problema tan grave, el problema se agrava si el computador va a ser sometido a fuertes cargas pues puede ser que se multipliquen. A pesar de que los zombis no consumen memoria un incremento acelerado de estos podría traer consecuencias a la hora de que el sistema operativo se le acaben los PID a asignar.

Una vez que el padre haya matado el zombi el proceso ID (PID) y la entrada en la tabla de procesos puede ser reutilizada, pero si este falla, el zombi permanece en la tabla de procesos.

Para eliminar un zombi del sistema, se le debe enviar la señal SIGCHLD al padre usando el comando kill. En caso de que el padre se no pueda eliminar el zombi de la tabla de procesos podríamos intentar matando el proceso padre. Algo que debemos tomar en cuenta es que cuando un proceso pierde a su padre, ‘init‘ pasar a ser su nuevo padre y este se encarga de limpiar periódicamente la tabla de procesos de los zombis cuyos padres sean init.

Los zombis podrían estar consumiendo tu procesador en este instante es un articulo de: orvtech.com

Hoy tenia la necesidad de compartir un archivo de 1,1GB con un grupo de amigos y no quería usar el ancho de banda de mi servidor por completo para esto así que decidí usar torrents. El torrent es un protocolo para compartir archivos con la peculiaridad de que todo lo que descargas por este medio, durante el transcurso de su descarga, estará siempre disponible para ser descargado por otro. Ya en el articulo “Descargas automatizadas de torrents en el NSLU2″ toque el tema de los torrents en el NSLU2, esta vez les voy a comentar un poco de como crear un torrent tracker y como crear el torrent como tal.

La internet es como una serie de tubos

El torrent tracker es la pieza clave

Un tracker es un server (en este caso mi NSLU2) que contiene la información necesaria para que los peers se conecten con otros peers coordinando la comunicación entre ellos. Los trackers son el único punto de encuentro al cual los clientes requieren conectarse para poder comunicarse y poder iniciar una descarga. En nuestro caso usaremos el que trae el kit de utilidades bittornado.
bttrack.py viene incluido con bittornado, yo use el siguiente comando con estos flags para levantar mi servicio de torrent tracker:
nohup /usr/bin/bttrack.py --port 6969 --dfile ~/dstate.txt --logfile ~/tracker.log &

Así de simple como se ve, invoco el script de python y le paso los siguientes parámetros:
–port: El puerto en el que va a escuchar.
–difile: El archivo con la información mas reciente de las descargas.
–logfile: El archivo de registros de las actividades del tracker.

El archivo *.torrent es algo mas complejo.

El archivo torrent es un poco mas complejo pero igual fácil de crear, usando btmakemetafile que también esta incluido en bittornado podemos crear el archivo tan solo con proporcionarle el hipervínculo del tracker y el nombre del archivo que queremos compartir como se puede ver aquí:
btmakemetafile.py http://orvtech.com:6969/announce --comment "http://orvtech.com/latest/torrent" guardianes_de_chavez.mp4

El parámetro –comment simplemente nos permite agregarle un comentario al torrent.

Hacerlo publico para distribuirlo

Hay muchas formas de hacerlo publico, solo basta con enviar el archivo *.torrent a las personas que queremos que descarguen el archivo, publicarlo en tu blog personal o subirlo a uno de estos sitios que sirven para buscar torrents, en mi caso use TPB el cual tiene la particularidad que toma el *.torrent que tu creaste y agrega otros 2 trackers a el ( http://tracker.thepiratebay.org/announce y http://tracker.openbittorrent.com/announce )

UPDATE Viernes Agosto 13, 2010: Un bug en el tracker.

Al parecer mi versión de bttracker no es del todo compatible con mi versión de python, y el proceso muere después de mas de un par de horas con un error referente a la incompatibilidad con el modulo SHA. Por ahora he decidido hacer un pseudo whatchdog para vigilar que el tracker este siempre arriba.
Modifique el script a esto:
while true
do if pidof -x bttrack.py > /dev/null
then sleep 2
else /usr/bin/bttrack.py --port 6969 --dfile ~/dstate.txt --logfile ~/tracker.log
fi
done

Como ven es un loop infinito que constantemente pregunta por el PID del proceso, de no encontrarlo simplemente ejecuta de nuevo el comando.Luego descargo una versión mas nueva de bittornado a ver si esto soluciona el problema.

páginas de interés:
TheShad0w’s experimental bittorrent client (BitTornado)
Pagina del proyecto bittorrent.org

Comparte un archivo via torrents con tu propio tracker es un articulo de: orvtech.com

Por ahora no he jugado mucho con el Apple TV, tan solo unos minutos esta mañana, en cuestión de minutos lo conecte al TV, prendió y logre configurar para que se conecte a la red inalámbrica de la casa. Este sera el reemplazo de mi servidor NSLU2 en un par de meses. Por su puesto no podian faltar las fotos:

Las características técnicas del equipo son:

A simple vista, mas de ocho veces la cantidad de memoria que tiene mi NSLU2 (que por cierto aloja esta pagina web), casi ocho veces mas poder de procesamiento, disco duro interno vía IDE que ya de por si es mucho mas rápido que USB 2.0, lo puedo conectar al TV y ver en HD las películas, photos, y demás contenido multimedia que descargue vía torrents. Todo esto por $108 puesto en mi casa.

AppleTV, el futuro remplazo de mi NSLU2 es un articulo de: orvtech.com

Los directorios mas importantes de NanoBlogger son data templates styles images y plugins. Anoche decidí a automatizar el respaldo de mi blog, como no tengo problemas de espacio decidí solo dejar por fuera el directorio cache. Este es el script para crear un archivo comprimido y subirlo a otro server vía SCP:

#!/bin/bash
BLOG_PATH="/path/to/the/directory/that/contains/your/blog.conf/"
BLOG_NAME="orvtech.com"
DATE=`date +%d%b%Y-h%Hm%M`
NO_BAKUP="cache/*"
SCP_SERVER=""
SCP_USER=""
SCP_PORT="22"
cd $BLOG_PATH
tar -czpsf ~/$BLOG_NAME-nanoblogger.$DATE.tar.gz --exclude "$NO_BAKUP" *
ls -lah ~/$BLOG_NAME-nanoblogger.$DATE.tar.gz
scp -P$SCP_PORT ~/$BLOG_NAME-nanoblogger.$DATE.tar.gz $SCP_USER@$SCP_SERVER:~/

Respaldar NanoBlogger es un articulo de: orvtech.com

Como dice el titulo, automatizado (gracias a cron) y con una consola para monitorear las descargas. La consola luce algo así:

Bittornado es iniciado via un script el cual lo deja corriendo dentro de una instancia de screen

Este es el script que uso para descargar torrents a horas y días pre-determinadas, es un wrapper de btlaunchmanycurses.py y lo llamo en un cronjob a distintas horas y días. Demosle un vistazo y luego hablamos de las opciones:

#!/bin/bash
DESCARGA_VELOCIDAD=1458
COMPARTE_VELOCIDAD=113
LIMPIAR_INTERVALO=5
MIN_PUERTO=27777
MAX_PUERTO=27799
TORRENTS_CARPETA="/home/TU_USUARIO_AQUI/descargas"
DESCARGAS_DESTINO="/home/TU_USUARIO_AQUI/descargas"
test -d $TORRENTS_CARPETA || mkdir -p $TORRENTS_CARPETA
test -d $DESCARGAS_DESTINO || mkdir -p $DESCARGAS_DESTINO
cd $TORRENTS_CARPETA
nice /usr/bin/btlaunchmanycurses.py $TORRENTS_CARPETA \
--saveas_style 3 \
--upnp_nat_access 0 \
--minport $MIN_PUERTO \
--maxport $MAX_PUERTO \
--max_upload_rate $COMPARTE_VELOCIDAD \
--max_download_rate $DESCARGA_VELOCIDAD \
--auto_flush $LIMPIAR_INTERVALO

Para empezar la descarga solo basta poner los *.torrent en ~/descargas/ y el script hará el resto.

saveas_style:
Que nombre le va a poner a la descarga del torrent. Acepta hasta tres valores del 1 al 3:

• 1= Lo renombra al nombre que el torrent especifica.
• 2= Lo salva bajo el nombre del torrent.
• 3= Lo salva dentro de un directorio que tiene el nombre especificado en el torrent.

La ultima (3) es la opcion que usaremos para tener todo mas ordenado.

upnp_nat_access:
Intenta autoconfigurar un puerto UPnP en el router para que le haga foward al server. En mi caso uso la primera opción que lo deshabilita. Pero aquí tienen la lista completa de opciones:

• 0= deshabilitada.
• 1= modo 1, esta es rápida y es la que btlaunchmanycurses usa como predeterminada.
• 2= modo 2, esta es un poco mas lenta.

minport:
El puerto que va a usar para escuchar, en caso de que este puerto este ocupado o no este disponible, btlaunchmanycurses utilizara el siguiente puerto y así de manera sucesiva hasta llegar al maxport.

maxport:
El número de puerto máximo en el que puede escuchar, el predeterminado es el 60000.

max_upload_rate:
El máximo de ancho de banda a usar para compartir nuestros torrents, este acepta el numero máximo de kB/s o estas dos opciones:

• 0= Sin limites.
• -1= Automático.

El valor predeterminado es 0 (sin limites).

max_download_rate:
El máximo de kB/s que se pueden descargar, el valor predeterminado es 0 que indica que no tiene limites.

auto_flush:
Los minutos entre cada flush al disco, el predeterminado es 0 que indica deshabilitado.

Una opcion que Uds pueden considerar es –random_port que toma los valores 0 o 1, esta opción le dice a btlaunchmanycurses que use un puerto aleatoriamente seleccionado dentro del rango de minport y maxport.

El Cronjob.

30 0  *   *   *     /home/TU_USUARIO_AQUI/descargas/cron_torrent.sh >/dev/null 2>&1
8  8  *   *   *     /home/TU_USUARIO_AQUI/descargas/killbtlaunch.sh >/dev/null 2>&1

Como verán ejecuto dos scripts distintos, uno que levanta el torrent y otro que lo mata. veamos el primero, cron_torrent.sh:
#!/bin/bash
screen -D -m -S "torrents-nightly" /home/TU_USUARIO_AQUI/descargas/download.sh

Este a las 12:30am creara un screen de nombre torrents-nightly y dentro de ese screen ejecutara el script que discutimos arriba el cual lo llamo download.sh. El segundo script que se ejecuta a las 8:08am termina las descargas. Aquí esta el cod
igo fuente de killbtlaunch.sh:
#!/bin/bash
for X in `ps ax | grep -i -E 'btlaunchmanycurses|bittornado|irssi|torrents-nightly' | grep -v grep |awk '{print $1}'`
do kill -9 $X
done

Descargas automatizadas de torrents en el NSLU2 es un articulo de: orvtech.com

No hace mucho publique dos scripts para obtener el código BBCode a partir de la URL de un álbum de Picasa o de un set de flickr, luego de jugar un poco logre unirlos en un CGI hecho en BASH. pueden ojearlo en esta URL:
http://orvtech.com/album2bbcode.cgi

El script primero evalua si la URL es de picasa o flickr, luego procede a diseccionar la data del REQUEST_URI a el script que le toque dependiendo de si es de Flickr o si es de Picasa. El CGI puede ser mejorado, actualmente no controlo si los servidores de flickr o picasa devuelven un Status distinto a 200. También se podría implementar un método de cache o regular el acceso (hacerle throtle).

El código base del CGI es el siguiente:

#!/bin/bash
echo "Content-type: text/html"
echo -e "Status: 200 \n"
GET_DATA=`env | grep REQUEST_URI |sed -e 's/\?/\ /g' | awk '{print $2}'`
ALBUM_DATA=`echo "$GET_DATA" | sed -e 's/%3A/\:/g' -e 's/%2F/\//g' -e 's/\&/ /g' |grep -i -E 'http\:\/\/picasaweb\.google\.com\/[a-z 0-9]?.*/[a-z 0-9]?|http://(www\.)*flickr.com/photos/.*/sets/[0-9]?*[0-9]'`
SIZE=`echo "$GET_DATA" | sed -e 's/%3A/\:/g' -e 's/%2F/\//g' -e 's/\&/ /g' |grep [0-9][0-9]px| sed -e 's/\=/ /g'| awk '{print $4}'`
if `echo $ALBUM_DATA | grep -i -q -E 'http\:\/\/picasaweb\.google\.com\/[a-z 0-9]?.*/[a-z 0-9]?'`
then
ALBUM_TYPE="picasa"
else
if `echo $ALBUM_DATA | grep -i -q -E 'http://(www\.)*flickr.com/photos/.*/sets/[0-9]?*[0-9]'`
then
ALBUM_TYPE="flickr"
else
ALBUM_TYPE="unknown"
fi
fi
echo "
<html>
<body>
<table>
<tr>
<td>
<b>Album o Set URL:</b>
<form method=get action=\"/album2bbcode.cgi\"><input type=text name=albumoset />
</td>
<td>
<select name=\"SIZE\">"
for X in 640px 144px 288px 320px 400px 512px 576px 800px 1024px
do echo "<option value=\"$X\"> $X </option>"
done
echo "</select>
</td>
</tr>
<tr colspan=2><td>
<input type=submit>
</td></tr></table>
</form>"
echo -e "<b>Album:</b> <i>$ALBUM_DATA</i>" | sed -e 's/=/ /g'
echo "<br />< textarea class=\"bashcode\" style=\"width: 700px; height: 280px;\">"
if [[ "$ALBUM_TYPE" == picasa ]]
then
PICASA_DATA=`echo -e " $ALBUM_DATA"|sed -e 's/=/ /g'|awk '{print $2}'`
echo -e " $PICASA_DATA" | curl -s `awk -F / '{print "http://picasaweb.google.com/data/feed/api/user/"$4"/album/"$5}'` | sed -e 's/\"/\ /g' -e s/\'/\ /g | tr ' ' '\n' | grep 's72' | awk '{print "[url='$PICASA_DATA'][img]"$0"[/img][/url]\n"}' | sed s/s72/s$SIZE/g
fi
if [[ "$ALBUM_TYPE" == flickr ]]
then
FLICKR_DATA=`echo $ALBUM_DATA |sed -e 's/=/ /g'| awk '{print $2}'`
curl -s `echo $FLICKR_DATA`| tr ' ' '\n' | grep '_s.jpg' | sed "s/\"/\ /g" |sed -e 's/_s\.jpg/\.jpg/g'| awk '{print "[url='$FLICKR_DATA'][img]"$2"[/img][/url]\n"}'
fi
if [[ "$ALBUM_TYPE" == unknown ]]
then
UNKNOWN=`echo -e " $ALBUM_DATA"|sed -e 's/=/ /g'|awk '{print $2}'`
echo "Hasta ahora solo soportamos Flickr y Picasa. Lo que Ud. introdujo $UNKNOWN no parece ser de ninguno de estos.
*El formato de URL para los sets de flickr es:
http://www.flickr.com/photos/USUARIO/sets/SET/
*El formato de URL para los álbum de Picasa es:
http://picasaweb.google.com/USUARIO/ALBUM"
fi
echo "</ textarea><br />"
echo "</ body></ html>"

CGI para obtener el BBCode de Flickr y Picasaweb hecha en BASH. es un articulo de: orvtech.com

@POTUSCamacho tiene un articulo interesante acerca de como usar el NSLU2 en conjunto con un adaptador USB de bluetooth como un servidor de audio. POTUSCamacho explica como hacerlo usando un adaptador con audio ‘mono’ pero aclara que debería de ser posible lograr lo mismo usando uno estéreo.

Echemosle un vistazo a esta guia.

Una vez que ya se tenga el firmware de Ubuntu instalado en el NSLU2, podemos hacer login y actualizar nuestros paquetes.

sudo -i apt-get update

Luego instalamos los siguientes paquetes:

sudo -i apt-get install linux-sound-base bluetooth bluez bluez-alsa bluez-btsco bluez-compat bluez-utils python python-bluez vlc

Nota: Yo hago bastante desarrollo en mi NSLU2 así que puede ser que falte algún paquete aquí.


Ahora que ya tenemos los paquetes que necesitavamos instalados, crearemos el archivo .asoundrc en nuestro directorio home. Aquí un ejemplo:

pcm.bluetooth {
type bluetooth
device 00:00:00:00:00:00
}

Editamos la sección del dispositivo para poner el MAC address de nuestros audífonos bluetooth. Para conseguir esta MAC address puedes resetear el adaptador ejecutando el comando:

hciconfig hci0 reset

Luego configura tus audífonos para que estén en modo ‘pairing’ y ejecuta el siguiente comando:

sdptool browse

Ahora copia el siguiente script hecho en python en un archivo que se llame pair.py

#!/usr/bin/python

import gobject

import sys
import dbus
import dbus.service
import dbus.mainloop.glib

class Rejected(dbus.DBusException):
_dbus_error_name = "org.bluez.Error.Rejected"

class Agent(dbus.service.Object):
exit_on_release = True

def set_exit_on_release(self, exit_on_release):
self.exit_on_release = exit_on_release

@dbus.service.method("org.bluez.Agent",
in_signature="", out_signature="")
def Release(self):
print "Release"
if self.exit_on_release:
mainloop.quit()

@dbus.service.method("org.bluez.Agent",
in_signature="os", out_signature="")
def Authorize(self, device, uuid):
print "Authorize (%s, %s)" % (device, uuid)
authorize = raw_input("Authorize connection (yes/no): ")
if (authorize == "yes"):
return
raise Rejected("Connection rejected by user")

@dbus.service.method("org.bluez.Agent",
in_signature="o", out_signature="s")
def RequestPinCode(self, device):
print "RequestPinCode (%s)" % (device)
return raw_input("Enter PIN Code: ")

@dbus.service.method("org.bluez.Agent",
in_signature="o", out_signature="u")
def RequestPasskey(self, device):
print "RequestPasskey (%s)" % (device)
passkey = raw_input("Enter passkey: ")
return dbus.UInt32(passkey)

@dbus.service.method("org.bluez.Agent",
in_signature="ou", out_signature="")
def DisplayPasskey(self, device, passkey):
print "DisplayPasskey (%s, %d)" % (device, passkey)

@dbus.service.method("org.bluez.Agent",
in_signature="ou", out_signature="")
def RequestConfirmation(self, device, passkey):
print "RequestConfirmation (%s, %d)" % (device, passkey)
confirm = raw_input("Confirm passkey (yes/no): ")
if (confirm == "yes"):
return
raise Rejected("Passkey doesn't match")

@dbus.service.method("org.bluez.Agent",
in_signature="s", out_signature="")
def ConfirmModeChange(self, mode):
print "ConfirmModeChange (%s)" % (mode)

@dbus.service.method("org.bluez.Agent",
in_signature="", out_signature="")
def Cancel(self):
print "Cancel"

def create_device_reply(device):
print "New device (%s)" % (device)
mainloop.quit()

def create_device_error(error):
print "Creating device failed: %s" % (error)
mainloop.quit()

if __name__ == '__main__':
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)

bus = dbus.SystemBus()
manager = dbus.Interface(bus.get_object("org.bluez", "/"),
"org.bluez.Manager")

if len(sys.argv) > 1:
path = manager.FindAdapter(sys.argv[1])
else:
path = manager.DefaultAdapter()

adapter = dbus.Interface(bus.get_object("org.bluez", path),
"org.bluez.Adapter")

path = "/test/agent"
agent = Agent(bus, path)

mainloop = gobject.MainLoop()

if len(sys.argv) > 2:
if len(sys.argv) > 3:
device = adapter.FindDevice(sys.argv[2])
adapter.RemoveDevice(device)

agent.set_exit_on_release(False)
adapter.CreatePairedDevice(sys.argv[2], path, "DisplayYesNo",
reply_handler=create_device_reply,
error_handler=create_device_error)
else:
adapter.RegisterAgent(path, "DisplayYesNo")
print "Agent registered"

mainloop.run()

#adapter.UnregisterAgent(path)
#print "Agent unregistered"

Ahora pon tus audífonos en modo ‘pairing’ de nuevo y ejecuta este comando:

sudo -i python pair.py hci0 00:00:00:00:00:00

Una vez mas, recuerda remplazar el MAC address con el de tus audífonos.
El ultimo paso involucra editar el vlcrc, para hacer esto puedes ejecutar:

pico .vlc/vlcrc

Recorre el archivo y remplaza:

alsadev=(default soundcard)

Por:

alsadev=bluetooth

Si el archivo no existe, entonces créalo:

A este punto ya deberías de poder escuchar en tus audífonos. Para escuchar el audio de NASA TV (video online), puedes ejecutar:

cvlc --aout-rate 8000 --novideo http://www.nasa.gov/55644main_NASATV_Windows.asx

Si todo esta bien, deberías de escuchar el audio. Cuando ejecutando estos comandos, recuerda el el sample rate debe de ser de 8000Hz ya que esto es lo que los audífonos soportan.

Para configurar otros audífonos o re-conectar los actuales, el archivo /var/lib/bluetooth/<tu MAC address>/linkkeys debe de ser eliminado. Este se re-creara una vez que el dispositivo se vuelva a conectar. Si conectas otros audífonos, también debe de editar el archivo .asoundrc

Para mas información, no dudes en visitar el blog de POTUSCamacho Industries.

Audio via bluetooth desde el nslu2 es un articulo de: orvtech.com

Con leves modificaciones a el plugin galleries de NanoBlogger logre generar imágenes miniaturas cuadradas manteniendo la proporción.

El script modificado del plugin de galleries para nanoblogger produce miniaturas cuadradas sin distorcionar

Modifique el plugin para generar imágenes en formato GIF que tienen menor tamaño y por lo tanto consumen menos ancho de banda que jpeg o png. La modificación para que genere *.gif lo hice por aligerar la carga de mi NSLU2 ya que esta sirviendo paginas a través de una conexión de 1024Kbps que además comparto.

Básicamente lo que hago es determinar si la imagen es postal o panorámica para saber como le voy a hacer el ajuste de tamaño, para esto uso el comando identify y filtro un poco la salida del comando, quedaría algo así:

/usr/bin/identify `echo $GALLERY_DIR"/"$PICTURE` |\
awk '{print $3}' |\
sed -e 's/x/ /g'

Luego procedo a centrar la imagen y cortarla en base al lado mas corto. de allí simplemente se le ajusta el tamaño al deseado y continuo con el resto del plugin.

Puedes descargar el plugin modificado de aquí, este plugin esta optimizado para el NSLU2 corriendo Debian 2.6.18-6-ixp4xx e ImageMagick 6.2.4.

Thumbnails cuadradas en plugin galleries.sh de NanoBlogger. es un articulo de: orvtech.com

A raíz de la migración de apache a lighttpd he tenido algunos problemitas por resolver, El primero seria el redireccionamiento de /latest sin usar archivos htaccess. En esta oportunidad apuntaremos el directorio /latest y todo lo que este adentro a nuestro CGI hecho en BASH, con la ayuda de lighttpd redireccionaremos todas las peticiones a la entrada mas reciente de nuestro blog que esta corriendo NanoBlogger.

El script (ultimas.cgi) luce así:

#!/bin/bash
DocummentRoot="/var/www/orvtech.com/htdocs"
Latest=`cat $DocummentRoot/rss.xml | grep link | grep archives | head -n1 | sed -e :a -e 's/< [^>]*>//g;/

Para poder ejecutar nuestro script como un CGI necesitamos habilitar mod_cgi en nuestra configuración y agregar las siguientes linea a nuestro VirtualHost:

cgi.assign = ( ".cgi" => "/bin/bash" )
url.redirect =( "^/latest/(.*)" => "http://orvtech.com/ultimas.cgi")


La ultima linea es en caso de que ya tengamos nuestra firma así en varios foros, en mi caso lo uso mas que todo para registro en los logs y poder contabilizar desde donde me vienen mas hits, por ejemplo, pongo links como http://orvtech.com/latest/meneame luego en los logs se que todo lo que tenga ‘meneame’ viene de meneame.net sin importar que este o no recibiendo el header de ‘referrer’

Un CGI en BASH para mantener tu firma al dia en todos los foros en que participas. es un articulo de: orvtech.com