l'exécution de la boucle bash pendant l'exécution de la commande

Je veux créer un script bash qui exécute une commande et en attendant effectue d'autres choses, avec la possibilité de tuer la commande si le script est tué. Dire, exécute un cp d'un fichier de grande taille et dans le même temps imprime le temps écoulé depuis la copie commencé, mais si le script est tué, il tue aussi la copie.
Je ne pas souhaitez utiliser rsync, pour 2 raisons: 1) est lente et 2) je veux apprendre comment le faire, il pourrait être utile.
J'ai essayé ceci:

until cp SOURCE DEST
do
#evaluates time, stuff, commands, file dimensions, not important now
#and echoes something
done

mais il ne veut pas exécuter l' do - done bloc, tel qu'il est en attente que la copie se termine. Pourriez-vous s'il vous plaît suggérer quelque chose?

source d'informationauteur marco

  1. 33

    until est à l'opposé de while. Il n'a rien à voir avec faire des trucs alors qu'une autre commande s'exécute. Pour cela vous avez besoin pour exécuter votre tâche en arrière-plan avec &.

    cp SOURCE DEST &
pid=$!

# If this script is killed, kill the `cp'.
trap "kill $pid 2> /dev/null" EXIT

# While copy is running...
while kill -0 $pid 2> /dev/null; do
    # Do stuff
    ...
    sleep 1
done

# Disable the trap on a normal exit.
trap - EXIT

    kill -0 vérifie si un processus est en cours d'exécution. Notez qu'il ne fait pas de signal le processus et de le tuer, comme le nom pourrait le faire croire. Pas avec un signal de 0, au moins.

  2. 8

    Il y a trois étapes dans la résolution de votre problème:

    1. Exécuter une commande en arrière-plan, donc, il va continuer à courir pendant que votre script ne fait autre chose. Vous pouvez le faire en suivant la commande avec &. Voir la la section sur le Contrôle du Travail dans le Bash Manuel de Référence pour plus de détails.

    2. Garder une trace de la commande de l'état, de sorte que vous saurez si elle est toujours en cours d'exécution. Vous pouvez le faire avec la variable spéciale $!qui est le PID (identificateur de processus) de la dernière commande exécutée en arrière-plan, ou vide si pas de fond de commande a été commencé. Linux crée un répertoire /proc/$PID pour chaque processus en cours d'exécution et le supprime lorsque le processus s'arrête, de sorte que vous pouvez vérifier l'existence de ce répertoire pour savoir si le fond de commande est toujours en cours d'exécution. Vous pouvez en apprendre plus que vous avez toujours voulu savoir sur /proc du Projet de Documentation Linux est Hiérarchie du Système de fichier de la page ou Advanced Bash Scripting Guide.

    3. Tuer le fond de commande si votre script est tué. Vous pouvez faire cela avec le trap de commande, qui est un bash builtin commande.

    Rassembler les morceaux:

    # Look for the 4 common signals that indicate this script was killed.
# If the background command was started, kill it, too.
trap '[ -z $! ] || kill $!' SIGHUP SIGINT SIGQUIT SIGTERM
cp $SOURCE $DEST &  # Copy the file in the background.
# The /proc directory exists while the command runs.
while [ -e /proc/$! ]; do
    echo -n "."  # Do something while the background command runs.
    sleep 1  # Optional: slow the loop so we don't use up all the dots.
done

    Noter que nous avons vérifier la /proc répertoire pour savoir si le fond de commande est toujours en cours, car kill -0 va générer une erreur si elle a été appelée lorsque le processus n'existe plus.

    Mise à jour pour expliquer l'utilisation de trap:

    La syntaxe est trap [arg] [sigspec …]où sigspec … est une liste de signaux de attraper, et arg est une commande à exécuter lorsque l'un quelconque de ces signaux est soulevée. Dans ce cas, la commande est une liste:

    '[ -z $! ] || kill $!'

    C'est une commune bash idiome qui tire parti de la façon || est traitée. Une expression de la forme cmd1 || cmd2 permettra d'évaluer autant de succès si cmd1 OU cmd2 réussit. Mais bash est intelligent: si cmd1 réussit, bash sait que l'expression complète doit également réussir, de sorte qu'il n'a pas pris la peine d'évaluer cmd2. D'autre part, si cmd1 échoue, le résultat de cmd2 détermine le résultat global de l'expression. Donc une caractéristique importante de || est que il va exécuter cmd2 seulement si cmd1 échoue. Cela signifie que c'est un raccourci pour l' (invalides) séquence:

    if cmd1; then
   # do nothing
else
   cmd2
fi

    Avec cela à l'esprit, nous pouvons voir que

    trap '[ -z $! ] || kill $!' SIGHUP SIGINT SIGQUIT SIGTERM

    permettra de tester si $! est vide (ce qui signifie que la tâche en arrière-plan n'a jamais été exécutée). Si cela échoue, ce qui signifie que la tâche était exécuté, il tue à la tâche.

  3. 1

    Ce que vous voulez est de faire deux choses à la fois dans le shell. La manière habituelle de le faire est avec un travail. Vous pouvez démarrer une tâche en arrière-plan pour la fin de la commande avec une esperluette.

    copy $SOURCE $DEST &

    Vous pouvez ensuite utiliser la jobs de commande pour vérifier son état.

    Lire la suite:

  4. 0

    ici est la façon la plus simple de le faire à l'aide de ps -p :

    [command_1_to_execute] &
pid=$!

while ps -p $pid &>/dev/null; do
    [command_2_to_be_executed meanwhile command_1 is running]
    sleep 10 
done

    Cela permettra d'exécuter toutes les 10 seconds la command_2 si le command_1 est toujours en cours d'exécution en arrière-plan .

    espérons que cela vous aidera 🙂