불필요한 지연없이 bash에서 명령 시간 초과

이 답변 에 에 명령 줄 명령 일정한 시간이 지나면 명령을 자동-죽일

bash 명령 줄에서 장기 실행 명령을 시간 초과하는 단선 방법을 제안합니다.

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

그러나 지정된 "장기 실행"명령이 시간 초과보다 일찍 완료 될 수 있습니다. ( "일반적으로 오래 실행되지만 때로는 빠른"명령 또는 재미를 위해 tlrbsf라고하자 .)

따라서이 멋진 1- 라이너 방식에는 몇 가지 문제가 있습니다. 첫째,는 sleep조건부가 아니므로 시퀀스가 ​​완료되는 데 걸리는 시간에 바람직하지 않은 하한을 설정합니다. tlrbsf 명령이 2 초 안에 완료 될 때 수면을 위해 30 ~ 2m 또는 5m를 고려하십시오 . 둘째, kill는 무조건적이므로이 순서는 실행 중이 아닌 프로세스를 종료시키고 그 과정에서 우회를 시도합니다.

그래서...

일반적으로 오래 실행되지만 가끔 빠른 ( "tlrbsf" ) 명령 을 시간 초과 하는 방법이 있습니까?

• bash 구현이 있습니다 (다른 질문에는 이미 Perl 및 C 답변이 있습니다)
• 두 가지의 이전에 종료됩니다 : tlrbsf의 프로그램 종료 또는 제한 시간 경과
• 존재하지 않거나 실행되지 않는 프로세스를 종료하지 않습니다 (또는 선택적 으로 나쁜 종료에 대해 불평 하지 않습니다 )
• 1- 라이너 일 필요는 없습니다
• Cygwin 또는 Linux에서 실행할 수 있습니다

... 그리고 보너스 포인트의 경우, tlrbsf 명령의 stdin / stdout / stderr가 원래의 위치 와 동일하게 리디렉션 될 수 있도록 포 그라운드에서 tlrbsf 명령을 실행하고 백그라운드 에서 'sleep'또는 추가 프로세스를 실행합니다. 직접 실행?

그렇다면 코드를 공유하십시오. 그렇지 않은 경우 이유를 설명하십시오.

앞서 언급 한 예제를 해킹하려고 잠시 시간을 보냈지 만 bash 기술의 한계에 도달했습니다.

나는 이것이 당신이 요구하는 정확하게라고 생각합니다.

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

아마도 timeoutcoreutils 에서 명령을 찾고있을 것입니다 . coreutils의 일부이므로 기술적으로 C 솔루션이지만 여전히 coreutils입니다. info timeout상세 사항은. 예를 들면 다음과 같습니다.

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

이 솔루션은 bash 모니터 모드에 관계없이 작동합니다. 적절한 신호를 사용하여 your_command를 종료 할 수 있습니다

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

감시자는 제한 시간이 초과되면 your_command를 종료합니다. 스크립트는 느린 작업을 기다렸다가 감시자를 종료합니다. 참고 wait다른 쉘의 자식 프로세스 작동하지 않습니다.

예 :

• your_command가 2 초 이상 실행되어 종료되었습니다

your_command가 중단되었습니다

( 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가 시간 초과되기 전에 완료되었습니다 (20 초).

your_command 완료

( 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

당신은 간다 :

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

당신은 변경 될 수 있습니다 SIGINT그리고 10당신이 원하는대로)

이 작업을 전적으로 bash 4.3또는 그 이상으로 수행 할 수 있습니다 .

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

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

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

• Bash 4.3 필요 wait -n

• 명령이 종료 된 경우 137을 제공하고 그렇지 않으면 명령의 리턴 값을 제공합니다.
• 파이프에 사용됩니다. (여기서는 전경으로 갈 필요가 없습니다!)
• 내부 쉘 명령 또는 기능에서도 작동합니다.
• 서브 쉘에서 실행되므로 현재 쉘로 변수를 내보낼 수 없습니다. 죄송합니다.

리턴 코드가 필요하지 않은 경우, 더 간단하게 만들 수 있습니다.

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

노트:

• 엄밀히 말하면 ;in은 필요하지 않지만 상황에 ; )더 일관성이 ; }있습니다. 그리고 set +b아마도 아마 빠져있을 수도 있지만 미안보다 안전합니다.

• --forground(아마도)를 제외하고 모든 변형 timeout지원을 구현할 수 있습니다 . --preserve-status그래도 조금 어렵습니다. 이것은 독자를위한 연습으로 남겨둔다;)

이 레시피는 쉘에서 "자연스럽게"사용할 수 있습니다 (와 마찬가지로 flock fd).

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

그러나 위에서 설명한대로 환경 변수를 자연스럽게 둘러싸는 쉘로 다시 내보낼 수 없습니다.

편집하다:

실제 예 : 시간 __git_ps1이 너무 오래 걸리면 시간이 초과 됩니다 (SSHFS 링크 속도가 느린 경우).

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

편집 2 : 버그 수정. 나는 그것이 exit 137필요하지 않고 _timeout동시에 신뢰할 수 없다는 것을 알았 습니다.

Edit3 : git다이 하드이므로 만족스럽게 작동하려면 이중 트릭이 필요합니다.

Edit4 : 실제 GIT 예제 _에서 처음으로 a 를 잊었습니다 _timeout.

