Ya que tengo tiempo de no escribir un articulo geek y para identificarlos he creado una categoría en donde voy a poner estos artículos, la verdad es que ya hace un año me suscribí a Linux Journal y les puedo contar que es la mejor inversión que he hecho y que desde luego voy a renovar esta semana, en uno de los ejemplares esta un articulo de como explotar las reglas de udev para hacer backup, como no puedo traducirles todo el articulo de una vez este post lo pondré en varios posts.

El articulo dice lo siguiente:

udev al rescate

El udev es el moderno manejador encargado de los dispositivo para Linux, substituyendo devfs del kernel 2.4. El udev maneja todo los dispositivos, incluyendo los enchufados en caliente. Una de sus características más frescas es, él te deja escribir tus propias reglas del acontecimiento. Este artículo te demuestra cómo hacer una regla a mano, automáticamente para cuando enchufas tu USB al sistema.

Estas reglas se almacenan en /etc/udev/rules.d (si no encuentras esta carpeta porque estás utilizando otra distribución de Linux, comprueban /etc/udev/udev.conf y busca la línea udev_rules=, que debe señalar al directorio de las reglas). Puedes poner cualquier regla de udev que desees como archivos de texto en este directorio, y el udev los toma inmediatamente para el uso sin requerir el reinicio del sistema.

Cómo identificar tu dispositivo

Para escribir una regla de un evento en udev, primero necesitas una manera única de identificar el dispositivo USB. La mayoría de los pendrives tienen números de serie, aunque no todos. Afortunadamente, para los pendrives que no tienen un número de serie, tú puedes hacer las reglas del udev a mano para ellas.

Utilizo dos pendrives como ejemplos: un JetFlash JF110, cifrado con TrueCrypt, y un flash Voyager del Corsair. El JetFlash tiene un número de serie; el Corsair no.

Enchufa tu pendrive, y con un cat /proc/scsi/usb-storage/ *. Debes encontrar una entrada para ella similar a esto:

Host scsi5: usb-storage
Vendor: Unknown
Product: USB Mass Storage Device
Serial Number: 85a5b1f2c96492
Protocol: Transparent SCSI
Transport: Bulk
Quirks:

Si tienes un número de serie, salta a la sección “escritura de la regla” de este artículo. Si no ves “ninguno” para el número de serie, todavía puedes identificar el dispositivo usando udevinfo. Seguir estos pasos:

1) Mirar la salida del dmesg. La salida típica es como sigue:

usb-storage: waiting for device to settle before scanning
Vendor: Corsair Model: Flash Voyager Rev: 1.00
Type: Direct-Access
ANSI SCSI SCSI device sde: 2031616 512-byte hdwr sectors (1040 MB)
[…]
sde: assuming drive cache: write through
sde: sde1
Attached scsi removable disk sde at scsi12, channel 0, id 0, lun 0
Attached scsi generic sg4 at scsi12, channel 0, id 0, lun 0, type 0

Esto te dice que /dev/sde sea el dispositivo asignado.

2) Ahora, ejecuta esto:

udevinfo – a – p $ (udevinfo – trayectoria de q – n /dev/sde)

y examinar la salida. Debes buscar estas líneas:

BUS==»scsi»
SYSFS{model}==»Flash Voyager »
SYSFS{vendor}==»Corsair »

Escribir la regla

Ahora, con el número de serie o el vendedor/el modelo combo, puedes escribir la regla. La regla crea un link simbolico para el dispositivo en /dev, por ejemplo, /dev/corsair_drive, y después llama la escritura /usr/local/bin/backup-thumb.sh, que veremos mas adelante.

Debes convertirte en root (su -), y crea un archivo de texto en /etc/udev/rules.d llamado 95.backup.rules. Puedes utilizar un número con excepción de 95, pero tienes presente que el udev procesa reglas en orden alfanumérica, y es mejor tener reglas locales como último en el procesó.

Si tienes un número de serie, escribe una regla como esto (todos en una línea) en el archivoy grabalo:

BUS=»usb», SYSFS{serial}=»85a5b1f2c96492″, SYMLINK=»jet_drive»,
RUN+=»/usr/local/bin/backup-thumb.sh jet_drive »

