In diesem letzten Beitrag unserer 3-teiligen Reihe Grundlagen der Automatisierung und Bash-Skripterstellung, Wir werden das Skript-Debugging untersuchen, Ausführen von Skripten als Hintergrundprozedur und Importieren anderer Skripte mit dem Quellbefehl.
Grundlagen der Bash-Automatisierung und Skripterstellung
Wenn du von vorne anfangen willst, lea nuestro post Bash Automation and Scripting Basics Part 1. In diesem letzten Beitrag unserer dreiteiligen Serie über Bash-Automatisierung und Skripting-Grundlagen wird das Ausführen von Skripten als Hintergrundverfahren erläutert..
Wir möchten auch unsere Skripte schnell mit einem Minimum an Komplikationen und High-End-Ergebnissen debuggen.. Dies kann mit einer sehr nützlichen Trace-Funktion erfolgen, direkt in die Bash-Shell eingebaut. Das werden wir im zweiten Thema sehen. Behaltet auch unseren nächsten Beitrag zum dazugehörigen Shellcheck im Auge.
Und zum Abschluss werden wir untersuchen, wie man Skripte als Hintergrundprozedur ausführt. Obwohl dies bescheidene unmittelbare Vorteile bieten kann, wie man mehrere Aufgaben gleichzeitig startet, legt auch einen Teil der Grundlage für später fortgeschrittene Multithread-Skripte.
Skript-Debugging
Das Debuggen eines Skripts in der Bash muss nicht schwierig sein!! Behalten Sie das CloudSavvyIT-Webportal im Auge, da wir bald das umfassendste Shellcheck-Debugging-Tool für Bash überprüfen werden, aber im Moment möchte ich Ihnen eine großartige Möglichkeit vorstellen, Shell-Skripte auf einfache und leicht verständliche Weise zu debuggen.
In Bashs Shell, das ist doch ein “einfach” Binärdatei, die auf Ihrem Computer ausgeführt wird, Mit anderen Worten, das bash Spuren, eine Option ist vorgesehen (-x) das, gemäß man bash (Wenn Sie dies in Ihrem Terminal ausführen, wird eine manuelle Bash angezeigt) wird beschrieben als Befehle und ihre Argumente ausgeben, während sie ausgeführt werdenUnd genau das tut es!! Wie wird dies beim Debuggen helfen?? Sehen Sie sich das folgende Beispiel an:
#!/bin/bash A=1 B=2 if [ "${AA}" == "1" -Ö "${B}" == "1" ]; then echo "Eins ('1') wurde definitiv entweder in der Variablen A gespeichert, oder die Variable B" Ausfahrt 0 else echo "Behaupten: Konnte den Wert '1' in den Variablen A und B nicht finden" Ausfahrt 1 Sein
Hier überprüfen wir die Variablen A und B gegen Wert 1. das -o Redewendung im if Deklaration bedeutet OR, Mit anderen Worten, der erste Teil (A, oder besser AA hier ist es 1) Es stimmt, oder der zweite Teil (B es ist 1) wahr ist und, in einem solchen Fall, Erfolg ist erreicht.
Die Ausgabe des Skripts ist die geplante Assertion und das Programm wird mit einem Exit-Code von beendet 1, was im Allgemeinen bedeutet, dass ein Fehler aufgetreten ist. Wenn das Skript richtig funktioniert hätte, eine Bestätigungsnachricht würde angezeigt und das Skript würde mit einem Exit-Code von beendet 0, was im Allgemeinen bedeutet, dass alles, was mit dem Skript oder dem Dienstprogramm beabsichtigt war, erfolgreich war.
Dann, Warum wird das Skript auf Assertion ausgeführt?? Sie haben vielleicht schon bemerkt, dass die Variable A Ich habe einen Tippfehler in unserem gefunden if Stellungnahme, im Code eingetragen als AA: ein Insekt! Wir könnten gehen und das Skript überprüfen, und wenn es so kurz und einfach ist wie hier, der fehler wäre schnell gefunden. Aber für eine Show 5000 Linien, Die Antwort ist nicht so einfach, vor allem, wenn Sie mehrere Threads verwenden, komplexe Unterschichten, etc.
Wir debuggen dies jetzt mit dem -x Option zu Bash. Sie erinnern sich vielleicht an den zweiten Teil unseres Kurses Bash Scripting and Automation Basics, dass eine Subshell mit a . gestartet werden kann $( ... ) Satz von Redewendungen. Es kann auch durch einfaches Tippen gestartet werden bash, o für diesen Fall bash -x in unserer Oberschale. Unter diesen Umständen, Wir werden das Skript in unserer Bash-Subshell ausführen, mit dem -x Möglichkeit, Schritt für Schritt zu beobachten, was passiert.
Also führen wir aus bash -x ./test_debugging.sh und beachten Sie, dass die nächste bedingte Prüfung stattfindet: '[' '' == 1 -o 2 == 1 ']'. Wir merken, dass etwas nicht stimmt: der Wert von 2 wird verglichen mit 1 im zweiten Teil unserer Bedingungsprüfung, aber was passiert im ersten teil? Etwas wird verglichen mit 1, aber das etwas ist … leer (wie durch die leere Zeichenfolge angezeigt '')!
Dann überprüfen wir unser Skript, warum dieser leere Platz da ist und warum er nicht mit dem Wert unserer gefüllt wurde A Variable. Wir erkennen schnell die AA Anstatt von A Error, Beheben Sie den Fehler und das Skript funktioniert jetzt einwandfrei.
Etwas wirklich Cooles, an das man sich bei der Verwendung erinnern kann bash -x ist das du kannst tee (lese das gerne 'Kopieren’) die Ausgabe des Bash-Befehls, der stderr . umleitet (die Fehlerausgabe) ein stdout (Standardausgabe) und das gleiche mit einfangen tee:
Hier führen wir unser festes Skript aus und leiten die Fehlerausgabe um (bash -x Senden Sie alle Ihre Debug-Informationen an stderr, die Standardfehlerausgabe, y nein ein stdout) mit 2>&1 (was unsere stderr-Ausgabe auf stdout umleitet – unsere Standardausgabe – stattdessen). Dann erfassen wir stdout mit tee und dies speichert die Ausgabe in der angegebenen Datei, nämlich bash_-x_output.txt.
Dies ermöglicht es einem Bash-Entwickler, langsam zu überprüfen, in einem Schritt-für-Schritt-Format, dein geschriebener Code. Vor allem, wenn Programme komplex werden, Funktionen haben, multithreading werden, Hintergrundprozesse starten, usw., diese Form des Debuggens kann sehr wertvoll sein. Als Beispiel, Ich neige dazu, zu verwenden bash -x etwa alle fünfzehn Tage, um komplexe Skripte zu debuggen.
Ausführung von Skripten als Hintergrundprozesse
Das Ausführen eines Skripts als Hintergrundprozedur ist einfach: einfach hinzufügen & am Ende des Skriptnamens (mit einem Leerzeichen zwischen ihnen). Definieren background.sh wie folgt:
#!/bin/bash
sleep 2
Dann starten wir es auf die nächste Art und Weise, um die Tatsache hervorzuheben, dass es im Hintergrund ausgeführt wird:
Was wir hier sehen können, ist wie folgt:: background.sh Das Skript beginnt im Hintergrund (angesichts der & an den Skriptnamen mit einem Leerzeichen angehängt), und sofort kehrt die Eingabeaufforderung zurück. Wir verwenden dies hier, indem wir den folgenden Befehl angeben (sleep 1) direkt danach & Hintergrundsprache, was auch diesen Befehl einen einzelnen Befehl beendet / einzigartig (Mit anderen Worten, sleep 1 es ist ein absolut neuer Befehl).
Wir kündigen auch unsere sleep 1 Befehl mit einem häufigen Ende des Befehls Bash-Idiom, danach laufen wir a echo dass er sleep 1 Es ist fertig / getan. Nächste, mal sehen was bei der Ausführung dieser Zeile passiert.
Sofort, unser Verfahren / Skript im Hintergrund (background.sh) startet und läuft für ca. 2 Sekunden. Die PID (Verfahrenskennung) der gestarteten Hintergrundprozedur wird optisch angezeigt (Mit anderen Worten, 773183 für unser erstes[1]) Hintergrundverfahren, und diese PID wird jedes Mal anders sein, wenn Sie ein Programm starten / Hintergrundverfahren), und unsere sleep 1 (die nächste Anweisung zur Ausführung) jetzt kann es ausgeführt werden, da das andere Programm unsere Nachricht zurückgegeben hat (auch wenn es hier nicht direkt angezeigt wird, Das passiert, wenn Sie eine Hintergrundprozedur starten; bekommt sofort die Eingabeaufforderung zurück).
das sleep 1 beginnt (mit dem sleep 2 oder genauer die background.sh Skript läuft noch im Hintergrund, als anderes Verfahren, in einer Unterschicht, die unter dieser oberen oder höheren Schicht begonnen hat) und endet nach 1 Sekunde. Danach unser echo läuft, zeigt uns die sleep 1 Ist komplett. Eine Sekunde später, unsere background.sh das Verfahren rundet Ihre Wartezeit ab 2 Sekunden und endet.
Wir sehen nicht, dass es fertig ist, da die Bash-Shell erwartet, dass uns eine Interaktion angezeigt wird Statusmeldungen. Weil, sobald wir Enter drücken, jederzeit nach Ende des zweisekündigen Schlafs, wir sehen die Beendigung des Hintergrundverfahrens als a [1]+ Done ./background.sh Statusnachricht. Wenn Sie zum zweiten Teil unserer Miniserie zurückkehren, es ist auch möglich zu sehen, wie wir es hätten gebrauchen können wait hier um auf die Fertigstellung zu warten / Hintergrundprozedur PID-Beendigung. Es zeigt auch, wie viele Befehle und Dienstprogramme in Bash . kombinatorisch verwendet werden können.
Skripte importieren mit Quelle
Das Importieren eines anderen Skripts kann einfach mit Bash durchgeführt werden source Befehl. Berücksichtigen Sie den folgenden Bindestrich testsource.sh:
#!/bin/bash
source mysource.sh
echo "${MYVAR}"
Und Pairing mysource.sh:
#!/bin/bash
MYVAR="Hallo CloudSavvyIT Leser!"
Wenn wir einfach das erste Skript machen (testsource.sh) ausführbar (mit chmod +x testsource.sh), aber nicht das zweite Skript (Genau genommen, Wir haben das Flag der ausführbaren Datei zerlegt, um deutlich zu zeigen, dass dies mit chmod -x auf mysource.sh), Das zweite Skript wird aufgrund der source Befehl, und läuft im Rahmen der testsource.sh Text:
Bei mysource.sh Skript, Wir setzen die Variable MYVAR zum Hello CloudSavvyIT Readers!. Dieses Skript erhalten Sie später von testsource.sh Skript mit Anweisung source mysource.sh. Dies wird verursachen mysource.sh an diesem Punkt ausgeführt werden der Code, und wenn es fertig ist, das testsource.sh Das Skript wird weiterhin ausgeführt, obwohl alles in der mysource.sh wird beibehalten (stell dir das vor als aus einem anderen Skript um sich die Bedienung leichter zu merken).
Zusammenfassend
Wir werfen einen Blick auf das Debuggen von Skripten mit bash -x um alle ausgeführten Befehle anzuzeigen. Wir haben auch untersucht, wie ein Skript als Hintergrundverfahren ausgeführt wird, und erfahren, wie wir Skripte mithilfe von Quellcode importieren können.. Vielen Dank für deine Aufmerksamkeit auf diese Serie von 3 Teile, Davon war dies der letzte Beitrag!
Wenn Sie mehr über Bash erfahren möchten, Wie wäre es mit unseren Beiträgen oder Primer: Bash-Loops: zum, solange und bis, Bedingte Tests in bash: wenn, dann, anders, elif und Bash Lokale Funktionen und Variablen