나는 적어도 데비안 패키지를 가지고있는 "timelimit"를 선호합니다.

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

프로세스를 종료 할 때 무언가를 인쇄하기 때문에 coreutils "timeout"보다 조금 더 좋고 기본적으로 일정 시간 후에 SIGKILL을 보냅니다.

slowcommand1 초 후 시간 초과하려면

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

자체적 인 이유로 명령이 시간 종료되었는지 또는 실패했는지 판별하려면 상태 코드가 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

종료 상태가 124 인 timeout경우 명령으로 인해 시간 종료되었는지 또는 자체 내부 시간 초과 논리로 인해 명령 자체가 종료 된 후 124로 리턴 되는지 여부를 알 수 없습니다 . 두 경우 모두 안전하게 가정 할 수 있습니다. 그러나 어떤 종류의 시간 초과가 발생했습니다.

새로운 coreutils에 기능이 통합 된 http://www.pixelbeat.org/scripts/timeout 스크립트 도 참조하십시오.

킨다는 해 키지 만 작동합니다. 다른 포 그라운드 프로세스가있는 경우 작동하지 않습니다 (이 문제를 해결하도록 도와주세요!)

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

실제로, 나는 당신이 '보너스'기준을 충족시켜 그것을 뒤집을 수 있다고 생각합니다.

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

타임 아웃 은 아마도 첫 번째 시도 방법 일 것입니다. 시간이 초과되면 알림이나 다른 명령을 실행해야 할 수도 있습니다. 꽤 많은 검색과 실험을 거친 후이 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

코드 명확성이있는 간단한 스크립트. 저장 /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

너무 오래 실행되는 명령을 시간 초과합니다.

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

다음 명령을 완료하면 즉시 종료됩니다.

$ run 10 sleep 2
$

program시간 초과 후 종료 되는 프로그램 이름 (예 : 가정 )을 이미 알고 있다면 3간단하고 다소 더러운 대안 솔루션을 제공 할 수 있습니다.

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

시스템 호출로 벤치 마크 프로세스를 호출하면 완벽하게 작동합니다.

도 있습니다 cratimeout(유닉스와 리눅스 시스템을위한 C로 작성) 마틴 Cracauer에 의해.

# 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은 아직 bash 4를 사용하지 않으며 / usr / bin / timeout도 없으므로 / usr / bin / timeout과 비슷한 홈 브루 또는 macport가없는 OS X에서 작동하는 기능이 있습니다 (Tino의 대답). 다른 신호에 대한 매개 변수 검증, 도움말, 사용법 및 지원은 독자의 연습입니다.

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

99 %의 경우에 답은 타임 아웃 로직을 구현하지 않는 것입니다. 시간 제한 논리는 어떤 것을 거의 모든 상황에 빨간색 경고 표지판입니다 다른 사람이 잘못 고정되어야한다 대신 .

때때로 n 초 후에 프로세스가 중단되거나 중단됩니까? 그런 다음 이유를 찾아서 대신 수정하십시오.

strager의 솔루션을 올바르게 수행하려면 스크립트에서 작업 제어가 없기 때문에 fg 1 대신 대기 "$ SPID"를 사용해야합니다. 또한, fg 1은 이전에 스크립트에서 다른 작업을 시작하지 않았기 때문에 잘못된 가정입니다.

셸 컨텍스트를 유지하고 시간 초과를 허용하는 문제가 발생했습니다.이 문제의 유일한 문제는 시간 초과에서 스크립트 실행을 중지한다는 것입니다.

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

출력 :

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

물론 나는라는 디렉토리가 있다고 가정합니다. 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 "$@"

내 문제는 약간 다를 수 있습니다. 원격 컴퓨터에서 ssh를 통해 명령을 시작하고 명령이 중단되면 쉘과 자식을 죽이고 싶습니다.

나는 이제 다음을 사용한다 :

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

이 방법으로 시간 초과 또는 명령 반환 코드가있는 경우 명령은 255를 반환합니다.

ssh 세션에서 프로세스 종료는 대화식 쉘과 다르게 처리됩니다. 그러나 -t 옵션을 사용하여 의사 터미널을 할당하기 위해 ssh를 사용할 수도 있으므로 대화식 쉘처럼 작동합니다.

다음은 자식 프로세스 생성에 의존하지 않는 버전입니다.이 기능을 포함하는 독립형 스크립트가 필요했습니다. 또한 부분 폴링 간격을 수행하므로 더 빨리 폴링 할 수 있습니다. 시간 초과가 선호되었지만 이전 서버에 붙어 있습니다.

# 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

매우 간단한 방법 :

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

pkill (옵션 -f )을 사용하면 인수로 특정 명령을 종료하거나 -n을 지정하여 오래된 프로세스 를 강제 종료 할 수 있습니다.

@loup의 답변을 바탕으로 ...

프로세스를 시간 종료하고 종료 작업 / pid 출력을 침묵 시키려면 다음을 실행하십시오.

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

그러면 백그라운드 프로세스가 서브 쉘에 들어가므로 작업 출력이 표시되지 않습니다.

PHP 스크립트를 호출하는 cron 작업이 있으며 때로는 PHP 스크립트에 붙어 있습니다. 이 솔루션은 나에게 완벽했습니다.

나는 사용한다:

scripttimeout -t 60 /script.php