A continuación voy a poner algunos snippets de código de shell script que me han sido siempre útiles cuando escribo algún script. La mayoríá funcinoan en cualquier shell de Unix, aunque algunos requieren que sean ejecutados por Bash.

Evitar que usuarios sin privilegios ejecuten el script

Algunos scripts realizan tareas administrativas por lo cual podríamos querer que solo el usuario root ejecute el script. En ese caso podemos usar algo como esto:

#!/bin/bash
if [[ $EUID -ne 0 ]]; then
echo "Este script debe ser ejecutado por el usuario root" 1>&2
    exit 1
fi

Permitir la ejecución del script solo a un usuario específico

De manera similar al código anterior, podríamos querer que solo un usuario específico ejecute el script. Lo hacemos así:

#!/bin/bash
AUTHORIZED_USER="usuario_permitido"
if [ $USER != $AUTHORIZED_USER ]; then
    echo "Este script debe ser ejecutado por el usuario $AUTHORIZED_USER" 1>&2
    exit 1
fi

Verificar que un servicio/proceso se está ejecutando

Si queremos saber si existen procesos de algún servicio o programa ejecutándose podríamos usar este script (en este caso verifica que el demonio de Apache esté corriendo):

#!/bin/sh
SERVICE='httpd'
if ps ax | grep -v grep | grep $SERVICE > /dev/null
then
    echo "El servicio $SERVICE esta ejecutandose"
else
    echo "Chanfle! El servicio $SERVICE esta detenido"
fi

Verificar que una variable esté asignada/tenga datos

Hay bastantes maneras de hacer esto en shell script… la que considero más sencilla y concisa es esta:

#!/bin/bash
FOO=
: ${FOO:?"No existe la variable FOO o no tiene datos"}
echo "esto nunca se va a imprimir"

El anterior script verifica si una variable existe y tiene datos; si esto no se cumple, el script se cierra. Podemos usar esta variación en donde solo comprobamos que la variable exista, sin importar si tiene datos o no:

#!/bin/bash
FOO=
: ${FOO?"No existe la variable FOO"}
echo "esto si se va a imprimir"

Crear un archivo de bloqueo

A veces debemos asegurarnos que el script no se ejecute dos o más veces simultáneas. Para ello podemos hacer uso de los archivos de bloqueo. Esta es una versión sencilla de un script que nos permite hacer esto:

#!/bin/bash
lockfile=/var/lock/loquesea.lock
if [ ! -e $lockfile ]; then
   touch $lockfile
   echo "hago muchas cosas importantes aqui"
   rm $lockfile
else
   echo "ya hay otro proceso corriendo"
fi

En este caso, se verifica que el archivo loquesea.lock exista. En caso de que exista, el script NO ejecuta sus tareas. Si no existe, crea el archivo, ejecuta las tareas que deba ejecutar y lo elimina.

Pero, esto no es del todo fiable. ¿Qué pasaría si mientras nuestro script se está ejecutando es cerrado abruptamente (con Ctrl^c por ejemplo)? En ese caso el archivo de bloqueo no se borraría, y por lo tanto, no nos permitiría ejecutar el script de nuevo.

Para cubrir esos casos, podríamos hacer uso del comando trap que nos permite ejecutar comandos en caso que nuestro script termine de manera inesperada. Esta es una versión más avanzada que además guarda dentro del archivo de bloqueo el PID del script que lo ejecuta:

#!/bin/bash
lockfile=/var/lock/loquesea.lock
if ( set -o noclobber; echo "$$" > "$lockfile") 2> /dev/null;
then
    trap 'rm -f "$lockfile"; exit $?' INT TERM EXIT
    echo "hago muchas cosas aqui tranquilamente"
    rm -f "$lockfile"
    trap - INT TERM EXIT
else
    echo "Ya hay otro proceso de este script ejecutandose"
    echo "corriendo con el PID: $(cat $lockfile)"
fi

Entendamos un poco mejor el comando trap. La sintaxis del mismo es básicamente esta: trap comando signal [signal ...]; donde signal es la señal de terminación que quieres atrapar. Si quieres ver una lista de los signals disponibles puedes ejecutar el comando kill -l. Para el caso anterior se usaron los signals INT (captura la terminación producida por un Ctrl^c), TERM (terminación producida por el comando kill) y EXIT (terminación normal de un script, bien sea porque ya no hay más líneas que ejecutar o porque se encuentra con el comando exit).

Menú de opciones

Para hacer un menú en donde permitimos al usuario seleccionar una serie de opciones podemos usar el siguiente esquema:

