Délai d'expiration d'une commande dans bash sans délai inutile

Cette réponse à la commande de ligne de commande pour tuer automatiquement une commande après un certain temps

propose une méthode sur une ligne pour expirer une commande de longue durée à partir de la ligne de commande bash:

( /path/to/slow command with options ) & sleep 5 ; kill $!

Mais il est possible qu'une commande "de longue durée" donnée se termine plus tôt que le délai d'expiration. (Appelons-la une commande "généralement longue mais parfois rapide" ou tlrbsf pour le plaisir.)

Donc, cette approche astucieuse à 1 doublure a quelques problèmes. Tout d'abord, le sleepn'est pas conditionnel, ce qui définit une limite inférieure indésirable sur le temps nécessaire à la séquence pour se terminer. Considérez 30s ou 2m ou même 5m pour le sommeil, lorsque la commande tlrbsf se termine en 2 secondes - hautement indésirable. Deuxièmement, le killest inconditionnel, donc cette séquence tentera de tuer un processus non en cours et de se plaindre.

Alors...

Existe-t-il un moyen de temporiser une commande généralement longue mais parfois rapide ( "tlrbsf" ) qui

• a une implémentation bash (l'autre question a déjà des réponses Perl et C)
• se terminera à la première des deux: fin du programme tlrbsf , ou délai d'expiration
• ne tuera pas les processus non existants / non en cours d'exécution (ou, facultativement: ne se plaindra pas d'un mauvais kill)
• ne doit pas être un doublure
• peut fonctionner sous Cygwin ou Linux

... et, pour les points bonus, exécute la commande tlrbsf au premier plan et tout processus "sleep" ou supplémentaire en arrière-plan, de telle sorte que la commande stdin / stdout / stderr de la commande tlrbsf peut être redirigée, comme si elle avait été courir directement?

Si oui, veuillez partager votre code. Sinon, veuillez expliquer pourquoi.

J'ai passé un certain temps à essayer de pirater l'exemple susmentionné, mais j'atteins la limite de mes compétences bash.

Je pense que c'est précisément ce que vous demandez:

http://www.bashcookbook.com/bashinfo/source/bash-4.0/examples/scripts/timeout3

#!/bin/bash
#
# The Bash shell script executes a command with a time-out.
# Upon time-out expiration SIGTERM (15) is sent to the process. If the signal
# is blocked, then the subsequent SIGKILL (9) terminates it.
#
# Based on the Bash documentation example.

# Hello Chet,
# please find attached a "little easier"  :-)  to comprehend
# time-out example.  If you find it suitable, feel free to include
# anywhere: the very same logic as in the original examples/scripts, a
# little more transparent implementation to my taste.
#
# Dmitry V Golovashkin <Dmitry.Golovashkin@sas.com>

scriptName="${0##*/}"

declare -i DEFAULT_TIMEOUT=9
declare -i DEFAULT_INTERVAL=1
declare -i DEFAULT_DELAY=1

# Timeout.
declare -i timeout=DEFAULT_TIMEOUT
# Interval between checks if the process is still alive.
declare -i interval=DEFAULT_INTERVAL
# Delay between posting the SIGTERM signal and destroying the process by SIGKILL.
declare -i delay=DEFAULT_DELAY

function printUsage() {
    cat <<EOF

Synopsis
    $scriptName [-t timeout] [-i interval] [-d delay] command
    Execute a command with a time-out.
    Upon time-out expiration SIGTERM (15) is sent to the process. If SIGTERM
    signal is blocked, then the subsequent SIGKILL (9) terminates it.

    -t timeout
        Number of seconds to wait for command completion.
        Default value: $DEFAULT_TIMEOUT seconds.

    -i interval
        Interval between checks if the process is still alive.
        Positive integer, default value: $DEFAULT_INTERVAL seconds.

    -d delay
        Delay between posting the SIGTERM signal and destroying the
        process by SIGKILL. Default value: $DEFAULT_DELAY seconds.

As of today, Bash does not support floating point arithmetic (sleep does),
therefore all delay/time values must be integers.
EOF
}

