Descompresión de ficheros automática en Linux con bash

Hola a todos; hoy primer día de Verano, quiero traeros un pequeño script diseñado para "vagos" que no quiere recordar toda la sintaxis relacionada con la descompresión de archivos. Existen numerosos formatos de compresión y a veces el recordarlo todos puede resultar difícil; especialmente cuando trabajamos con ficheros basados en tar; obligándonos a consultar por Internet u otras fuentes la sintaxis de descompresión correcta. ¿Pero para qué tener que recordar dicha sintaxis cuando podemos hacer que un script o servicio lo haga por nosotros? Es por eso que trasteando un poco finalmente he creado una pequeña solución que puede facilitarnos considerablemente dicha tarea; en este caso en concreto he creado un demonio (un servicio) que descomprima automáticamente un fichero. Si bien podemos hacer que simplemente sea un script que se ejecute únicamente cuando queremos.

Para ello lo primero que he creado ha sido el script que inicializará y detendrá el demonio; un script que incluiremos en el directorio /etc/init.d para que, en caso de ser necesario, se inicializará automáticamente el arranque. A dicho script lo he llamado demonio_dcompres.sh y tendría el siguiente contenido:

1. #!/bin/bash
2. ### BEGIN INIT INFO
3. # Provides:          dcompres
4. # Required-Start:    $network $named $remote_fs $syslog
5. # Required-Stop:     $network $named $remote_fs $syslog
6. # Default-Start:     2 3 4 5
7. # Default-Stop:      0 1 6
8. # Short-Description: dcompres
9. # Description:       Descompresor automatico
10. ### END INIT INFO
12. PIDFILE=/tmp/dcompres.pid
13. SRV="dcompres"
14. function status()
15. if [ -f ${PIDFILE} ];
16. then
17.         echo "${SRV}  esta en marcha"
18. else
19.         echo "${SRV} esta parado"
20. fi
21. function start(){
22.  echo -n $"Iniciando servicio ${SRV}: "
23.  /usr/bin/dcompres >/dev/null 2>&1 &
24.  RETVAL=$?
25.  echo $! > $PIDFILE
26.  if [ ${RETVAL} -eq 0 ];
27.  then
28.         echo "Se ha iniciado ${SRV}"
29.  else
30.         echo "No se ha podido iniciar ${SRV}"
31.  fi
32.  echo
33. }
34. function stop(){
35.  echo -n $"Parando servicio ${SRV}... "
36.  SERV=$(ps -e |grep ${SRV} |awk '{print $1}')
37.  kill -9 ${SERV}
38.  echo "Servicio detenido"
39. }
40. function restart(){
41.  stop
42.  sleep 10
43.  start
44. }
45. case "$1" in
46. start)
47.  start
48.  ;;
49. stop)
50.  stop
51.  ;;
52. restart)
53.  restart
54.  ;;
55. status)
56. status
57. ;;
58. *)
59.  echo $"Usar: $0 {status|start|stop|restart}"
60.  exit 1
61. esac
62. exit 0

Si observáis bien, este script controla otro llamado /usr/bin/dcompres, script que controlaremos como un servicio gracias a este script añadido en init.d. Dicho script puede ser más o menos complicado dependiendo de nuestras necesidades; en este caso he creado un script bastante completo que intenta contemplar diferentes posibilidades, que sería el siguiente

