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.
- Ventajas de los envoltorios de shell script
- Ejemplo: Creación de una envoltura de script de shell
- Herramientas de solución de problemas: Comandos Ping y Host
- Envoltorio personalizado para Ping
- Envoltorio personalizado para el host
- Utilización de los comandos Ping y Host originales
- Paso de argumentos de línea de comandos a través de Bash Shell Script Wrapper
- Para finalizar
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.libGuarde 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.