#!/bin/bash
clear
while :
do
 echo " Escoja una opcion "
 echo "1. quien soy?"
 echo "2. cuanto espacio tengo"
 echo "3. que es esto?"
 echo "4. Salir"
 echo -n "Seleccione una opcion [1 - 4]"
 read opcion
 case $opcion in
  1) echo "este eres:";
     whoami;;
  2) echo "tienes esto";
     df;;
  3) uname -r;;
  4) echo "chao pues parcero";
     exit 1;;
  *) echo "$opc es una opcion invalida. Es tan dificil?";
     echo "Presiona una tecla para continuar...";
     read foo;;
esac
done

Pedir confirmación antes de ejecutar un script

A veces es útil hacer que el usuario confirme la ejecución de un lote de sentencias, es decir, el típico mensaje que pide al usuario escribir yes o no. Esto lo podemos hacer así:

#!/bin/bash
while true; do
    echo
    read -p "esta seguro de hacer lo que sea que vaya a hacer " yn
    case $yn in
        yes ) break;;
        no ) exit;;
        * ) echo "por favor responda yes o no";;
    esac
done
echo "si se ejecuta esto es que aceptaste"

Fuentes de información

• StackOverflow - La más valiosa sin duda alguna
• Writing Robust Bash Shell Scripts
• nixCraft

En esta entrada abordaremos un tema bastante interesante: cómo correr un programa en Java como servicio en Windows o demonio en UNIX/Linux. Puesto que el API de Java no proporciona nada para estos casos, utiliza

remos una librería llamada Java Service Wrapper. Dicha librería nos ofrece una serie de scripts y binarios preparados para diferentes sistemas operativos y arquitecturas, que nos permitirán correr nuestros programas como un servicio; además ofrece diferentes versiones: Profesional, Estándar y Comunity. En este caso usaremos la versión Comunity que es libre y gratuita.

La mejor manera de aprender a usar dicha librería es con un pequeño laboratorio, así que he preparado uno en donde explico la integración más simple que existe con Java Service Wrapper (existen 4 métodos; unos más avanzados que otros). La integración sencilla que he escogido nos permitirá ejecutar como servicio una aplicación que ya esté creada (probablemente ya empaquetada en un .jar) y a la que no podemos o es difícil hacerle modificaciones. Esta es la manera más sencilla de hacerlo, sin embargo tiene una desventaja: al detener el servicio se envía directamente un System.exit() a la JVM por lo que la aplicación no se cerrará limpiamente.

