Wie viele Muscheln bin ich tief?

Problem : Finde heraus, wie viele Muscheln tief ich bin.

Details : Ich öffne die Shell sehr oft von vim. Bauen und ausführen und beenden. Manchmal vergesse ich und öffne ein anderes Vim und dann noch eine Muschel. :(

Ich möchte wissen, wie viele Muscheln tief ich bin, vielleicht habe ich sie sogar immer auf meinem Muschelschirm. (Ich kann diesen Teil verwalten).

Meine Lösung : Analysieren Sie den Prozessbaum, suchen Sie nach vim und bash / zsh und ermitteln Sie die Tiefe des aktuellen Prozesses.

Gibt es so etwas schon? Ich konnte nichts finden.

Als ich Ihre Frage las, war mein erster Gedanke $SHLVL. Dann sah ich, dass Sie vimEbenen zusätzlich zu Shell-Ebenen zählen wollten . Eine einfache Möglichkeit, dies zu tun, besteht darin, eine Shell-Funktion zu definieren:

vim()  { ( ((SHLVL++)); command vim  "$@");}

Dies wird bei SHLVL jeder Eingabe eines vimBefehls automatisch und unbeaufsichtigt inkrementiert . Sie müssen dies für jede Variante von vi/ tun vim, die Sie jemals verwenden. z.B,

vi()   { ( ((SHLVL++)); command vi   "$@");}
view() { ( ((SHLVL++)); command view "$@");}

Der äußere Satz von Klammern erstellt eine Subshell, sodass die manuelle Änderung des Werts von SHLVL die aktuelle (übergeordnete) Shell-Umgebung nicht verschmutzt. Das commandSchlüsselwort soll natürlich verhindern, dass sich die Funktionen selbst aufrufen (was zu einer unendlichen Rekursionsschleife führen würde). Und natürlich sollten Sie diese Definitionen in Ihre .bashrcoder eine andere Shell-Initialisierungsdatei einfügen.

Es gibt eine leichte Ineffizienz in der obigen. In einigen Muscheln (Bash ist eins), wenn Sie sagen

( cmd 1 ;  cmd 2 ; … ;  cmd n )

Wenn es sich um ein externes ausführbares Programm handelt (dh nicht um einen eingebauten Befehl), hält die Shell einen zusätzlichen Prozess herum, nur um auf das Beenden zu warten . Dies ist (wohl) nicht notwendig; Die Vor- und Nachteile sind umstritten. Wenn es Ihnen nichts ausmacht, ein wenig Speicher und einen Prozess-Slot zu belegen (und einen Shell-Prozess mehr zu sehen, als Sie benötigen, wenn Sie a ausführen ), gehen Sie wie oben beschrieben vor und fahren Sie mit dem nächsten Abschnitt fort. Das Gleiche gilt, wenn Sie eine Shell verwenden, bei der der zusätzliche Prozess nicht herumliegt. Wenn Sie jedoch den zusätzlichen Prozess vermeiden möchten, sollten Sie zunächst versuchen, dies zu tuncmdncmdnps

vim()  { ( ((SHLVL++)); exec vim  "$@");}

Der execBefehl soll verhindern, dass der zusätzliche Shell-Prozess nachlässt.

Aber es gibt ein GOTCHA. Die Bedienung der Shell SHLVList etwas intuitiv: Beim Start der Shell wird geprüft, ob SHLVLgesetzt ist. Wenn es nicht gesetzt ist (oder auf etwas anderes als eine Zahl gesetzt ist), setzt die Shell es auf 1. Wenn es gesetzt ist (auf eine Zahl), fügt die Shell 1 hinzu.

Aber von dieser Logik, wenn Sie sagen exec sh, Ihr SHLVLsollte steigen. Dies ist jedoch unerwünscht, da sich Ihr tatsächlicher Shell-Level nicht erhöht hat. Die Muschelgriffe dies durch eine Subtraktion von SHLVL , wenn Sie tun ein exec:

$ echo "$SHLVL"
1

$ set | grep SHLVL
SHLVL=1

$ env | grep SHLVL
SHLVL=1

$ (env | grep SHLVL)
SHLVL=1

$ (env) | grep SHLVL
SHLVL=1

$ (exec env) | grep SHLVL
SHLVL=0

Damit

vim()  { ( ((SHLVL++)); exec vim  "$@");}

ist eine Wäsche; es wird SHLVLnur inkrementiert , um es erneut zu dekrementieren. Sie können auch einfach sagen vim, ohne eine Funktion zu nutzen.

Hinweis:
Laut Stéphane Chazelas (der alles weiß) sind einige Muscheln klug genug, dies nicht zu tun, wenn sie execsich in einer Unterschale befinden.

Um dies zu beheben, würden Sie tun

vim()  { ( ((SHLVL+=2)); exec vim  "$@");}

Dann habe ich gesehen, dass Sie vimEbenen unabhängig von Shell-Ebenen zählen möchten. Nun, genau der gleiche Trick funktioniert (nun, mit einer kleinen Modifikation):

vim() { ( ((SHLVL++, VILVL++)); export VILVL; exec vim "$@");}

(und so weiter für vi, viewusw.) Das exportist notwendig, da VILVLes standardmäßig nicht als Umgebungsvariable definiert ist. Es muss jedoch nicht Teil der Funktion sein. Sie können einfach export VILVLals separates Kommando (in Ihrem .bashrc) sagen . Und, wie oben beschrieben, wenn der zusätzliche Shell - Prozess für Sie kein Problem ist, können Sie tun , command vimstatt exec vim, und lassen Sie SHLVLallein:

vim() { ( ((VILVL++)); command vim "$@");}

Persönliche Präferenz:
Möglicherweise möchten Sie in VILVLso etwas wie umbenennen VIM_LEVEL. Wenn ich auf " VILVL" schaue , schmerzen meine Augen; Sie können nicht sagen, ob es sich um eine falsche Schreibweise von „Vinyl“ oder eine falsch geformte römische Ziffer handelt.

Wenn Sie eine Shell verwenden, die nicht unterstützt wird SHLVL(z. B. Bindestrich), können Sie sie selbst implementieren, solange die Shell eine Startdatei implementiert. Mach einfach so etwas wie

if [ "$SHELL_LEVEL" = "" ]
then
    SHELL_LEVEL=1
else
    SHELL_LEVEL=$(expr "$SHELL_LEVEL" + 1)
fi
export SHELL_LEVEL

in Ihrer .profileoder einer entsprechenden Datei. (Sie sollten den Namen wahrscheinlich nicht verwenden SHLVL, da dies zu Chaos führen kann, wenn Sie jemals eine unterstützte Shell verwenden SHLVL.)

Andere Antworten haben das Problem der Einbettung von Umgebungsvariablenwerten in Ihre Shell-Eingabeaufforderung angesprochen, daher werde ich das nicht wiederholen, besonders wenn Sie sagen, dass Sie bereits wissen, wie es geht.

Sie können so viele Zeit in Anspruch nehmen, bis Sie einen Sitzungsleiter gefunden haben. Wie bei zshLinux:

lvl() {
  local n=0 pid=$$ buf
  until
    IFS= read -rd '' buf < /proc/$pid/stat
    set -- ${(s: :)buf##*\)}
    ((pid == $4))
  do
    ((n++))
    pid=$2
  done
  echo $n
}

Oder POSIXly (aber weniger effizient):

lvl() (
  unset IFS
  pid=$$ n=0
  until
    set -- $(ps -o ppid= -o sid= -p "$pid")
    [ "$pid" -eq "$2" ]
  do
    n=$((n + 1)) pid=$1
  done
  echo "$n"
)

Das würde 0 für die Shell ergeben, die von Ihrem Terminalemulator oder getty gestartet wurde, und eine weitere für jeden Nachkommen.

Sie müssen dies nur einmal beim Start tun. Zum Beispiel mit:

PS1="[$(lvl)]$PS1"

in Ihrem ~/.zshrcoder einem gleichwertigen Format, um es in Ihrer Aufforderung zu haben.

tcshund mehrere andere Muscheln ( zsh, ksh93, fishund bashzumindest) halten eine $SHLVLVariable , die sie beim Start erhöhen (und Abnahme vor einem anderen Befehl ausgeführt werden mit exec(es sei denn , dass execin einer Subshell wenn sie nicht Buggy (aber viele sind))). Dass nur die Menge von Spuren Schale Verschachtelung nicht aber verarbeiten Verschachtelung. Es wird auch nicht garantiert, dass Stufe 0 der Sitzungsleiter ist.

Verwenden Sie echo $SHLVL. Verwenden Sie das KISS-Prinzip . Abhängig von der Komplexität Ihres Programms kann dies ausreichen.

Eine mögliche Lösung besteht darin, den Output von zu betrachten pstree. Wenn Sie in einer Shell laufen vi, die von innen erzeugt wurde , sollte der Teil des Baumbaums, der aufgelistet wird pstree, Ihnen zeigen, wie tief Sie sind. Zum Beispiel:

$ pstree <my-user-ID>
...
       ├─gnome-terminal-─┬─bash───vi───sh───vi───sh───pstree
...

Erste Variante - nur Schalentiefe.

Einfache Lösung für bash: Addiere zu den .bashrcnächsten zwei Zeilen (oder ändere deinen aktuellen PS1Wert):

PS1="${SHLVL} \w\$ "
export PS1

Ergebnis:

1 ~$ bash
2 ~$ bash
3 ~$ exit
exit
2 ~$ exit
exit
1 ~$

Die Zahl am Anfang der Eingabeaufforderungszeichenfolge gibt die Shell-Ebene an.

Zweite Variante mit verschachtelten Vim- und Shell-Ebenen.

füge diese Zeilen dem hinzu .bashrc

branch=$(pstree -ls $$)
vim_lvl=$(grep -o vim <<< "$branch" | wc -l)
sh_lvl=$(grep -o bash <<< "$branch" | wc -l)
PS1="v:${vim_lvl};s:$((sh_lvl - 1)):\w\$ "
export PS1

Ergebnis:

v:0;s:1:/etc$ bash
v:0;s:2:/etc$ bash
v:0;s:3:/etc$ vim
##### do ':sh' command in the vim, shell level is increasing by 1
v:1;s:4:/etc$ vim
##### do ':sh' command in the vim, shell level is increasing by 1
v:2;s:5:/etc$ bash
v:2;s:6:/etc$

v: 1 - Tiefenlevel vim
s: 3 - Tiefenlevel shell

In der Frage, die Sie erwähnt haben, analysieren von pstree. Hier ist ein relativ einfacher Weg:

bash-4.3$ pstree -Aals $$ | grep -E '^ *`-((|ba|da|k|c|tc|z)sh|vim?)( |$)'
                  `-bash
                      `-bash --posix
                          `-vi -y
                              `-dash
                                  `-vim testfile.txt
                                      `-tcsh
                                          `-csh
                                              `-sh -
                                                  `-zsh
                                                      `-bash --norc --verbose

Die pstreeOptionen:

• -A- ASCII-Ausgabe zur einfacheren Filterung (in unserem Fall wird jedem Befehl ein vorangestellt `-)
• -a - zeige auch Befehlsargumente an, als Nebeneffekt wird jeder Befehl in einer eigenen Zeile angezeigt und wir können die Ausgabe einfach mit filtern grep
• -l - Schneiden Sie keine langen Zeilen ab
• -s- Eltern des ausgewählten Prozesses
  anzeigen (wird in alten Versionen von leider nicht unterstützt pstree)
• $$ - der ausgewählte Prozess - die PID der aktuellen Shell

Dies beantwortet die Frage nicht unbedingt , macht sie jedoch in vielen Fällen unnötig:

Wenn Sie Ihre Shell zum ersten Mal starten, führen Sie sie aus set -o ignoreeof. Steck es nicht in deine ~/.bashrc.

Machen Sie es sich zur Gewohnheit, Strg-D einzugeben, wenn Sie glauben, dass Sie sich in der obersten Ebene der Shell befinden und sicher sein möchten.

Wenn Sie sich nicht in der Shell der obersten Ebene befinden, signalisiert Strg-D der aktuellen Shell das "Ende der Eingabe" und Sie werden eine Ebene zurückgesetzt.

Wenn Sie sich in der obersten Ebene der Shell befinden, erhalten Sie eine Nachricht:

Use "logout" to leave the shell.

Ich benutze dies die ganze Zeit für verkettete SSH-Sitzungen, um es einfach zu machen, auf eine bestimmte Ebene der SSH-Kette zurückzukehren. Es funktioniert genauso gut für verschachtelte Shells.