Befehlszeilenbefehl zum automatischen Beenden eines Befehls nach einer bestimmten Zeit

GNU Coreutils enthält die timeout Befehl, installiert standardmäßig auf vielen Systemen.

https://www.gnu.org/software/coreutils/manual/html_node/timeout-invocation.html

Beobachten free -m für eine minute, dann töten Sie, indem Sie einen BEGRIFF signal:

timeout 1m watch free -m

InformationsquelleAutor der Antwort Roger Dahl

Habe ich ein Programm namens timeout das bedeutet, dass - die in C geschrieben sind, ursprünglich im Jahr 1989, aber aktualisiert in regelmäßigen Abständen seit dann.

Update: dieser code nicht kompilieren unter MacOS X, da SIGRTMIN ist nicht definiert, und es nicht-timeout beim laufen auf MacOS X, da die signal() Funktion dort wieder wait() nachdem der alarm mal aus - das ist nicht die erforderliche Verhalten. Ich habe eine neue version von timeout.c die sich mit beiden Problemen (mit sigaction() statt signal()). Wie vor, Kontaktieren Sie mich für ein 10K Gzip-tar-Datei mit dem Quellcode und eine manual-Seite (siehe mein Profil).

/*
@(#)File:           $RCSfile: timeout.c,v $
@(#)Version:        $Revision: 4.6 $
@(#)Last changed:   $Date: 2007/03/01 22:23:02 $
@(#)Purpose:        Run command with timeout monitor
@(#)Author:         J Leffler
@(#)Copyright:      (C) JLSS 1989,1997,2003,2005-07
*/

#define _POSIX_SOURCE       /* Enable kill() in <unistd.h> on Solaris 7 */
#define _XOPEN_SOURCE 500

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "stderr.h"

#define CHILD       0
#define FORKFAIL    -1

static const char usestr[] = "[-vV] -t time [-s signal] cmd [arg ...]";

#ifndef lint
/* Prevent over-aggressive optimizers from eliminating ID string */
const char jlss_id_timeout_c[] = "@(#)$Id: timeout.c,v 4.6 2007/03/01 22:23:02 jleffler Exp $";
#endif /* lint */

static void catcher(int signum)
{
    return;
}

int main(int argc, char **argv)
{
    pid_t   pid;
    int     tm_out;
    int     kill_signal;
    pid_t   corpse;
    int     status;
    int     opt;
    int     vflag = 0;

    err_setarg0(argv[0]);

    opterr = 0;
    tm_out = 0;
    kill_signal = SIGTERM;
    while ((opt = getopt(argc, argv, "vVt:s:")) != -1)
    {
        switch(opt)
        {
        case 'V':
            err_version("TIMEOUT", &"@(#)$Revision: 4.6 $ ($Date: 2007/03/01 22:23:02 $)"[4]);
            break;
        case 's':
            kill_signal = atoi(optarg);
            if (kill_signal <= 0 || kill_signal >= SIGRTMIN)
                err_error("signal number must be between 1 and %d\n", SIGRTMIN - 1);
            break;
        case 't':
            tm_out = atoi(optarg);
            if (tm_out <= 0)
                err_error("time must be greater than zero (%s)\n", optarg);
            break;
        case 'v':
            vflag = 1;
            break;
        default:
            err_usage(usestr);
            break;
        }
    }

    if (optind >= argc || tm_out == 0)
        err_usage(usestr);

    if ((pid = fork()) == FORKFAIL)
        err_syserr("failed to fork\n");
    else if (pid == CHILD)
    {
        execvp(argv[optind], &argv[optind]);
        err_syserr("failed to exec command %s\n", argv[optind]);
    }

    /* Must be parent -- wait for child to die */
    if (vflag)
        err_remark("time %d, signal %d, child PID %u\n", tm_out, kill_signal, (unsigned)pid);
    signal(SIGALRM, catcher);
    alarm((unsigned int)tm_out);
    while ((corpse = wait(&status)) != pid && errno != ECHILD)
    {
        if (errno == EINTR)
        {
            /* Timed out -- kill child */
            if (vflag)
                err_remark("timed out - send signal %d to process %d\n", (int)kill_signal, (int)pid);
            if (kill(pid, kill_signal) != 0)
                err_syserr("sending signal %d to PID %d - ", kill_signal, pid);
            corpse = wait(&status);
            break;
        }
    }

    alarm(0);
    if (vflag)
    {
        if (corpse == (pid_t) -1)
            err_syserr("no valid PID from waiting - ");
        else
            err_remark("child PID %u status 0x%04X\n", (unsigned)corpse, (unsigned)status);
    }

    if (corpse != pid)
        status = 2; /* Dunno what happened! */
    else if (WIFEXITED(status))
        status = WEXITSTATUS(status);
    else if (WIFSIGNALED(status))
        status = WTERMSIG(status);
    else
        status = 2; /* Dunno what happened! */

    return(status);
}

