Gereksiz gecikme olmadan bash komutunu zaman aşımı

Komut satırı komutuna verilen bu yanıt , belirli bir süre sonra bir komutu otomatik olarak öldürmek

bash komut satırından uzun süren bir komutun zaman aşımına uğraması için 1 satırlık bir yöntem önerir:

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

Ancak, belirli bir "uzun süren" komutun zaman aşımından önce bitmesi mümkündür. (Buna "tipik olarak uzun süren ama bazen hızlı" bir komut veya eğlence için tlrbsf diyelim .)

Bu şık 1 katlı yaklaşımın birkaç sorunu var. Birincisi, sleepkoşullu değildir, böylece dizinin bitmesi için geçen süre için istenmeyen bir alt sınır belirler. Tlrbsf komutu 2 saniyede bittiğinde uyku için 30s veya 2m hatta 5m düşünün - çok istenmeyen. İkincisi, killkoşulsuzdur, bu nedenle bu dizi çalışmayan bir süreci öldürmeye ve bu konuda sızlanmaya çalışacaktır.

Yani...

Genellikle uzun çalışan ama bazen hızlı ( "tlrbsf" ) komutunu zaman aşımına uğratmanın bir yolu var mı

• bir bash uygulaması var (diğer soru zaten Perl ve C cevaplarına sahip)
• ikisinin başında sona erecek : tlrbsf programın sonlandırılması veya geçen zaman aşımı
• mevcut olmayan / çalışmayan süreçleri öldürmeyecek (veya isteğe bağlı olarak: kötü bir öldürmeden şikayet etmeyecek )
• 1 astar olmak zorunda değil
• Cygwin veya Linux altında çalışabilir

... ve bonus puanlar için, tlrbsf komutunu ön planda ve arka planda herhangi bir 'uyku' veya ekstra işlemi çalıştırır, böylece tlrbsf komutunun stdin / stdout / stderr'i , sanki eskisi gibi yönlendirilebilir doğrudan koşmak?

Öyleyse, lütfen kodunuzu paylaşın. Değilse, lütfen nedenini açıklayın.

Bir süredir yukarıda bahsi geçen örneği hacklemek için harcadım ama bash becerilerimin sınırına ulaşıyorum.

Bence bu tam olarak istediğin şey:

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

Muhtemelen timeoutcoreutils komutunu arıyorsunuz . Coreutils'in bir parçası olduğundan, teknik olarak bir C çözümüdür, ancak yine de coreutils. info timeoutdaha fazla ayrıntı için. İşte bir örnek:

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

Bu çözüm, bash monitör modundan bağımsız olarak çalışır. Komutunuzu sonlandırmak için uygun sinyali kullanabilirsiniz

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

Gözcü, belirli bir zaman aşımından sonra komutunuzu öldürür; senaryo yavaş görevi bekler ve izleyiciyi sonlandırır. Bunu not etwaitFarklı bir kabuğun alt öğesi olan işlemlerle çalışmadığını .

Örnekler:

• komutunuz 2 saniyeden fazla çalışıyor ve sonlandırıldı

Komutunuz kesildi

( 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

• komutunuz zaman aşımından önce bitti (20 saniye)

Komutunuz bitti

( 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

İşte böyle:

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

Eğer değişebilir SIGINTve 10istediğiniz gibi;)

Bunu tamamen bash 4.3ve üstü ile yapabilirsiniz :

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

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

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

• Bash 4.3 İhtiyacı Var wait -n

• Komut öldürüldüyse 137 verir, aksi takdirde komutun dönüş değeri.
• Boru işleri. (Burada ön plana çıkmanıza gerek yok!)
• Dahili kabuk komutları veya işlevleriyle de çalışır.
• Bir alt kabukta çalışır, bu nedenle geçerli kabukta hiçbir değişken dışa aktarma, üzgünüm.

Dönüş koduna ihtiyacınız yoksa, bu daha da basitleştirilebilir:

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

Notlar:

• Belirtmek gerekir gerekmez konuşan ;içinde ; )ancak daha tutarlı şey yapar ; }-Örnek. Ve set +bmuhtemelen de bırakılabilir, ama üzgünümden daha güvenli.

• Dışında --forground(muhtemelen) tüm varyant timeoutdesteklerini uygulayabilirsiniz . --preserve-statusgerçi biraz zor. Bu okuyucu için bir egzersiz olarak bırakılır;)

Bu tarif kabukta "doğal olarak" kullanılabilir (olduğu kadar doğal flock fd):

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

Ancak, yukarıda açıklandığı gibi, çevre değişkenlerini çevreleyen kabuğa bu şekilde doğal olarak yeniden aktaramazsınız.

Düzenle:

Gerçek dünya örneği: __git_ps1Çok uzun sürmesi durumunda zaman aşımı (yavaş SSHFS Bağlantıları gibi şeyler için):

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

Edit2: Bugfix. Bunun exit 137gerekli olmadığını ve_timeout olmadığını ve aynı zamanda güvenilmez .

Edit3: git çok zor, bu yüzden tatmin edici bir şekilde çalışmak için bir çift hile gerekiyor.

Edit4: Gerçek dünya GIT örneği _için ilk olarak unuttum _timeout.

En azından debian'da bir paketi olan "timelimit" i tercih ederim.

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

Bu, coreutils "timeout" dan biraz daha güzel çünkü işlemi öldürürken bir şeyler yazdırıyor ve ayrıca bir süre sonra varsayılan olarak SIGKILL gönderiyor.

