Ejemplos de Shell Script Wrappers: Mejora de los comandos Ping y Host

La transparencia para los usuarios de comandos *nix puede lograrse con envolturas de scripts de shell. Un wrapper es una función o script de shell o un alias que contiene una utilidad o comando de sistema.

Los sistemas operativos tipo Unix y Linux pueden ejecutar versiones de aplicaciones de 64 y 32 bits. Esto significa que puedes escribir un script wrapper y éste elegirá y ejecutará la versión necesaria de la plataforma de hardware de 64 o 32 bits. En un entorno de alto rendimiento, es posible encontrar cientos de scripts de envoltura escritos en Python, Shell y Perl para gestionar y enviar trabajos, solucionar problemas, realizar copias de seguridad, configurar el almacenamiento compartido, obtener el uso del clúster y mucho más.

En este artículo, hemos decidido compartir nuestra experiencia práctica y explicar cómo se crea el envoltorio shell para mejorar la herramienta principal de solución de problemas.   

Ventajas de los envoltorios de shell script

• Iniciar y llamar el trabajo necesario.
• Personalización de comandos *nix.
• Útil en HPC, investigación científica y entorno de clúster.
• Es una opción perfecta para ahorrar tiempo.
• Pasar argumentos por defecto a aplicaciones o binarios de terceros.
• Los Wrappers son ideales para comandos o herramientas que necesitan controles de sistema, diferentes configuraciones de entorno personalizadas o parámetros de envío de trabajos.

Ejemplo: Creación de una envoltura de script de shell

El siguiente script de shell iniciará la aplicación java kvminit redirigiendo los registros al archivo y configurando el entorno del sistema:

export JAVA_HOME=${JAVA_HOME:-/usr/java}
export CLASSPATH="/home/vivek/apps/java/class
exec ${JAVA_HOME}/bin/java kvminit "$@" &>/var/log/kvm/logfile

Otro ejemplo de script envoltorio es el que funciona parando/arrancando el cliente o el servidor nfs:

_me=${0##*/}          ​# Server or client?
_server="/etc/init.d/rpcbind /etc/init.d/rpcidmapd /etc/init.d/nfslock /etc/init.d/nfs" # list of server init scripts
_client="/etc/init.d/rpcbind /etc/init.d/rpcidmapd /etc/init.d/nfslock" # list of client init scripts
_action="$1"        ​# stop / start / restart
# activate all scripts with stop or start or restart
runme(){
           ​local i="$1"
          ​local a="$2"
           ​for t in $i
           ​do
                          ​$t $a
           ​done
} 
usage(){
           ​echo "$_me stop|restart|start|reload|status";
           ​exit 0
}
[ $# -eq 0 ] && usage
# main logic
case $_me in
           ​nfs.server) runme "$_server" "$_action" ;;
           ​nfs.client) runme "$_client" "$_action" ;;
           ​*) usage
esac

Herramientas de solución de problemas: Comandos Ping y Host

Las herramientas básicas de solución de problemas para los administradores de sistemas son host y ping.

• El comando host es útil para especificar problemas de DNS. Es posible recibir datos sobre los registros sys de nombres de dominio para ciertas IPs y al mismo tiempo nombres de host para solucionar problemas de DNS.
• Los comandos ping son necesarios para especificar la conectividad entre dispositivos en la red remota o local.

Envoltorio personalizado para Ping

Enviando una petición ping a un dominio eliminando protocolo, nombre de usuario, urls:pass usando el sistema /bin/ping, tiene el siguiente aspecto:

ping(){
           ​local t="$1"
           ​local _ping="/bin/ping"
           ​local c=$(_getdomainnameonly "$t")
           ​[ "$t" != "$c" ] && echo "Sending ICMP ECHO_REQUEST to \"$c\"..."
           ​$_ping $c
}

Envoltorio personalizado para el host

Para el sistema de búsquedas Dns /usr/bin/host utilice lo siguiente:

host(){
           ​local t="$1"
           ​local _host="/usr/bin/host"
           ​local c=$(_getdomainnameonly "$t")
           ​[ "$t" != "$c" ] && echo "Performing DNS lookups for \"$c\"..."
           ​$_host $c

Utilización de los comandos Ping y Host originales

Necesita crear un script de shell que se llame $HOME/scripts/wrapper_functions.lib y rellenar las 3 funciones como aquí:

_getdomainnameonly(){
           ​local h="$1"
           ​local f="${h,,}"
           ​# delete protocol part of name
    ​f="${f#http://}"
    ​f="${f#https://}"
           ​f="${f#ftp://}"
           ​f="${f#scp://}"
           ​f="${f#scp://}"
           ​f="${f#sftp://}"
           ​# delete username or/and username:password part of hostname
           ​f="${f#*:*@}"
           ​f="${f#*@}"
           ​# delete all /foo/xyz.html*
           ​f=${f%%/*}
           ​# Reveal only domain name
           ​echo "$f"
}
ping(){
           ​local t="$1"
           ​local _ping="/bin/ping"
           ​local c=$(_getdomainnameonly "$t")
           ​[ "$t" != "$c" ] && echo "Sending ICMP ECHO_REQUEST to \"$c\"..."
           ​$_ping $c
}
host(){
           ​local t="$1"
           ​local _host="/usr/bin/host"
           ​local c=$(_getdomainnameonly "$t")
           ​[ "$t" != "$c" ] && echo "Performing DNS lookups for \"$c\"..."
           ​$_host $c
}

After that edit $HOME/.bashrc by adding the next line:

 source $HOME/scripts/wrapper_functions.lib

Guarde el archivo con los cambios y también puede probar si todo funciona como necesita.

Paso de argumentos de línea de comandos a través de Bash Shell Script Wrapper

_getdomainnameonly(){
           ​local h="$1"
           ​local f="${h,,}"
           ​# delete protocol part of name
    ​f="${f#http://}"
    ​f="${f#https://}"
           ​f="${f#ftp://}"
           ​f="${f#scp://}"
           ​f="${f#scp://}"
           ​f="${f#sftp://}"
           ​# delete username or/and username:password part of hostname
           ​f="${f#*:*@}"
           ​f="${f#*@}"
           ​# delete all /foo/xyz.html*
           ​f=${f%%/*}
           ​# Reveal only domain name
           ​echo "$f"
}
ping(){
           ​local array=( $@ )                      ​
           ​local len=${#array[@]}      ​
           ​local host=${array[$len-1]} ​
           ​local args=${array[@]:0:$len-1}
           ​local _ping="/bin/ping"
           ​local c=$(_getdomainnameonly "$host")
           ​[ "$t" != "$c" ] && echo "Sending ICMP ECHO_REQUEST to \"$c\"..."
           ​# pass host and args
           ​$_ping $args $c
}
host(){
           ​local array=( $@ )
           ​local len=${#array[@]}
           ​local host=${array[$len-1]}
           ​local args=${array[@]:0:$len-1}
           ​local _host="/usr/bin/host"
           ​local c=$(_getdomainnameonly "$host")
           ​[ "$t" != "$c" ] && echo "Performing DNS lookups for \"$c\"..."
           ​$_host $args $c
}

Para finalizar​

Tenemos funciones compartidas y un pequeño script que puede realizar operaciones para conseguir los resultados necesarios. Para crear otras funcionalidades, debes disponer de binarios existentes y reutilizar código.