1. #!/bin/bash
3. #BUCLE INFINTO HASTA QUE LO PAREMOS
4. ACTIVE='y'
5. DIRECTORIO='/home/ivan/Descargas/'
6. while [ ${ACTIVE} == 'y' ];
7. do
8.         cd $DIRECTORIO
9.         ls $DIRECTORIO |grep ".tar" > /tmp/descom.txt
10.         ls $DIRECTORIO |grep ".bz2" >> /tmp/descom.txt
11.         ls $DIRECTORIO |grep ".gz" >> /tmp/descom.txt
12.         ls $DIRECTORIO |grep ".rar" >> /tmp/descom.txt
13.         ls $DIRECTORIO |grep ".zip" >> /tmp/descom.txt
14.         while read FICHERO
15.         do
16.                 FICHERO2=`echo $FICHERO | sed 's/ /_/g'`
17.                 if [ "$FICHERO" != "$FICHERO2" ];
18.                 then
19.                         mv "$FICHERO" $FICHERO2
20.                 fi
21.                 #TAR
22.                 if [ $(ls $DIRECTORIO$FICHERO2 | rev | cut -d'.' -f 1 | rev) == "tar" ];
23.                 then
24.                         tar -xvf $FICHERO2
25.                         rm ${FICHERO2}
26.                 #BZ2 Y TAR.BZ2
27.                 elif [ $(ls $DIRECTORIO$FICHERO2 | rev | cut -d'.' -f 1 | rev) == "bz2" ];
28.                 then
29.                         if [ $(ls $DIRECTORIO$FICHERO2 | rev | cut -d'.' -f 2 | rev) == "tar" ];
30.                         then
31.                                 tar -xjf  $FICHERO2
32.                         else
33.                                 bzip2 -d $FICHERO2
34.                         fi
35.                         rm ${FICHERO2}
36.                 #GZ Y TAR.GZ
37.                 elif [ $(ls $DIRECTORIO$FICHERO2 | rev | cut -d'.' -f 1 | rev) == "gz" ];
38.                 then
39.                         if [ $(ls $DIRECTORIO$FICHERO2 | rev | cut -d'.' -f 2 | rev) == "tar" ];
40.                         then
41.                                 tar -xzf  $FICHERO2
42.                         else
43.                                 gzip -d $FICHERO2
44.                         fi
45.                         rm ${FICHERO2}
46.                 #RAR
47.                 elif [ $(ls $DIRECTORIO$FICHERO2 | rev | cut -d'.' -f 1 | rev) == "rar" ];
48.                 then
49.                         rar -x $FICHERO2
50.                         rm ${FICHERO2}
51.                 #ZIP
52.                 elif [ $(ls $DIRECTORIO$FICHERO2 | rev | cut -d'.' -f 1 | rev) == "zip" ];
53.                 then
54.                         unzip $FICHERO2
55.                         rm ${FICHERO2}
56.                 fi
57.         done < /tmp/descom.txt
58. done

En este script hay un par de puntos "especiales" que en mi opinión merecen la pena ser mencionados. El primer punto sería el uso de la variable FICHERO2 con sed. Por si no encontraseis dicha línea os la pondré a continuación:

1. FICHERO2=`echo $FICHERO | sed 's/ /_/g'`
2. if [ "$FICHERO" != "$FICHERO2" ];
3. then
4.     mv "$FICHERO" $FICHERO2
5. fi

Esta acción tiene un motivo en concreto. Imaginemos que el fichero comprimido que tenemos en el directorio contiene espacios; dichos espacios no dejará trabajar con el fichero adecuadamente, así que lo primero que haríamos sería transformar los espacios en blanco en _. Obviamente, revisaríamos si el fichero tendría espacios para evitar renombrar el fichero en vano; he ahí el motivo del if. El comando de sustitución tiene la sintaxis:

FICHERO_NUEVO=`echo $FICHERO_ORIGINAL | sed 's/CADENA_ORIGINAL/CADENA_NUEVA/g'`

Otro punto que a tener en cuenta en el que probablemente os habréis fijado es que hago uso del parámetro |rev en las condiciones introducidas. El uso de dicho rev es debido a que con ello nos aseguraremos que siempre contará los puntos desde el final del fichero y no desde el principio; puntos que uso en este script como referencia para obtener el tipo de compresión (zip, tar, rar...). Esto es debido a que existen muchos ficheros que contienen la versión junto con su nombre (ejemplo nmap-7.12.tar.bz2) y siempre querremos asegurarnos que contaremos el último o penúltimo punto (dependiendo de nuestra necesidad), independientemente de los puntos que hayamos encontrado antes. La sintaxis sería:

ls fichero | rev | cut -d'.' -f (número_posición_desde_el_final) | rev

Si pusiésemos un 1, haríamos referencia a la última posición, mientras que con un 2 haríamos referencia a la penúltima y así sucesivamente...

Con esto tendríamos un script muy sencillo y funcional que hará que las dificultades de una tarea de descompresión, sean tareas del pasado.

Espero que os haya resultado útil.

Saludos.