# Options.
while getopts ":t:i:d:" option; do
    case "$option" in
        t) timeout=$OPTARG ;;
        i) interval=$OPTARG ;;
        d) delay=$OPTARG ;;
        *) printUsage; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# $# should be at least 1 (the command to execute), however it may be strictly
# greater than 1 if the command itself has options.
if (($# == 0 || interval <= 0)); then
    printUsage
    exit 1
fi

# kill -0 pid   Exit code indicates if a signal may be sent to $pid process.
(
    ((t = timeout))

    while ((t > 0)); do
        sleep $interval
        kill -0 $$ || exit 0
        ((t -= interval))
    done

    # Be nice, post SIGTERM first.
    # The 'exit 0' below will be executed if any preceeding command fails.
    kill -s SIGTERM $$ && kill -0 $$ || exit 0
    sleep $delay
    kill -s SIGKILL $$
) 2> /dev/null &

exec "$@"

Vous recherchez probablement la timeoutcommande dans coreutils. Puisqu'il fait partie de coreutils, c'est techniquement une solution C, mais c'est toujours coreutils. info timeoutpour plus de détails. Voici un exemple:

timeout 5 /path/to/slow/command with options

Cette solution fonctionne quel que soit le mode de surveillance bash. Vous pouvez utiliser le signal approprié pour terminer votre_commande

#!/bin/sh
( your_command ) & pid=$!
( sleep $TIMEOUT && kill -HUP $pid ) 2>/dev/null & watcher=$!
wait $pid 2>/dev/null && pkill -HUP -P $watcher

L'observateur tue votre_commande après un délai d'expiration donné; le script attend la tâche lente et termine l'observateur. Notez que waitcela ne fonctionne pas avec les processus qui sont des enfants d'un shell différent.

Exemples:

• your_command s'exécute plus de 2 secondes et a été interrompue

votre_commande interrompue

( sleep 20 ) & pid=$!
( sleep 2 && kill -HUP $pid ) 2>/dev/null & watcher=$!
if wait $pid 2>/dev/null; then
    echo "your_command finished"
    pkill -HUP -P $watcher
    wait $watcher
else
    echo "your_command interrupted"
fi

• votre_commande s'est terminée avant la temporisation (20 secondes)

votre_commande terminée

( sleep 2 ) & pid=$!
( sleep 20 && kill -HUP $pid ) 2>/dev/null & watcher=$!
if wait $pid 2>/dev/null; then
    echo "your_command finished"
    pkill -HUP -P $watcher
    wait $watcher
else
    echo "your_command interrupted"
fi

Voilà:

timeout --signal=SIGINT 10 /path/to/slow command with options

vous pouvez changer le SIGINTet 10comme vous le souhaitez;)

Vous pouvez le faire entièrement avec bash 4.3et au-dessus:

_timeout() { ( set +b; sleep "$1" & "${@:2}" & wait -n; r=$?; kill -9 `jobs -p`; exit $r; ) }

• Exemple: _timeout 5 longrunning_command args
• Exemple: { _timeout 5 producer || echo KABOOM $?; } | consumer
• Exemple: producer | { _timeout 5 consumer1; consumer2; }

• Exemple: { while date; do sleep .3; done; } | _timeout 5 cat | less

• Nécessite Bash 4.3 pour wait -n

• Donne 137 si la commande a été supprimée, sinon la valeur de retour de la commande.
• Fonctionne pour les tuyaux. (Vous n'avez pas besoin d'aller au premier plan ici!)
• Fonctionne également avec les commandes ou fonctions internes du shell.
• Fonctionne dans un sous-shell, donc aucune exportation de variable dans le shell actuel, désolé.

Si vous n'avez pas besoin du code retour, cela peut être rendu encore plus simple:

_timeout() { ( set +b; sleep "$1" & "${@:2}" & wait -n; kill -9 `jobs -p`; ) }

Remarques:

• Au sens strict , vous n'avez pas besoin ;dans ; ), mais il fait chose plus cohérente à l' ; }-case. Et le set +bpeut aussi être laissé de côté, mais mieux vaut prévenir que guérir.

