不要な遅延なしにコマンドをbashでタイムアウトする

この回答へのコマンドラインコマンド一定の時間が経過するコマンドを自動殺します

は、bashコマンドラインから実行時間の長いコマンドをタイムアウトする1行の方法を提案しています。

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

ただし、特定の「長時間実行」コマンドがタイムアウトよりも早く終了する可能性があります。（これを「通常は長時間実行するが時々高速」なコマンド、または楽しみのためにtlrbsfと呼びましょう。）

したがって、この気の利いた1ライナーアプローチにはいくつかの問題があります。まず、これsleepは条件付きではないため、シーケンスの完了にかかる時間に望ましくない下限が設定されます。tlrbsfコマンドが2秒で終了するスリープには、30 秒、2分、さらには5分を考慮してください。これは非常に望ましくありません。第二に、killは無条件であるため、このシーケンスは、実行されていないプロセスを強制終了し、それについて駄々をこねることを試みます。

そう...

通常は長時間実行されるが時々高速な（"tlrbsf"）コマンドをタイムアウトする方法はありますか。

• bash実装があります（他の質問にはすでにPerlとCの回答があります）
• tlrbsfプログラムの終了、またはタイムアウトの経過のどちらか早い方で終了します
• 存在しない/実行されていないプロセスを強制終了しません（またはオプションで、不正な強制終了について文句を言いません）
• ワンライナーである必要はありません
• CygwinまたはLinuxで実行できます

...ボーナスポイントについては、フォアグラウンドでtlrbsfコマンドを実行し、バックグラウンドで「スリープ」または追加のプロセスを実行します。これにより、tlrbsfコマンドのstdin / stdout / stderrをリダイレクトできます。直接実行しますか？

その場合は、コードを共有してください。そうでない場合は、その理由を説明してください。

私は前述の例をハックするためにしばらく費やしてきましたが、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 は必要ありませんが; )、; }-caseとの一貫性が高まります。また、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 "$@"; ) }

Edit2：バグ修正。私はそれexit 137が必要ではないことに気づき_timeout、同時に信頼できなくなりました。

Edit3：git非常に難しいので、満足に動作するにはダブルトリックが必要です。

Edit4：実世界のGITの例の_最初のa を忘れました_timeout。

私は「timelimit」を好んでいます。これは少なくともdebianのパッケージを持っています。

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が返されたのかがわからないことに注意してください。どちらの場合も安全に想定できます。ただし、なんらかのタイムアウトが発生した。

http://www.pixelbeat.org/scripts/timeoutスクリプトも参照してください。このスクリプトの機能は、新しいcoreutilsに統合されています。

ちょっとハッキーですが、動作します。他のフォアグラウンドプロセスがある場合は機能しません（これを修正してください！）

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（UnixおよびLinuxシステム用に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（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秒後にハングまたは中断することがありますか？次に、理由を見つけて、代わりに修正します。

余談ですが、ストレッジャーのソリューションを正しく実行するには、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の答えに基づいて構築しています ...

プロセスをタイムアウトしてkill job / pid出力を無音にする場合は、次のコマンドを実行します。

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

これにより、バックグラウンドプロセスがサブシェルに配置され、ジョブの出力が表示されなくなります。

私はphpスクリプトを呼び出すcronジョブを持っていて、時々、それはphpスクリプトでスタックします。この解決策は私にとって完璧でした。

私が使う：

scripttimeout -t 60 /script.php