Lo primero que pensé fue en utilizar el comando cut de forma que el fichero de configuración tuviera un formato de etiqueta=valor, y podría “cortar” para leer la etiqueta y el valor. Pero es mala cosa, porque por cada línea del fichero de configuración tienes que cortar y luego saber qué etiqueta es. La mejor solución, el comando source

Suponemos un fichero de configuración config.ini como este:

PATTERN="$hello*"
FILENAME=hello.txt
OUTPUT=result.txt

Y queremos que nuestro script lea estas variables y ejecute grep

#!/bin/bash
source config.ini

grep ${PATTERN} ${FILENAME} > ${OUTPUT}

El comando source importara todas las variables del fichero de configuración config.ini en nuestro script y prodremos utilizarlas para lanzar grep. También podemos sustituir el comando source por un . (un punto) así:

. config.ini

También podemos importar otros script con sentencias de control (if-else) pero hay que tener cuidado porque si el script que importamos contiene el comando exit el programa finalizará en ese punto. Por ejemplo, importamos el siguente trozo de código:

config.sh

#!/bin/bash
HELLO=world
exit

Y lo utilizamos en este:

parent.sh

#!/bin/bash
source config.sh
echo ${HELLO}

Cuando lanzamos el script ./parent.sh terminará antes de llegar a la línea de echo porque ha leído el exit

Espero que este pequeño truco os de una idea de como utilizar el comando source para importar fichero de configuración dentro de vuestros scripts

Es una traducción de este truco en linux.byexamples.com

$ notify-send "el comando $0 ha finalizado"

Así puedes relajarte y ver las ultimas novedades de tus feeds mientras esperas que las máquinas sincronicen o termine de compilar el nuevo Kernel de Linux.

Podemos añadir opciones en la lista de comandos, como la prioridad del mensaje, el icono que aparece, el tiempo que se muestra, etc

Para instalarlo,

# apt-get install libnotify-bin

Y a jugar!

En Python también disponemos de un sistema de notificaciones a través del módulo pynotify que es igual sólo que, tenemos que escribir un poco más en el código y se ve así,

if pynotify.init("program name"):
  n = pynotify.Notification("Programa terminado")
  n.show()
else:
  print "there was a problem initializing the pynotify module"

Se inicializa la clase y se van añadiendo los atributos que correspondan, como en el caso anterior, la prioridad, el icono y el tiempo de exposición. Tenemos la posibilidad de contar con un control de errores por si algo falla no muestre una fea traza de llamadas.

Para instalarlo,

# apt-get install python-notify

Y a notificar xD

La sintaxis como sigue:

command -v $COMANDO 

Un ejemplo:

$ command -v cp
/bin/cp

Ahora uno que no existe

$ command -v prueba
$ $?
1

Vemos como responde con la ruta al ejecutable en éxito y pone a 1 el flag de error cuando no existe. ¿Cómo lo usamos en un script? Muy fácil

Lo primero que necesitamos es una variable CMDLIST donde listamos los comandos que necesitamos

CMDLIST="ls cp nmap echo cat";

y creamos un bucle para comprobar que existen o salimos con algún mensaje de error que indique que comando falta.

for i in $CMDLIST
do
  command -v $i >/dev/null && continue || { echo "$i command not found."; exit 1; }
done

Dependiendo de la funcionalidad del script, el echo de comprobar que todos los elementos están nos puede ahorrar algún disgusto como perdida de datos o de tiempo ya que en el peor de los casos, el comando que falta puede ser el último de un programa de lotes que tarde varias horas en completarse.

Pues bien, apoyandome en el demonio Incron, he creado un sistema para notificar por correo electrónico a mi lusers cada novedad. El problema es que incron no implementa todavía la recursividad sobre subdirectorios, así que hay que supervisar cada uno por separado.

Este es el contenido:

bigBangTheory            Dollhouse           House          Mental               Numbers         RobinsonCrusoe    TheBeast
Bones                    EntreFantasmas      Hung           MentesCriminales     Olvidados       RomaCriminal      TheITCrowd
cocheFantastico          Eureka              incoming       Mercy                PadreDeFamilia  SamanthaWho       TheListener
ComoConociAVuestraMadre  EverybodyHateChris  kyle           Mienteme             pelisVistas     scrubs            TorchWood
csi                      FlashForward        LaPeceraDeEva  Monk                 Psych           siesta            Trauma
Deadwood                 Greek               Life           MP3s                 Reaper          Simpson           TrueBlood
Dexter                   Heroes              LifeOnMars     MujeresDesesperadas  Ritchies        StargateAtlantis  videosChicos
Docus                    Historicas          meLlamoEarl    MyOwnWorstEnemy      RobinHood       supernatural      Weeds

Escribir una línea de incrontab para cada uno es algo que no estaba dispuesto a hacer, así que se recurre a find y awk.

find /mnt/almacen/Media/ -maxdepth 1 | awk '{ print $1 " IN_MOVED_TO /home/nordri/bin/incron/nuevoMedio.py $@ $# " }'

Este comando, que debemos redireccionar a un fichero, nos mostrará esto:

[...]
/mnt/almacen/Media/Mienteme IN_MOVED_TO /home/nordri/bin/incron/nuevoMedio.py $@ $#
[...]