slowcommand1 saniye sonra zaman aşımına uğramak için :

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

Komutun kendi nedenleriyle zaman aşımına uğradığını veya başarısız olup olmadığını belirlemek için durum kodunun 124 olup olmadığını kontrol edin:

# 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

Çıkış durumu 124 olduğunda, timeoutkomutunuz nedeniyle zaman aşımına uğradı mı yoksa kendi kendine ait bazı iç zaman aşımı mantığı nedeniyle komutun kendisinin sonlandırılıp sonlandırılmayacağını ve 124'ün geri döndüğünü bilmediğinizi unutmayın. yine de, bir tür zaman aşımı oldu.

Ayrıca işlevselliği daha yeni çekirdek sunuculara entegre edilen http://www.pixelbeat.org/scripts/timeout komut dosyasına da bakın

Biraz hacky, ama işe yarıyor. Başka ön plan süreçleriniz varsa çalışmaz (lütfen bunu düzeltmeme yardım edin!)

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

Aslında, 'bonus' kriterlerinizi karşılayarak tersine çevirebileceğinizi düşünüyorum:

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

zaman aşımı muhtemelen denenecek ilk yaklaşımdır. Zaman aşımına uğradığında yürütmek için bildirime veya başka bir komuta ihtiyacınız olabilir. Biraz arama ve deneme yaptıktan sonra, bu bash betiği ile geldim :

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

Kod netliği ile basit komut dosyası. Şuraya kaydet /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

Çok uzun süre çalışan bir komutun zaman aşımına uğraması:

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

Tamamlanan bir komut için hemen sona erer:

$ run 10 sleep 2
$

programZaman aşımından sonra sonlanacak programın adını zaten varsayalım (varsayalım ) (örnek 3saniye olarak), basit ve biraz kirli bir alternatif çözüme katkıda bulunabilirim:

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

Karşılaştırma süreçlerini sistem çağrılarıyla çağırırsam bu mükemmel çalışır.

Orada da cratimeout(Unix ve Linux sistemleri için C ile yazılmış) Martin Cracauer tarafından.

# 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 henüz bash 4 kullanmıyor, ne de / usr / bin / timeout içermiyor, bu nedenle / usr / bin / timeout'a benzeyen ev yapımı veya macport olmadan OS X üzerinde çalışan bir işlev Cevap). Parametre doğrulama, yardım, kullanım ve diğer sinyaller için destek okuyucu için bir alıştırmadır.

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

Vakaların% 99'unda cevap herhangi bir zaman aşımı mantığı uygulamak DEĞİLDİR. Zaman aşımı mantığı hemen hemen her durumda başka bir şeyin yanlış olduğunu ve bunun yerine düzeltilmesi gerektiğini gösteren kırmızı bir uyarı işaretidir. .

İşleminiz bazen n saniye sonra askıda mı yoksa kopuyor mu? Sonra nedenini öğrenin ve bunun yerine düzeltin.

Bir kenara, strager çözümünü doğru yapmak için, fg 1 yerine wait "$ SPID" kullanmanız gerekir, çünkü komut dosyalarında iş kontrolünüz yoktur (ve açmaya çalışmak aptalca). Dahası, fg 1 senaryoda daha önce başka bir işe başlamadığınız gerçeğine dayanır ki bu da kötü bir varsayımdır.

Kabuk içeriğini korumak ve zaman aşımlarına izin vermek için bir sorunla karşılaştım, bununla ilgili tek sorun, zaman aşımı sırasında komut dosyasının yürütülmesini durduracak - ama sunulduğum gereksinimlerle iyi:

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

çıkışları ile:

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

tabii ki bir dir 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 "$@"

Benim sorunum belki biraz farklıydı: Uzak bir makinede ssh ile bir komut başlatıyorum ve komut kilitlenirse kabuk ve childs öldürmek istiyorum.

Şimdi aşağıdakileri kullanıyorum:

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

Bu şekilde başarı durumunda komutun bir zaman aşımı veya dönüş kodu olduğunda komut 255 değerini döndürür

Bir ssh oturumundaki öldürme işlemlerinin etkileşimli bir kabuktan farklı bir şekilde işlendiğini lütfen unutmayın. Ancak, sahte bir terminal ayırmak için ssh için -t seçeneğini de kullanabilirsiniz, bu nedenle etkileşimli bir kabuk gibi davranır

İşte bir çocuk süreç yumurtlama dayanmayan bir sürümü - Ben bu işlevselliği gömülü bağımsız bir komut dosyası gerekiyordu. Ayrıca kesirli bir anket aralığı yapar, böylece daha hızlı anket yapabilirsiniz. zaman aşımı tercih edilirdi - ama eski bir sunucuda kaldım

# 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

Çok basit bir yol:

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

ile pkill (opsiyon -f ) Eğer argümanlarla özel komutu öldürmek veya eski sürecini öldürmek önlemek için -n belirtebilirsiniz.

@ Loup'un cevabı üzerine inşa ...

Bir işlemi zaman aşımına uğratmak ve kill job / pid çıktısını susturmak istiyorsanız, şunu çalıştırın:

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

Bu, arka plandaki işlemi alt kabuğa koyar, böylece iş çıktısını görmezsiniz.

Ben bir php betiği çağıran bir cron iş var ve bazı durumlarda, php betiği takılıp. Bu çözüm benim için mükemmeldi.

Kullanırım:

scripttimeout -t 60 /script.php