Beispiele für Shell-Skript-Wrapper: Verbesserung von Ping- und Host-Befehlen

Die Transparenz für die Benutzer von *nix-Befehlen kann mit Shell-Skript-Wrappern erreicht werden. Ein Wrapper ist eine Shell-Funktion oder ein Shell-Skript oder ein Alias, das ein Dienstprogramm oder einen Systembefehl enthält.

Unix- und Linux-ähnliche Betriebssysteme können 64-Bit- und 32-Bit-Versionen von Anwendungen ausführen. Das bedeutet, dass Sie ein Wrapper-Skript schreiben können, das die benötigte Version für die 64-Bit- oder 32-Bit-Hardwareplattform auswählt und ausführt. In einer Hochleistungsumgebung kann man Hunderte von Wrapper-Skripten finden, die in Python, Shell und Perl geschrieben sind, um Aufträge zu verwalten und zu übermitteln, Fehler zu beheben, Backups zu erstellen, den gemeinsamen Speicher einzurichten, die Clusterauslastung zu ermitteln und vieles mehr.

In diesem Artikel möchten wir unsere praktischen Erfahrungen weitergeben und erklären, wie der Shell-Wrapper erstellt wird, um das primäre Werkzeug zur Fehlerbehebung zu verbessern.    

Vorteile von Shell Script Wrappern

• Starten und rufen Sie den gewünschten Auftrag auf.
• Anpassung von *nix-Befehlen.
• Hilfreich in HPC-, wissenschaftlichen Forschungs- und Cluster-Umgebungen.
• Dies ist eine perfekte zeitsparende Option.
• Übergabe von Standardargumenten an Anwendungen oder Binärdateien von Drittanbietern.
• Wrapper sind ideal für Befehle oder Tools, die Systemsteuerungen, angepasste Umgebungseinstellungen oder Parameter für die Auftragsübermittlung benötigen.

​Beispiel: Erstellung eines Shell-Script-Wrappers

Das nächste Shell-Skript startet kvminit java app, indem es Protokolle in die Datei umleitet und die Systemumgebung einrichtet:

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

Ein weiteres Beispiel für ein Wrapper-Skript ist das Stoppen/Starten des Clients oder nfs-Servers:

_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"
​für 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

Tools zur Fehlerbehebung: Ping und Host-Befehle

Die grundlegenden Werkzeuge zur Fehlerbehebung für Systemadministratoren sind host und ping.

• Der Host-Befehl ist hilfreich bei der Angabe von DNS-Problemen. Es ist möglich, Daten über Domain-Name-Sys-Records für bestimmte IPs und gleichzeitig Hostnamen zu erhalten, um DNS-Probleme zu beheben.
• Ping-Befehle werden benötigt, um die Konnektivität zwischen Geräten im entfernten oder lokalen Netz festzustellen.  

Kundenspezifischer Wrapper für Ping

Das Senden einer Ping-Anfrage an eine Domäne durch Entfernen von Protokoll, Benutzername, urls:pass mit dem System /bin/ping sieht so aus:

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

Kundenspezifischer Wrapper für Host

Für Dns-Lookups System /usr/bin/host verwenden Sie das folgende:

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

Verwendung der ursprünglichen Ping- und Host-Befehle

Sie müssen ein Shell-Skript mit dem Namen $HOME/scripts/wrapper_functions.lib erstellen und alle 3 Funktionen wie hier eingeben:

_getdomainnameonly(){
​local h="$1"
​local f="${h,,}"
​# Protokollteil des Namens löschen
​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
}

Bearbeiten Sie anschließend $HOME/.bashrc, indem Sie die folgende Zeile hinzufügen:

 Quelle $HOME/scripts/wrapper_functions.lib

Speichern Sie die Datei mit den Änderungen und testen Sie, ob alles wie gewünscht funktioniert.

Übergabe von Kommandozeilenargumenten über Bash Shell Script Wrapper

_getdomainnameonly(){
​local h="$1"
​local f="${h,,}"
​# Protokollteil des Namens löschen
​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
}

Zusammenfassend

Wir haben gemeinsame Funktionen und ein kleines Skript, das Operationen ausführen kann, um die benötigten Ergebnisse zu erzielen. Um weitere Funktionen zu erstellen, sollten Sie über vorhandene Binärdateien verfügen und Code wiederverwenden.