Que creara un monitor para el directorio, en caso que algún fichero sea movido dentro del directorio, ejecutará el comando nuevoMedio.py con los parametros $@ y $# que son la ruta completa y el nombre del archivo.

Existen, también dos detalles, uno es el directorio históricas donde guardo las series finalizadas, canceladas y discontinuadas. Esto es porque me gusta saber que series he seguido. El otro detalle, es supervisar la raíz de Media para avisar en caso que se añada una nueva serie. Las líneas que hay que añadir al incrontab son las siguientes.

/mnt/almacen/Media/Historicas IN_MOVED_TO /home/nordri/bin/incron/nuevoHistorico.py $#
/mnt/almacen/Media IN_CREATE /home/nordri/bin/incron/nuevoDirMedio.py $#

Bien, pasemos a la programación, todos los scripts son en el básico Python que manejo, pero que resulta útil para estas cuestiones. El script nuevoMedio.py

import avisoPorEmail
import sys
def getCategoria(t):
  c = t.split("/")
  l = len(c)
  return c[l-1]
categoria  = getCategoria(sys.argv[1])
email = open("/tmp/email", "w")
email.write("En la categoria : " + categoria + "\n\nSe ha compartido un nuevo archivo multimedia: \n\n" + sys.argv[2] + "\n\n enjoy  ")
email.close()
asunto = "Nuevo archivo multimedia"
direcciones = [ #direcciones# ]
avisoPorEmail.mail('/tmp/email', asunto, direcciones, 'txt')

Simplemente, recibe la ruta del directorio compartido, elimina las barras y nos quedamos el nombre de la serie, que será la categoría, el segundo parámetro es el nombre del archivo, que lleva consigo el episodio, y todo lo que los uploaders le añaden para autopromocionarse. Se escribe la cadena en un archivo y se manda por correo a las direcciones que se le indican en el array. Hay que avisar a los usuarios que miren en spam por si acaso. A mi me pasa.

Los scripts de nuevoDirMedio.py y nuevoHistorico.py son muy similares.

import avisoPorEmail
import sys
import os
categoria  = sys.argv[1]
email = open("/tmp/email", "w")
email.write("Se está siguiendo una nueva serie : " + categoria + "\n\n enjoy  ")
email.close()
asunto = "Nueva Serie"
direcciones = [ #direcciones# ]
# Dar de alta el nuevo directorio en incron
os.system('/home/nordri/bin/incron/nuevoDirVigilado.sh ' + categoria)
avisoPorEmail.mail('/tmp/email', asunto, direcciones, 'txt')

Prácticamente igual, la peculiaridad aquí está en que si creamos un nuevo directorio, debemos dar de alta el monitor para incron. Para ello utilizo el siguiente script.

echo "/mnt/almacen/Media/$1 IN_MOVED_TO /home/nordri/bin/incron/nuevoMedio.py \$@ \$#" > /tmp/tareaIncron.txt
incrontab -l >> /tmp/tareaIncron.txt
incrontab /tmp/tareaIncron.txt

Simple, no? Se escribe la tarea en un archivo auxiliar, se anexa el contenido del incrontab actual y se recarga usando el archivo auxiliar como base.

El último es para cuando una serie se pasa al histórico, así,

import avisoPorEmail
import sys
def getCategoria(t):
  c = t.split("/")
  l = len(c)
  return c[l-1]
categoria  = getCategoria(sys.argv[1])
email = open("/tmp/email", "w")
email.write("La serie : " + categoria + "\n\nHa sido cancelada o discontinuada. Perdone las molestias")
email.close()
asunto = "Serie abandonada"
direcciones = [ #Direcciones# ]
avisoPorEmail.mail('/tmp/email', asunto, direcciones, 'txt')

Pues bien, cada vez que algo se mueva del incoming del Torrent a su directorio se avisará a los usuarios con un correo electrónico.

http://www.muspells.net/unarchivo.tar.gz

La gente lo iba descargando, pero quería mirar cuan curiosos eran, como pasé la URL directa del archivo al darle click ya empieza la descarga. Así que me preguntaba cuantos de ellos borraron unarchivo.tar.gz y entraron a la dirección del sitio.
Para ello, filtre las peticiones al archivo.

# grep unarchivo.tar.gz access.muspells.net.log | cut -d" " -f1 | sort | uniq 

Obteniendo una lista como esta:

88.55.66.33
77.5.47.5
...

La lista es un ejemplo, obviamente, me salían 29 IP’s únicas, ahora hay que cruzar los datos con las visitas a páginas legítimas del blog. Así

IPS=$(grep unarchivo.tar.gz access.muspells.net.log | cut -d" " -f1 | sort | uniq)
for IP in $IPS
do
grep $IP access.muspells.net.log | grep -v unarchivo.tar.gz | cut -d" " -f1 | sort | uniq
done

Que nos da una lista con 9 direcciones IPs que son las personas que han descargado el archivo y han visitado alguna otra página.
Esta estadística es chapucera, pero conociendo el tráfico que tiene el servidor y como son mis amigos, es muy fiable. Nos da que el 36% de mis amigos son curiosos en tecnología.
Ahora voy a contar los que van a intentar descargar unarchivo.tar.gz dando el correspondiente 404.