• À l'exception de --forground(probablement), vous pouvez implémenter toutes les variantes de timeoutsupports. --preserve-statusest un peu difficile, cependant. Ceci est laissé comme un exercice pour le lecteur;)

Cette recette peut être utilisée "naturellement" dans la coquille (aussi naturelle que pour flock fd):

(
set +b
sleep 20 &
{
YOUR SHELL CODE HERE
} &
wait -n
kill `jobs -p`
)

Cependant, comme expliqué ci-dessus, vous ne pouvez pas réexporter naturellement les variables d'environnement dans le shell englobant de cette façon.

Éditer:

Exemple réel: Délai d'attente __git_ps1au cas où cela prendrait trop de temps (pour des choses comme les liens SSHFS lents):

eval "__orig$(declare -f __git_ps1)" && __git_ps1() { ( git() { _timeout 0.3 /usr/bin/git "$@"; }; _timeout 0.3 __orig__git_ps1 "$@"; ) }

Edit2: Bugfix. J'ai remarqué que ce exit 137n'est pas nécessaire et rend _timeoutpeu fiable en même temps.

Edit3: gitest un die-hard, il a donc besoin d'un double truc pour fonctionner de manière satisfaisante.

Edit4: Oublié un _dans le premier _timeoutpour l'exemple GIT du monde réel.

Je préfère "timelimit", qui a au moins un paquet dans debian.

http://devel.ringlet.net/sysutils/timelimit/

Il est un peu plus agréable que le "timeout" coreutils car il imprime quelque chose lors de l'arrêt du processus, et il envoie également SIGKILL après un certain temps par défaut.

Pour expirer slowcommandaprès 1 seconde:

timeout 1 slowcommand || echo "I failed, perhaps due to time out"

Pour déterminer si la commande a expiré ou a échoué pour ses propres raisons, vérifiez si le code d'état est 124:

# ping for 3 seconds, but timeout after only 1 second
timeout 1 ping 8.8.8.8 -w3
EXIT_STATUS=$?
if [ $EXIT_STATUS -eq 124 ]
then
echo 'Process Timed Out!'
else
echo 'Process did not timeout. Something else went wrong.'
fi
exit $EXIT_STATUS

Notez que lorsque l'état de sortie est 124, vous ne savez pas s'il a expiré en raison de votre timeoutcommande, ou si la commande elle-même s'est terminée en raison d'une logique de temporisation interne qui lui est propre, puis a renvoyé 124. Vous pouvez supposer en toute sécurité dans les deux cas , cependant, qu'un délai d'attente d'une certaine sorte s'est produit.

Voir également le script http://www.pixelbeat.org/scripts/timeout dont la fonctionnalité a été intégrée dans les coreutils plus récents

Un peu hacky, mais ça marche. Ne fonctionne pas si vous avez d'autres processus de premier plan (veuillez m'aider à résoudre ce problème!)

sleep TIMEOUT & SPID=${!}; (YOUR COMMAND HERE; kill ${SPID}) & CPID=${!}; fg 1; kill ${CPID}

En fait, je pense que vous pouvez l'inverser en répondant à vos critères de bonus:

(YOUR COMMAND HERE & SPID=${!}; (sleep TIMEOUT; kill ${SPID}) & CPID=${!}; fg 1; kill ${CPID}) < asdf > fdsa

le timeout est probablement la première approche à essayer. Il se peut que vous ayez besoin d'une notification ou d'une autre commande pour l'exécuter si elle expire. Après un peu de recherche et d'expérimentation, j'ai trouvé ce script bash :

if 
    timeout 20s COMMAND_YOU_WANT_TO_EXECUTE;
    timeout 20s AS_MANY_COMMANDS_AS_YOU_WANT;
then
    echo 'OK'; #if you want a positive response
else
    echo 'Not OK';
    AND_ALTERNATIVE_COMMANDS
fi

Script simple avec clarté de code. Enregistrer dans /usr/local/bin/run:

