Combien de coquilles je suis profond?

Problème : Trouve combien de coquilles je suis.

Détails : J'ouvre beaucoup le shell de vim. Construire et exécuter et sortir. Parfois, j'oublie et ouvre un autre vim à l'intérieur, puis un autre shell. :(

Je veux savoir combien de coquilles je suis profondément, peut-être même l'avoir sur mon écran de coquille à tout moment. (Je peux gérer cette partie).

Ma solution : analyser l'arbre de processus et rechercher vim et bash / zsh et déterminer la profondeur du processus actuel.

Quelque chose comme ça existe déjà? Je n'ai rien trouvé.

Quand j'ai lu votre question, ma première pensée a été $SHLVL. Ensuite, j'ai vu que vous vouliez compter les vimniveaux en plus des niveaux de coque. Un moyen simple de le faire est de définir une fonction shell:

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

Cela augmentera automatiquement et silencieusement SHLVL chaque fois que vous taperez une vimcommande. Vous devrez le faire pour chaque variante de vi/ vimque vous utilisez déjà; par exemple,

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

L'ensemble de parenthèses externe crée un sous-shell, de sorte que la modification manuelle de la valeur de SHLVL ne contamine pas l'environnement de coque actuel (parent). Bien sûr, le commandmot clé est là pour empêcher les fonctions de s’appeler (ce qui entraînerait une boucle de récursion infinie). Et bien sûr, vous devriez mettre ces définitions dans votre .bashrcfichier d'initialisation du shell ou dans un autre.

Il y a une légère inefficacité dans ce qui précède. Dans certains coquillages (bash étant un), si vous dites

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

où est un programme exécutable externe (c.-à-d., pas une commande intégrée), le shell garde un processus supplémentaire traîner, juste pour attendre la fin. Ce n'est (sans doute) pas nécessaire; les avantages et les inconvénients sont discutables. Si cela ne vous dérange pas de garder un peu de mémoire et un emplacement de processus (et de voir un processus shell plus que nécessaire en a ), faites ce qui précède et passez à la section suivante. Idem si vous utilisez un shell qui ne laisse pas traîner le processus supplémentaire. Mais si vous voulez éviter le processus supplémentaire, la première chose à faire est d'essayercmdncmdnps

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

La execcommande est là pour empêcher le processus shell supplémentaire de rester en attente.

Mais, il y a un gotcha. Le traitement du shell SHLVLest quelque peu intuitif: au démarrage, le shell vérifie si SHLVLest défini. S'il n'est pas défini (ou défini sur autre chose qu'un nombre), le shell le définit sur 1. S'il est défini (sur un nombre), le shell ajoute 1 à celui-ci.

Mais, par cette logique, si vous dites exec sh, vous SHLVLdevriez monter. Mais ce n'est pas souhaitable, car votre niveau de coque réel n'a pas augmenté. Le shell gère cela en soustrayant un de SHLVL lorsque vous faites un 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

Alors

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

est un lavage; il incrémente SHLVLseulement pour le décrémenter à nouveau. Vous pourriez aussi bien dire vim, sans bénéfice d'une fonction.

Note:
Selon Stéphane Chazelas (qui sait tout) , certains obus sont suffisamment intelligents pour ne pas le faire s’ils se trouvent execdans un sous-shell.

Pour résoudre ce problème, vous feriez

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

Ensuite, j'ai vu que vous vouliez compter les vimniveaux indépendamment des niveaux de coque. Eh bien, le même truc fonctionne (bien, avec une modification mineure):

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

(et ainsi de suite pour vi, viewetc.) Le exportest nécessaire parce que VILVLn'est pas définie comme une variable d'environnement par défaut. Mais cela n’a pas besoin de faire partie de la fonction; vous pouvez simplement dire en export VILVLtant que commande séparée (dans votre .bashrc). Et, comme indiqué ci-dessus, si le processus de shell supplémentaire ne vous pose pas problème, vous pouvez le faire à la command vimplace exec vimet laisser les choses suivantes SHLVL:

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

Préférence personnelle:
Vous voudrez peut-être renommer VILVLquelque chose comme VIM_LEVEL. Quand je regarde “ VILVL”, j'ai mal aux yeux; ils ne peuvent pas dire s'il s'agit d'une mauvaise orthographe de «vinyle» ou d'un chiffre romain mal formé.

Si vous utilisez un shell qui ne prend pas en charge SHLVL(par exemple, dash), vous pouvez l'implémenter vous-même, à condition que le shell implémente un fichier de démarrage. Juste faire quelque chose comme

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

dans votre .profilefichier ou fichier applicable. (Vous ne devriez probablement pas utiliser le nom SHLVL, car cela provoquerait le chaos si vous utilisiez un shell compatible SHLVL.)

D'autres réponses ont abordé la question de l'intégration de valeurs de variable d'environnement dans votre invite de shell, je ne vais donc pas le répéter, surtout si vous dites que vous savez déjà comment le faire.

Vous pouvez compter autant de temps que nécessaire pour accéder à l'arborescence des processus jusqu'à ce que vous trouviez un responsable de session. Comme avec 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
}

