Commande en ligne de commande à l'auto-tuer une commande après un certain laps de temps

GNU Coreutils comprend la délai commande, installé par défaut sur de nombreux systèmes.

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

Regarder free -m pendant une minute, puis la tuer par l'envoi d'un signal TERM:

timeout 1m watch free -m

J'ai un programme appelé timeout qui ne qui écrit en C, à l'origine, en 1989, mais périodiquement mis à jour depuis.

Mise à jour: ce code ne peut pas compiler sur mac os X, car SIGRTMIN n'est pas défini, et pas de délai d'attente lorsqu'il est exécuté sur MacOS X parce que la signal() fonction, il reprend le wait() après l'alarme de temps - ce qui n'est pas le comportement requis. J'ai une nouvelle version de timeout.c qui traite à la fois de ces problèmes (à l'aide de sigaction() au lieu de signal()). Comme avant, contactez-moi pour un 10K fichier tar compressé, avec le code source et une page de manuel (voir mon 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);
}

Si vous voulez que les "officiels" code " stderr.h " et " stderr.c', contactez-moi (voir mon profil).

Perl un liner, juste pour le plaisir:

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

Cette affiche " foo " pendant dix secondes, puis expire. Remplacer '10' avec un nombre de secondes, et "oui foo' avec toute commande.

Ma variation sur le perl one-liner vous donne le statut de sortie sans coucher avec fork() et wait() et sans le risque de tuer le mauvais processus:

#!/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));' "$@"

Fondamentalement le fork() et wait() sont cachés à l'intérieur du système(). Le SIGALRM est remis au processus parent qui tue alors lui-même et de son enfant par l'envoi d'un SIGTERM à l'ensemble du processus de groupe (-$$). Dans le cas peu probable que l'enfant quitte l'enfant et la pid obtient réutilisés avant de le tuer() se produit, ce ne sera PAS tuer le mal, car le nouveau processus avec l'ancien enfant pid ne sera pas dans le même groupe de processus de la mère perl processus.

Comme un avantage supplémentaire, le script se termine avec ce qui est probablement le bon état de sortie.

- Je utiliser "délai", qui est un paquet disponible dans le dépôt debian.

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

Une légère modification de l'perl one-liner obtiendrez le statut de sortie à droite.

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

En gros, exit ($? >> 8) mettra en avant le statut de sortie de la sous-processus. J'ai juste choisi de 77 à la sortie de statut pour les délais d'attente.

pur bash:

#!/bin/bash

if [[ $# < 2 ]]; then
  echo "Usage: $0 timeout cmd [options]"
  exit 1
fi

TIMEOUT="$1"
shift

BOSSPID=$$

(
  sleep $TIMEOUT
  kill -9 -$BOSSPID
)&
TIMERPID=$!

trap "kill -9 $TIMERPID" EXIT

eval "$@"