#!/bin/bash

# run
# Run command with timeout $1 seconds.

# Timeout seconds
timeout_seconds="$1"
shift

# PID
pid=$$

# Start timeout
(
  sleep "$timeout_seconds"
  echo "Timed out after $timeout_seconds seconds"
  kill -- -$pid &>/dev/null
) &
timeout_pid=$!

# Run
"$@"

# Stop timeout
kill $timeout_pid &>/dev/null

Expire une commande trop longue:

$ run 2 sleep 10
Timed out after 2 seconds
Terminated
$

Se termine immédiatement pour une commande qui se termine:

$ run 10 sleep 2
$

Si vous connaissez déjà le nom du programme (supposons program) de se terminer après le délai d'expiration (par exemple en 3secondes), je peux apporter une solution alternative simple et quelque peu sale:

(sleep 3 && killall program) & ./program

Cela fonctionne parfaitement si j'appelle des processus de référence avec des appels système.

Il y a aussi cratimeoutpar Martin Cracauer (écrit en C pour les systèmes Unix et Linux).

# cf. http://www.cons.org/cracauer/software.html
# usage: cratimeout timeout_in_msec cmd args
cratimeout 5000 sleep 1
cratimeout 5000 sleep 600
cratimeout 5000 tail -f /dev/null
cratimeout 5000 sh -c 'while sleep 1; do date; done'

OS X n'utilise pas encore bash 4, ni n'a / usr / bin / timeout, alors voici une fonction qui fonctionne sur OS X sans home-brew ou macports qui est similaire à / usr / bin / timeout (basé sur Tino's répondre). La validation des paramètres, l'aide, l'utilisation et la prise en charge d'autres signaux sont un exercice pour le lecteur.

# implement /usr/bin/timeout only if it doesn't exist
[ -n "$(type -p timeout 2>&1)" ] || function timeout { (
    set -m +b
    sleep "$1" &
    SPID=${!}
    ("${@:2}"; RETVAL=$?; kill ${SPID}; exit $RETVAL) &
    CPID=${!}
    wait %1
    SLEEPRETVAL=$?
    if [ $SLEEPRETVAL -eq 0 ] && kill ${CPID} >/dev/null 2>&1 ; then
      RETVAL=124
      # When you need to make sure it dies
      #(sleep 1; kill -9 ${CPID} >/dev/null 2>&1)&
      wait %2
    else
      wait %2
      RETVAL=$?
    fi
    return $RETVAL
) }

Dans 99% des cas, la réponse n'est PAS d'implémenter une logique de temporisation. La logique de temporisation est dans presque toutes les situations un signe d'avertissement rouge que quelque chose d' autre ne va pas et devrait être corrigé à la place .

Votre processus est-il parfois suspendu ou interrompu après n secondes? Découvrez ensuite pourquoi et corrigez cela à la place.

En passant, pour faire correctement la solution de strager, vous devez utiliser attendre "$ SPID" au lieu de fg 1, car dans les scripts, vous n'avez pas de contrôle de travail (et essayer de l'activer est stupide). De plus, fg 1 repose sur le fait que vous n'avez démarré aucun autre travail auparavant dans le script, ce qui est une mauvaise hypothèse à faire.

On m'a présenté un problème pour préserver le contexte du shell et autoriser les délais d'expiration, le seul problème avec cela est qu'il arrêtera l'exécution du script sur le délai d'expiration - mais cela convient aux besoins qui m'ont été présentés:

#!/usr/bin/env bash

safe_kill()
{
  ps aux | grep -v grep | grep $1 >/dev/null && kill ${2:-} $1
}

my_timeout()
{
  typeset _my_timeout _waiter_pid _return
  _my_timeout=$1
  echo "Timeout($_my_timeout) running: $*"
  shift
  (
    trap "return 0" USR1
    sleep $_my_timeout
    echo "Timeout($_my_timeout) reached for: $*"
    safe_kill $$
  ) &
  _waiter_pid=$!
  "$@" || _return=$?
  safe_kill $_waiter_pid -USR1
  echo "Timeout($_my_timeout) ran: $*"
  return ${_return:-0}
}