Si quieres integrar tu aplicación de una manera más segura y estás en la capacidad de prepararla para ello, podrías intentar la integración avanzada en la que utilizas el API de Java Service Wrapper para implementar métodos de inicio, pausa y detención del servicio [Para este caso utilizaremos una aplicación de ejemplo que recibe un archivo como parámetro y escribe en él información sobre la memoria del sistema, cada 60 segundos. He escogido este ejemplo porque posee varios aspectos interesantes: requiere de librerías externas (tanto JARs como librerías nativas [.so, dll, etc.]) y recibe parámetros.

Puedes descargar la aplicación de ejemplo de haciendo clic aquí. Si la ejecutáramos de manera convencional veríamos algo de este tipo:

Como puedes ver se trata de una aplicación de consola común y corriente. La aplicación consta básicamente de:

• El ejecutable servicio.jar ubicado en el directorio bin/
• La librería sigar.jar en el directorio lib/
• Las librerías específicas de cada arquitectura de sigar en lib/

Pasos para la integración

Lo primero es descargar el paquete de Java Service Wrapper y descomprimirlo. Supondremos que el directorio donde se encuentra Java Service Wrapper es $RUTA_JSW y que el directorio de la aplicación que  vamos a convertir en servicio es $RUTA_APP.

1. Copiamos los siguentes archivos al directorio bin de nuestra aplicación de ejemplo…

UNIX/Linux

El archivo $RUTA_JSW/bin/wrapper podría no existir; por lo tanto lo que debes copiar es el archivo wrapper-xxx específico para tu plataforma. Por ejemplo, en este caso estoy usando Gentoo Linux de 64bits por lo tanto copiaré el archivo $RUTA_JSW/bin/wrapper-linux-x86-64.

Windows

2. Renombramos algunos archivos…

UNIX/Linux…

Ahora debes renombrar el script sh.script.in con el nombre de la aplicación con la que haremos la integración y darle privilegios de ejecución. En este casó se llama simplemente “servicio”:

Windows

Ahora debes renombrar los archivos .bat  para que concuerden con el nombre de la aplicación con la que haremos la integración. En este casó se llama simplemente “servicio” (lo puedes hacer usando el explorador si no te gusta usar la consola, pero a mi me daría pena):

3. editar archivo de configuración

Editamos el archivo wrapper.conf y lo dejamos en el directorio $RUTA_APP/conf/. El archivo para este ejemplo tendrá el siguiente contenido (importante! lee la explicación si usas Windows):

# Comando de Java
wrapper.java.command=java
# Clase que ejecutara el Wrapper
wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp
# Librerias necesarias para ejecutar el programa
wrapper.java.classpath.1=../lib/wrapper.jar
wrapper.java.classpath.2=servicio.jar
# Java Library Path (ubicacion de las librerias wrapper.dll o wrapper.so)
wrapper.java.library.path.1=../lib
# Java Bits.  On applicable platforms, tells the JVM to run in 32 or 64-bit mode.
wrapper.java.additional.auto_bits=TRUE
# Parametros del programa
wrapper.app.parameter.1=net.casidiablo.servicio.Servicio
wrapper.app.parameter.2=/tmp/log
#********************************************************************
# Wrapper General Properties
#********************************************************************
# Allow for the use of non-contiguous numbered properties
wrapper.ignore_sequence_gaps=TRUE
# Title to use when running as a console
wrapper.console.title=servicio
#********************************************************************
# Wrapper Windows NT/2000/XP Service Properties
#********************************************************************
# Name of the service
wrapper.name=jgossip
# Display name of the service
wrapper.displayname=Servicio
# Description of the service
wrapper.description=Monitor de memoria
# Mode in which the service is installed. AUTO_START or DEMAND_START
wrapper.ntservice.starttype=AUTO_START
# Allow the service to interact with the desktop.
wrapper.ntservice.interactive=false

Explicación del archivo de configuración:

• wrapper.java.command=java es el comando para ejecutar java. En este caso es simplemente java porque estoy en Linux y además tengo configurado correctamente el path. En Windows podría ser algo como: c:\archivos de programa\java\jdk1.6\bin\java.exe
• wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp indica el archivo a ejecutar es la clase WrapperSimpleApp que se usa en la integración sencilla. Esta clase envoltorio es la que permite ejecutar la aplicación como servicio.
• wrapper.java.classpath.1=../lib/wrapper.jar
wrapper.java.classpath.2=servicio.jar indican las rutas o archivos del classpath.
• wrapper.java.library.path.1=../lib indica el directorio donde se encuentran las librerías a usar.
• wrapper.app.parameter.1=net.casidiablo.servicio.Servicio
wrapper.app.parameter.2=/tmp/log estos son los parámetros que se pasarán al programa. Importante: como estamos haciendo la integración simple, el primer parámetro debe ser la clase que contiene el método main de nuestra aplicación.
• wrapper.name=jgossip esta opción es para Windows y define el nombre del servicio en el sistema.
• wrapper.ntservice.starttype=AUTO_START si estás en windows, define si el servicio quedará configurado para iniciar automáticamente.

4. Probar/Instalar el servicio…

Ahora veremos cómo podemos probar la aplicación para asegurarnos que ha quedado bien configurada antes de proceder con la instalación.

UNIX/Linux

Ejecutamos el script ‘servicio’ que configuramos en el paso 1 y 2 con el parámetro console:

Deberías ver algo como:

Lo detienes presionando Ctrl+C. Ahora, si queremos probarlo como demonio basta con ejecutar los comandos típicos de un demonio en UNIX/Linux:

Para instalarlo basta con crear un enlace simbólico del script en el directorio /etc/init.d y añadirlo al listado de servicios a iniciar; por ejemplo:

Windows

Para instalarlo en Windows basta con ejecutar el archivo InstallServicio-NT.bat. Puedes verificar que fue instalado correctamente accediendo a la consola de administración de servicios de NT (ejecutas el comando services.msc):

Fuentes y descargas

Aunque en esta entrada no explico cómo hacer la integración avanzada, he preparado un ejemplo completo que puedes descargar en el listado de abajo.

• Puedes encontrar más documentación en la página oficial del proyecto
• Descargar el laboratorio de esta entrada
• Descargar el código fuente del laboratorio
• Descargar código fuente y laboratorio de la integración avanzada

Me acabo de enterar de este nuevo proyecto, pero… ¿qué es UnixPorn? Bueno, teniendo en cuenta lo guarros que son todos algunos los linuxeros, en especial los chicos Ubuntu, pensé lo peor al principio…

Incluso antes de entrar completamente a la página te advierten de lo que verás, tal como hacen los típicos sitios porno (bueno, no me consta que los sitios porno te adviertan, solo me han contado).