Tiempo de espera de un comando en bash sin demoras innecesarias

Esta respuesta al comando de línea de comando para matar automáticamente un comando después de un cierto período de tiempo

propone un método de 1 línea para agotar el tiempo de espera de un comando de ejecución larga desde la línea de comando bash:

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

Pero es posible que un comando de "ejecución prolongada" finalice antes del tiempo de espera. (Llamémoslo un comando "típicamente de larga ejecución pero a veces rápido", o tlrbsf por diversión).

Entonces, este ingenioso enfoque de 1 línea tiene un par de problemas. Primero, el sleepno es condicional, por lo que establece un límite inferior indeseable en el tiempo que tarda la secuencia en terminar. Considere 30s o 2m o incluso 5m para dormir, cuando el comando tlrbsf termine en 2 segundos, muy indeseable. En segundo lugar, el killes incondicional, por lo que esta secuencia intentará matar un proceso que no se ejecuta y quejarse al respecto.

Entonces...

¿Hay alguna manera de agotar el tiempo de espera de un comando que suele ser de larga duración pero a veces rápido ( "tlrbsf" ) que

• tiene una implementación bash (la otra pregunta ya tiene respuestas de Perl y C)
• terminará en el primero de los dos: tlrbsf programa o tiempo de espera transcurrido
• no matará procesos no existentes / no en ejecución (u, opcionalmente: no se quejará de una mala eliminación)
• no tiene que ser un trazador de líneas
• puede ejecutarse bajo Cygwin o Linux

... y, para obtener puntos de bonificación, ejecuta el comando tlrbsf en primer plano y cualquier 'suspensión' o proceso adicional en segundo plano, de modo que el stdin / stdout / stderr del tlrbsf comando se pueda redirigir, como si hubiera sido correr directamente?

Si es así, por favor comparta su código. Si no, por favor explica por qué.

He pasado un tiempo tratando de hackear el ejemplo antes mencionado, pero estoy llegando al límite de mis habilidades de bash.

Creo que esto es precisamente lo que estás pidiendo:

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 <[email protected]>

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 "$@"

Probablemente esté buscando el timeoutcomando en coreutils. Como es parte de coreutils, técnicamente es una solución C, pero sigue siendo coreutils. info timeoutpara más detalles. Aquí hay un ejemplo:

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

Esta solución funciona independientemente del modo de monitor bash. Puede usar la señal adecuada para finalizar su_comando

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

El observador mata your_command después de un tiempo de espera determinado; el script espera la tarea lenta y finaliza el observador. Tenga en cuenta quewait no funciona con procesos que son hijos de un shell diferente.

Ejemplos:

• your_command se ejecuta más de 2 segundos y se finalizó

su_comando interrumpido

( 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

• your_command finalizó antes del tiempo de espera (20 segundos)

su_comando ha terminado

( 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

Ahí tienes:

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

puede cambiar el SIGINTy 10como desee;)

Puede hacer esto completamente con bash 4.3y por encima:

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

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

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

• Necesita Bash 4.3 para wait -n

• Da 137 si el comando fue asesinado, de lo contrario el valor de retorno del comando.
• Trabajos para tuberías. (¡No necesitas ir al primer plano aquí!)
• También funciona con comandos o funciones de shell internos.
• Se ejecuta en un subshell, por lo que no hay exportación de variables al shell actual, lo siento.

Si no necesita el código de retorno, esto puede simplificarse aún más:

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

Notas:

• En sentido estricto no es necesario el ;en ; ), sin embargo, hace algo más consistente a la ; }-case. Y set +bprobablemente también se pueda dejar de lado, pero es mejor prevenir que curar.

• Excepto --forground(probablemente) puede implementar todos los timeoutsoportes de variantes . --preserve-statusSin embargo, es un poco difícil. Esto se deja como un ejercicio para el lector;)

Esta receta se puede usar "naturalmente" en la cáscara (tan natural como para flock fd):

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

Sin embargo, como se explicó anteriormente, no puede reexportar las variables de entorno al shell envolvente de esta manera de forma natural.

Editar:

Ejemplo del mundo real: Tiempo de espera __git_ps1en caso de que tarde demasiado (para cosas como enlaces SSHFS lentos):

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

Edit2: Bugfix. Me di cuenta de que exit 137no es necesario y hace_timeout no confiable al mismo tiempo.

Edit3: git es un disco duro, por lo que necesita un doble truco para funcionar satisfactoriamente.

Edit4: Olvidé un _en el primero _timeoutpara el ejemplo GIT del mundo real.

Prefiero "timelimit", que tiene un paquete al menos en debian.

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