my_timeout 3 cd scripts
my_timeout 3 pwd
my_timeout 3 true  && echo true || echo false
my_timeout 3 false && echo true || echo false
my_timeout 3 sleep 10
my_timeout 3 pwd

avec les sorties:

Timeout(3) running: 3 cd scripts
Timeout(3) ran: cd scripts
Timeout(3) running: 3 pwd
/home/mpapis/projects/rvm/rvm/scripts
Timeout(3) ran: pwd
Timeout(3) running: 3 true
Timeout(3) ran: true
true
Timeout(3) running: 3 false
Timeout(3) ran: false
false
Timeout(3) running: 3 sleep 10
Timeout(3) reached for: sleep 10
Terminated

bien sûr, je suppose qu'il y avait un dir appelé scripts

#! /bin/bash
timeout=10
interval=1
delay=3
(
    ((t = timeout)) || :

    while ((t > 0)); do
        echo "$t"
        sleep $interval
        # Check if the process still exists.
        kill -0 $$ 2> /dev/null || exit 0
        ((t -= interval)) || :
    done

    # Be nice, post SIGTERM first.
    { echo SIGTERM to $$ ; kill -s TERM $$ ; sleep $delay ; kill -0 $$ 2> /dev/null && { echo SIGKILL to $$ ; kill -s KILL $$ ; } ; }
) &

exec "$@"

Mon problème était peut-être un peu différent: je lance une commande via ssh sur une machine distante et je veux tuer le shell et les enfants si la commande se bloque.

J'utilise maintenant les éléments suivants:

ssh server '( sleep 60 && kill -9 0 ) 2>/dev/null & my_command; RC=$? ; sleep 1 ; pkill -P $! ; exit $RC'

De cette façon, la commande retourne 255 en cas d'expiration ou le code retour de la commande en cas de succès

Veuillez noter que la suppression des processus d'une session ssh est gérée différemment d'un shell interactif. Mais vous pouvez également utiliser l'option -t pour ssh pour allouer un pseudo terminal, il agit donc comme un shell interactif

Voici une version qui ne repose pas sur la création d'un processus enfant - j'avais besoin d'un script autonome qui incorporait cette fonctionnalité. Il effectue également un intervalle d'interrogation fractionné, de sorte que vous pouvez interroger plus rapidement. le délai aurait été préféré - mais je suis bloqué sur un ancien serveur

# wait_on_command <timeout> <poll interval> command
wait_on_command()
{
    local timeout=$1; shift
    local interval=$1; shift
    $* &
    local child=$!

    loops=$(bc <<< "($timeout * (1 / $interval)) + 0.5" | sed 's/\..*//g')
    ((t = loops))
    while ((t > 0)); do
        sleep $interval
        kill -0 $child &>/dev/null || return
        ((t -= 1))
    done

    kill $child &>/dev/null || kill -0 $child &>/dev/null || return
    sleep $interval
    kill -9 $child &>/dev/null
    echo Timed out
}

slow_command()
{
    sleep 2
    echo Completed normally
}

# wait 1 sec in 0.1 sec increments
wait_on_command 1 0.1 slow_command

# or call an external command
wait_on_command 1 0.1 sleep 10

Une manière très simpliste:

# command & sleep 5; pkill -9 -x -f "command"

avec pkill (option -f ), vous pouvez tuer votre commande spécifique avec des arguments ou spécifier -n pour éviter de tuer l'ancien processus.

S'appuyer sur la réponse de @ loup ...

Si vous souhaitez expirer un processus et arrêter la sortie du job kill / pid, exécutez:

( (sleep 1 && killall program 2>/dev/null) &) && program --version 

Cela met le processus en arrière-plan dans un sous-shell afin que vous ne voyiez pas la sortie du travail.

J'ai un travail cron qui appelle un script php et, parfois, il se bloque sur le script php. Cette solution était parfaite pour moi.

J'utilise:

scripttimeout -t 60 /script.php