Wenn Sie wollen, dass die 'offiziellen' code für 'stderr.h' und 'stderr.c', Kontaktieren Sie mich (siehe mein Profil).

InformationsquelleAutor der Antwort Jonathan Leffler

Perl-one-liner, nur zum Spaß:

perl -e '$s = shift; $SIG{ALRM} = sub { print STDERR "Timeout!\n"; kill INT => $p }; exec(@ARGV) unless $p = fork; alarm $s; waitpid $p, 0' 10 yes foo

Diese prints " foo " für zehn Sekunden, dann auch mal aus. Ersetzen Sie '10' mit einer beliebigen Anzahl von Sekunden, und 'ja ' foo' mit einem beliebigen Befehl.

InformationsquelleAutor der Antwort vasi

Meine variation auf die perl-one-liner gibt Ihnen die exit-status ohne zu mucken mit fork() und wait() und ohne das Risiko der Tötung der falschen Prozess:

#!/bin/sh
# Usage: timelimit.sh secs cmd [ arg ... ]
exec perl -MPOSIX -e '$SIG{ALRM} = sub { print "timeout: @ARGV\n"; kill(SIGTERM, -$$); }; alarm shift; $exit = system @ARGV; exit(WIFEXITED($exit) ? WEXITSTATUS($exit) : WTERMSIG($exit));' "$@"

Grundsätzlich ist der fork() und wait() sind im inneren verborgen-system(). Die SIGALRM zugestellt wird der übergeordnete Prozess, der dann tötet sich und Ihr Kind durch senden von SIGTERM an den gesamten Prozess-Gruppe (-$$). In dem unwahrscheinlichen Fall, dass das Kind beendet und das Kind, das pid bekommt wiederverwendet vor dem kill() Auftritt, wird dies NICHT töten, den falschen Prozess, weil das neue Verfahren mit dem alten Kindes pid wird nicht in der gleichen Prozessgruppe des übergeordneten perl-Prozess.

Als zusätzlichen Vorteil, das Skript beendet sich mit dem, was ist wahrscheinlich den richtigen exit-status.

InformationsquelleAutor der Antwort bjaspan

Benutze ich "timelimit", die ein Paket im debian-repository.

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

InformationsquelleAutor der Antwort maxy

Wie über die Verwendung von dem tool erwarten?

## run a command, aborting if timeout exceeded, e.g. timed-run 20 CMD ARGS ...
timed-run() {
  # timeout in seconds
  local tmout="$1"
  shift
  env CMD_TIMEOUT="$tmout" expect -f - "$@" <<"EOF"
# expect script follows
eval spawn -noecho $argv
set timeout $env(CMD_TIMEOUT)
expect {
   timeout {
      send_error "error: operation timed out\n"
      exit 1
   }
   eof
}
EOF
}

InformationsquelleAutor der Antwort

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

Den Wächter tötet die langsame Aufgabe, nach bestimmten timeout; das Skript wartet, bis die langsame task und beendet die watcher.

Beispiele:

• Die langsame task ausführen, mehr als 2 sec und wurde beendet

Langsam task unterbrochen

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

• Diese langsame Aufgabe fertig, bevor die angegebene timeout -

Langsam beendet wurde

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

InformationsquelleAutor der Antwort Dmitry