Si estás utilizando el vendedor/la identificación modelo, tu regla parecería a esto:

BUS=»scsi», SYSFS{vendor}==»Corsair «, SYSFS{model}==»Flash Voyager «,
SYMLINK=»corsair_drive», RUN+=»/usr/local/bin/backup-thumb.sh
corsair_drive»

Observar que puedes encadenar tantas entradas de SYSFS {} juntas, mientras que solo necesitas identificar la impulsión únicamente. Tu regla estara disponible cada vez que enchufas tu pendrive.

Nota: si tienes otras reglas para un dispositivo, el udev ejecuta las reglas en orden de arriba hacia abajo.

Configurar el script de Backup

backup-thumb.sh es el motor que hace backup de tu pendrive. Nuestra regla lo llama, dando el nombre del dispositivo (el SYMLINK) como su solo nombrado. Todo se configura en la sección de los CONFIG. El Backup se demuestra en el listado 1.

Listado 1. Script de Backup

#!/bin/bash
# Pendrive backup script from Linux Journal
# ##############################################
# CONFIG section
# where you want the backups to be kept
BACKUP_DIR=/backups/thumb
# how many old backups to keep
GENERATIONS=7
# backup only once a day
# set to 0 if you want a backup run every time
# you insert your thumbdrive
BACKUP_ONCE_DAY=1
# completion sound to play when backup is done
SOUND=/usr/share/sounds/KDE_Beep_ClockChime.wav
# END CONFIG
# ##############################################
# main program
# wait for device to settle
sleep 10
# make sure no one will be able to copy our backups
umask 077
# check the directory
DEVICE=$1
if [ ! -d ${BACKUP_DIR} ] ; then
mkdir -p ${BACKUP_DIR}
fi
# only backup once per day
if [ ${BACKUP_ONCE_DAY} -gt 0 ] ; then
DIDTODAY=${BACKUP_DIR}/${DEVICE}.did_today
find ${BACKUP_DIR} -name ${DEVICE}.did_today -a -mtime +1 -delete
if [ -f ${DIDTODAY} ] ; then
exit
else
touch ${DIDTODAY}
fi
fi
# rotate backups
cd ${BACKUP_DIR}
let GENERATIONS=${GENERATIONS}-1
while [ ${GENERATIONS} -ge 0 ] ; do
let NEWFILE=${GENERATIONS}+1
if [ -f ${DEVICE}.backup.${GENERATIONS} ] ; then
mv -f ${DEVICE}.backup.${GENERATIONS}
${DEVICE}.backup.${NEWFILE}
fi
let GENERATIONS=${GENERATIONS}-1
done
# do the backup
dd if=/dev/${DEVICE} of=${BACKUP_DIR}/${DEVICE}.backup.0 > /dev/null 2>&1
# notify that we’re done
aplay ${SOUND} > /dev/null 2>&1

Pon este script en /usr/local/bin/backup-thumb.sh, y recuerda el chmod +x para convertirlo en ejecutable. Después, corregir la sección de los CONFIG — los parámetros son como sigue:

* BACKUP_DIR: donde quisieras que fueran los backups.
* GENERATIONS: cuántos días del backup deseas guardar. Los backups serán numerados 0 (el más reciente) al límite que introdujiste (el más viejo). Tener presente que necesitas tener mucho espacio de almacenaje para muchos backups. Si estás sosteniendo un 1GB y los GENERATIONS del sistema a 7, los backups consumirán 7GB del espacio.
* BACKUP_ONCE_DAY: si conectas y desconectas varias veces al día, no desearás hacerle backup cada vez que lo conectes. backup-thumb.sh utiliza una etiqueta en el archivo de modo que haga backup solamente una vez por día. Si deseas cambiar esto, y así hacer un backup cada vez que conectes tu pendrive, debes fijar BACKUP_ONCE_DAY a 0.
* SONIDO: en este ejemplo, he elegido un sonido de KDE, pero cualquier archivo de WAV trabajará. Puedes modificar fácilmente el script para utilizar madplay en vez de aplay y para utilizar un archivo MP3 como tu sonido cuando el backup alla terminado.

En la proxima entrega les incluire la parte de como es que funciona esto.