Ou POSIXly (mais moins efficace):

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"
)

Cela donnerait 0 pour le shell qui a été lancé par votre émulateur de terminal ou getty, et un de plus pour chaque descendant.

Il suffit de le faire une fois au démarrage. Par exemple avec:

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

dans votre ~/.zshrcou équivalent pour l'avoir dans votre invite.

tcshet plusieurs autres coquilles ( zsh, ksh93, fishet bashau moins) maintiennent une $SHLVLvariable qu'ils incrémenter au démarrage (et décrément avant d' exécuter une autre commande avec exec( à moins que execc'est dans un sous - shell si elles ne sont pas buggé (mais beaucoup sont))). Cela ne fait que suivre la quantité d' imbrication de shell , pas de processus d'imbrication. De plus, le niveau 0 n'est pas garanti pour être le responsable de la session.

Utilisez echo $SHLVL. Utilisez le principe KISS . Selon la complexité de votre programme, cela peut être suffisant.

Une solution potentielle consiste à examiner le résultat de pstree. Lorsqu'elle est exécutée à l'intérieur d'un shell créé de l'intérieur vi, la partie de l'arborescence répertoriée pstreedoit indiquer votre profondeur. Par exemple:

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

Première variante - profondeur de la coque uniquement.

Solution simple pour bash: ajouter aux .bashrcdeux lignes suivantes (ou modifier votre PS1valeur actuelle ):

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

Résultat:

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

Le nombre au début de la chaîne d'invite sera le niveau du shell.

Deuxième variante, avec les niveaux imbriqués vim et shell.

ajouter ces lignes à la .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

Résultat:

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 - niveau de profondeur vim
s: 3 - niveau de profondeur de coque

Dans la question que vous avez mentionné l'analyse de pstree. Voici un moyen relativement simple:

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

Les pstreeoptions:

• -A- Sortie ASCII pour un filtrage plus facile (dans notre cas, chaque commande est précédée de `-)
• -a - affiche également les arguments de la commande. En tant qu'effet secondaire, chaque commande est affichée sur une ligne séparée et nous pouvons facilement filtrer le résultat en utilisant grep
• -l - ne pas tronquer les longues lignes
• -s- montrer aux parents du processus sélectionné
  (malheureusement pas supporté dans les anciennes versions de pstree)
• $$ - le processus sélectionné - le PID du shell actuel

Cela ne répond pas strictement à la question, mais dans de nombreux cas, il peut être inutile de le faire:

Lorsque vous lancez votre shell pour la première fois, lancez set -o ignoreeof. Ne le mets pas dans ton ~/.bashrc.

Prenez l'habitude de taper Ctrl-D lorsque vous pensez être dans le shell de niveau supérieur et que vous voulez en être sûr.

Si vous n'êtes pas dans le shell de niveau supérieur, Ctrl-D signalera "la fin de l'entrée" au shell actuel et vous reculerez d'un niveau.

Si vous êtes dans le shell de niveau supérieur, vous recevrez un message:

Use "logout" to leave the shell.

Je l’utilise tout le temps pour les sessions SSH chaînées, afin de faciliter le retour à un niveau spécifique de la chaîne SSH. Cela fonctionne aussi bien pour les coquilles imbriquées.