Attendez qu'un processus se termine

Existe-t-il une fonctionnalité intégrée dans Bash pour attendre la fin d'un processus?

La waitcommande permet seulement d'attendre la fin des processus enfants. Je voudrais savoir s'il existe un moyen d'attendre la fin d'un processus avant de procéder à un script.

Une façon mécanique de le faire est la suivante, mais j'aimerais savoir s'il existe une fonctionnalité intégrée dans Bash.

while ps -p `cat $PID_FILE` > /dev/null; do sleep 1; done

Attendre la fin de tout processus

Linux:

tail --pid=$pid -f /dev/null

Darwin (nécessite d' $pidavoir des fichiers ouverts):

lsof -p $pid +r 1 &>/dev/null

Avec timeout (secondes)

Linux:

timeout $timeout tail --pid=$pid -f /dev/null

Darwin (nécessite d' $pidavoir des fichiers ouverts):

lsof -p $pid +r 1m%s -t | grep -qm1 $(date -v+${timeout}S +%s 2>/dev/null || echo INF)

Il n'y a pas de builtin. À utiliser kill -0en boucle pour une solution viable:

anywait(){

    for pid in "$@"; do
        while kill -0 "$pid"; do
            sleep 0.5
        done
    done
}

Ou comme oneliner plus simple pour une utilisation simple et unique:

while kill -0 PIDS 2> /dev/null; do sleep 1; done;

Comme l'ont noté plusieurs commentateurs, si vous souhaitez attendre des processus auxquels vous n'avez pas le privilège d'envoyer des signaux, vous avez trouvé un autre moyen de détecter si le processus est en cours d'exécution pour remplacer l' kill -0 $pidappel. Sous Linux, test -d "/proc/$pid"fonctionne, sur d'autres systèmes, vous devrez peut-être utiliser pgrep(si disponible) ou quelque chose du genre ps | grep "^$pid ".

J'ai trouvé que "kill -0" ne fonctionne pas si le processus appartient à root (ou autre), j'ai donc utilisé pgrep et j'ai trouvé:

while pgrep -u root process_name > /dev/null; do sleep 1; done

Cela aurait l'inconvénient de correspondre probablement aux processus zombies.

Cette boucle de script bash se termine si le processus n'existe pas ou si c'est un zombie.

PID=<pid to watch>
while s=`ps -p $PID -o s=` && [[ "$s" && "$s" != 'Z' ]]; do
    sleep 1
done

EDIT : Le script ci-dessus a été donné ci-dessous par Rockallite . Merci!

Ma réponse originale ci-dessous fonctionne pour Linux, en s'appuyant sur procfsie /proc/. Je ne connais pas sa portabilité:

while [[ ( -d /proc/$PID ) && ( -z `grep zombie /proc/$PID/status` ) ]]; do
    sleep 1
done

Ce n'est pas limité au shell, mais les OS eux-mêmes n'ont pas d'appels système pour surveiller l'arrêt des processus non enfants.

FreeBSD et Solaris ont cet pwait(1)utilitaire pratique , qui fait exactement ce que vous voulez.

Je crois que d'autres systèmes d'exploitation modernes ont également les appels système nécessaires (MacOS, par exemple, implémente BSD kqueue), mais tous ne le rendent pas disponible à partir de la ligne de commande.

Depuis la page de manuel bash

   wait [n ...]
          Wait for each specified process and return its termination  status
          Each  n  may be a process ID or a job specification; if a
          job spec is given, all processes  in  that  job's  pipeline  are
          waited  for.  If n is not given, all currently active child processes
          are waited for, and the return  status  is  zero.   If  n
          specifies  a  non-existent  process or job, the return status is
          127.  Otherwise, the return status is the  exit  status  of  the
          last process or job waited for.

Toutes ces solutions sont testées dans Ubuntu 14.04:

Solution 1 (en utilisant la commande ps): Juste pour ajouter à la réponse de Pierz, je suggérerais:

while ps axg | grep -vw grep | grep -w process_name > /dev/null; do sleep 1; done

Dans ce cas, grep -vw grepgarantit que grep correspond uniquement à nom_processus et non à grep lui-même. Il a l'avantage de prendre en charge les cas où le process_name n'est pas à la fin d'une ligne à ps axg.

Solution 2 (en utilisant la commande supérieure et le nom du processus):

while [[ $(awk '$12=="process_name" {print $0}' <(top -n 1 -b)) ]]; do sleep 1; done

Remplacer process_name par le nom du processus qui apparaît dans top -n 1 -b. Veuillez conserver les guillemets.

Pour voir la liste des processus que vous attendez qu'ils soient terminés, vous pouvez exécuter:

while : ; do p=$(awk '$12=="process_name" {print $0}' <(top -n 1 -b)); [[ $b ]] || break; echo $p; sleep 1; done

Solution 3 (en utilisant la commande supérieure et l'ID de processus):

while [[ $(awk '$1=="process_id" {print $0}' <(top -n 1 -b)) ]]; do sleep 1; done

Remplacez-le process_idpar l'ID de processus de votre programme.

D'accord, il semble donc que la réponse soit - non, il n'y a pas d'outil intégré.

Après avoir réglé /proc/sys/kernel/yama/ptrace_scopesur 0, il est possible d'utiliser le straceprogramme. D'autres commutateurs peuvent être utilisés pour le rendre silencieux, afin qu'il attende vraiment passivement:

strace -qqe '' -p <PID>

Solution de blocage

Utilisez le waitdans une boucle, pour attendre la fin de tous les processus:

function anywait()
{

    for pid in "$@"
    do
        wait $pid
        echo "Process $pid terminated"
    done
    echo 'All processes terminated'
}

Cette fonction se terminera immédiatement, lorsque tous les processus seront terminés. C'est la solution la plus efficace.

Solution non bloquante

Utilisez le kill -0dans une boucle, pour attendre la fin de tous les processus + faire quoi que ce soit entre les vérifications:

function anywait_w_status()
{
    for pid in "$@"
    do
        while kill -0 "$pid"
        do
            echo "Process $pid still running..."
            sleep 1
        done
    done
    echo 'All processes terminated'
}

Le temps de réaction a diminué avec le sleeptemps, car il faut éviter une utilisation élevée du processeur.

Un usage réaliste:

En attente de la fin de tous les processus + informer l'utilisateur de tous les PID en cours d'exécution.

function anywait_w_status2()
{
    while true
    do
        alive_pids=()
        for pid in "$@"
        do
            kill -0 "$pid" 2>/dev/null \
                && alive_pids+="$pid "
        done

        if [ ${#alive_pids[@]} -eq 0 ]
        then
            break
        fi

        echo "Process(es) still running... ${alive_pids[@]}"
        sleep 1
    done
    echo 'All processes terminated'
}

Remarques

Ces fonctions obtiennent des PID via des arguments en $@tant que tableau BASH.

J'ai eu le même problème, j'ai résolu le problème en tuant le processus, puis en attendant que chaque processus se termine en utilisant le système de fichiers PROC:

while [ -e /proc/${pid} ]; do sleep 0.1; done

Il n'y a pas de fonction intégrée pour attendre la fin d'un processus.

Vous pouvez envoyer kill -0à n'importe quel PID trouvé, afin de ne pas être déconcerté par les zombies et les éléments qui seront toujours visibles dans ps(tout en récupérant la liste PID en utilisant ps).

Utilisez inotifywait pour surveiller certains fichiers qui se ferment lorsque votre processus se termine. Exemple (sous Linux):

yourproc >logfile.log & disown
inotifywait -q -e close logfile.log

-e spécifie l'événement à attendre, -q signifie une sortie minimale uniquement à la fin. Dans ce cas, ce sera:

logfile.log CLOSE_WRITE,CLOSE

Une seule commande wait peut être utilisée pour attendre plusieurs processus:

yourproc1 >logfile1.log & disown
yourproc2 >logfile2.log & disown
yourproc3 >logfile3.log & disown
inotifywait -q -e close logfile1.log logfile2.log logfile3.log

La chaîne de sortie de inotifywait vous indiquera quel processus s'est terminé. Cela ne fonctionne qu'avec des fichiers 'réels', pas avec quelque chose dans / proc /

Sur un système comme OSX, vous n'avez peut-être pas pgrep, vous pouvez donc essayer cette approche, lorsque vous recherchez des processus par nom:

while ps axg | grep process_name$ > /dev/null; do sleep 1; done

Le $symbole à la fin du nom du processus garantit que grep correspond uniquement à nom_processus à la fin de la ligne dans la sortie ps et non à lui-même.

La solution de Rauno Palosaari pour Timeout in Seconds Darwin, est une excellente solution de contournement pour un système d'exploitation de type UNIX qui n'a pas GNU tail(ce n'est pas spécifique à Darwin). Mais, selon l'âge du système d'exploitation de type UNIX, la ligne de commande proposée est plus complexe que nécessaire et peut échouer:

lsof -p $pid +r 1m%s -t | grep -qm1 $(date -v+${timeout}S +%s 2>/dev/null || echo INF)

Sur au moins un ancien UNIX, l' lsofargument +r 1m%séchoue (même pour un super-utilisateur):

lsof: can't read kernel name list.

Le m%sest une spécification de format de sortie. Un post-processeur plus simple n'en a pas besoin. Par exemple, la commande suivante attend le PID 5959 pendant cinq secondes maximum:

lsof -p 5959 +r 1 | awk '/^=/ { if (T++ >= 5) { exit 1 } }'

Dans cet exemple, si le PID 5959 sort de lui-même avant la fin des cinq secondes, ${?}est 0. Sinon ${?}revient 1après cinq secondes.

Il peut être intéressant de noter expressément que dans +r 1 , le 1est l'intervalle d'interrogation (en secondes), il peut donc être modifié en fonction de la situation.