Es un poco mejor que el "tiempo de espera" de coreutils porque imprime algo al finalizar el proceso, y también envía SIGKILL después de un tiempo por defecto.

Para agotar el tiempo de espera slowcommanddespués de 1 segundo:

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

Para determinar si el comando agotó el tiempo de espera o falló por sus propios motivos, verifique si el código de estado es 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

Tenga en cuenta que cuando el estado de salida es 124, no sabe si se agotó el tiempo de espera debido a su timeoutcomando, o si el comando en sí terminó debido a alguna lógica interna de tiempo de espera propio y luego devolvió 124. Puede asumir con seguridad en cualquier caso , sin embargo, que ocurrió un tiempo de espera de algún tipo.

Consulte también el script http://www.pixelbeat.org/scripts/timeout cuya funcionalidad se ha integrado en los nuevos coreutils

Un poco hacky, pero funciona. No funciona si tienes otros procesos en primer plano (¡por favor, ayúdame a solucionar esto!)

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

En realidad, creo que puedes revertirlo, cumpliendo con tus criterios de 'bonificación':

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

el tiempo de espera es probablemente el primer enfoque para intentar. Es posible que necesite una notificación u otro comando para ejecutar si se agota el tiempo de espera. Después de bastante buscar y experimentar, se me ocurrió este 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 con claridad de código. Guardar en /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

Se agota el tiempo de espera de un comando que se ejecuta demasiado tiempo:

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

Termina inmediatamente para un comando que completa:

$ run 10 sleep 2
$

Si ya sabe el nombre del programa (supongamos program) que finalizará después del tiempo de espera (como ejemplo, 3segundos), puedo contribuir con una solución alternativa simple y algo sucia:

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

Esto funciona perfectamente si llamo procesos de referencia con llamadas al sistema.

También está cratimeoutMartin Cracauer (escrito en C para sistemas Unix y 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 todavía no usa bash 4, ni tiene / usr / bin / timeout, así que aquí hay una función que funciona en OS X sin home-brew o macports que es similar a / usr / bin / timeout (basado en Tino's responder). La validación de parámetros, la ayuda, el uso y el soporte para otras señales son un ejercicio para el lector.

# 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
) }

En el 99% de los casos, la respuesta NO es implementar ninguna lógica de tiempo de espera. La lógica de tiempo de espera es, en casi cualquier situación, una señal de advertencia roja de que algo más está mal y, en su lugar, debe solucionarse .

¿Su proceso se cuelga o se rompe después de n segundos a veces? Luego descubra por qué y solucione eso en su lugar.

Por otro lado, para hacer bien la solución de Strager, debe usar esperar "$ SPID" en lugar de fg 1, ya que en los scripts no tiene control de trabajo (e intentar activarlo es una estupidez). Además, fg 1 se basa en el hecho de que no inició ningún otro trabajo anteriormente en el script, lo cual es una mala suposición.

Se me presentó un problema para preservar el contexto de shell y permitir tiempos de espera, el único problema con él es que detendrá la ejecución del script en el tiempo de espera, pero está bien con las necesidades que se me presentaron:

#!/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

con las salidas:

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

por supuesto, supongo que había un directorio llamado 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 "$@"

Mi problema fue quizás un poco diferente: inicio un comando a través de ssh en una máquina remota y quiero matar el shell y los niños si el comando se cuelga.

Ahora uso lo siguiente:

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

De esta forma, el comando devuelve 255 cuando hubo un tiempo de espera o el código de retorno del comando en caso de éxito

Tenga en cuenta que los procesos de eliminación de una sesión ssh se manejan de manera diferente a un shell interactivo. Pero también puede usar la opción -t para ssh para asignar un pseudo terminal, por lo que actúa como un shell interactivo

Aquí hay una versión que no se basa en generar un proceso hijo: necesitaba un script independiente que integrara esta funcionalidad. También realiza un intervalo de sondeo fraccional, por lo que puede sondear más rápido. se hubiera preferido el tiempo de espera, pero estoy atascado en un servidor antiguo

# 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

Una forma muy simplista:

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

Con pkill (opción -f ) puede matar su comando específico con argumentos o especificar -n para evitar matar el proceso anterior.

Sobre la base de la respuesta de @ loup ...

Si desea agotar el tiempo de espera de un proceso y silenciar la salida kill job / pid, ejecute:

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

Esto pone el proceso en segundo plano en una subshell para que no vea la salida del trabajo.

Tengo un trabajo cron que llama un script php y, a veces, se atasca en el script php. Esta solución fue perfecta para mí.

Yo suelo:

scripttimeout -t 60 /script.php