Wie man SIGTERM-Signal anmutig verarbeitet?

Nehmen wir an, wir haben auch so ein trivial-daemon in python geschrieben:

def mainloop():
    while True:
        # 1. do
        # 2. some
        # 3. important
        # 4. job
        # 5. sleep

mainloop()

und wir daemonize es mit start-stop-daemon die standardmäßig sendet SIGTERM (TERM) signal auf --stop.

Nehmen wir an, der aktuelle Schritt ausgeführt wird #2. Und genau in diesem moment schicken wir TERM signal.

Was passiert, ist, dass die Ausführung sofort beendet.

Ich habe festgestellt, dass ich damit umgehen kann das signal-Ereignis mit signal.signal(signal.SIGTERM, handler) aber die Sache ist, dass es immer noch unterbricht die aktuelle Ausführung und übergibt die Kontrolle an handler.

So, meine Frage ist - ist es möglich, nicht unterbrechen, das aktuelle Ausführung, sondern Griff die TERM signal in einem separaten thread (?) so, ich war in der Lage shutdown_flag = True so dass mainloop() eine chance hatte, zu stoppen, anmutig?

InformationsquelleAutor der Frage zerkms | 2013-08-28

150

Einer Klasse, auf saubere Lösung:

import signal
import time

class GracefulKiller:
  kill_now = False
  def __init__(self):
    signal.signal(signal.SIGINT, self.exit_gracefully)
    signal.signal(signal.SIGTERM, self.exit_gracefully)

  def exit_gracefully(self,signum, frame):
    self.kill_now = True

if __name__ == '__main__':
  killer = GracefulKiller()
  while True:
    time.sleep(1)
    print("doing something in a loop ...")
    if killer.kill_now:
      break

  print "End of the program. I was killed gracefully :)"

InformationsquelleAutor der Antwort Mayank Jaiswal

Erstens: ich bin nicht sicher, dass du einen zweiten thread um die shutdown_flag. Warum nicht setzen es direkt in den SIGTERM-handler?

Alternative ist, um eine Ausnahme von der SIGTERM handler, die weitergegeben wird, bis der stack. Vorausgesetzt, du hast richtiges exception handling (z.B. mit with/contextmanager und try: ... finally: Blöcke) dies sollte ein ziemlich ordnungsgemäßes Herunterfahren, ähnlich wie wenn Sie wurden zu Ctrl-C Ihr Programm.

Beispiel Programm signals-test.py:

#!/usr/bin/python

from time import sleep
import signal
import sys


def sigterm_handler(_signo, _stack_frame):
    # Raises SystemExit(0):
    sys.exit(0)

if sys.argv[1] == "handle_signal":
    signal.signal(signal.SIGTERM, sigterm_handler)

try:
    print "Hello"
    i = 0
    while True:
        i += 1
        print "Iteration #%i" % i
        sleep(1)
finally:
    print "Goodbye"

Nun die Strg-C-Verhalten:

$ ./signals-test.py default
Hello
Iteration #1
Iteration #2
Iteration #3
Iteration #4
^CGoodbye
Traceback (most recent call last):
  File "./signals-test.py", line 21, in <module>
    sleep(1)
KeyboardInterrupt
$ echo $?
1

Dieses mal schicke ich es SIGTERM nach 4 Iterationen mit kill $(ps aux | grep signals-test | awk '/python/{print $2}'):

$ ./signals-test.py default
Hello
Iteration #1
Iteration #2
Iteration #3
Iteration #4
Terminated
$ echo $?
143

Dieser Zeit, die ich aktivieren meine custom SIGTERM handler und senden Sie es SIGTERM:

$ ./signals-test.py handle_signal
Hello
Iteration #1
Iteration #2
Iteration #3
Iteration #4
Goodbye
$ echo $?
0

InformationsquelleAutor der Antwort Will Manley

27

Ich denke, Sie sind in der Nähe zu einer möglichen Lösung.

Ausführen mainloop in einem separaten thread und erweitern Sie es mit der Eigenschaft shutdown_flag. Das signal kann abgefangen werden, mit signal.signal(signal.SIGTERM, handler) im Haupt-thread (nicht in einem separaten thread). Der signal-handler sollten shutdown_flag zu Wahren und warten, bis der thread zu Ende mit thread.join()

InformationsquelleAutor der Antwort moliware

Hier ist ein einfaches Beispiel ohne Gewinde oder Klassen.

import signal

run = True

def handler_stop_signals(signum, frame):
    global run
    run = False

signal.signal(signal.SIGINT, handler_stop_signals)
signal.signal(signal.SIGTERM, handler_stop_signals)

while run:
    pass # do stuff including other IO stuff

InformationsquelleAutor der Antwort thoughtarray

Basierend auf den vorherigen Antworten, die ich erstellt habe, einen Kontext-manager schützt vor sigint und sigterm.

import logging
import signal
import sys


class TerminateProtected:
    """ Protect a piece of code from being killed by SIGINT or SIGTERM.
    It can still be killed by a force kill.

    Example:
        with TerminateProtected():
            run_func_1()
            run_func_2()

    Both functions will be executed even if a sigterm or sigkill has been received.
    """
    killed = False

    def _handler(self, signum, frame):
        logging.error("Received SIGINT or SIGTERM! Finishing this block, then exiting.")
        self.killed = True

    def __enter__(self):
        self.old_sigint = signal.signal(signal.SIGINT, self._handler)
        self.old_sigterm = signal.signal(signal.SIGTERM, self._handler)

    def __exit__(self, type, value, traceback):
        if self.killed:
            sys.exit(0)
        signal.signal(signal.SIGINT, self.old_sigint)
        signal.signal(signal.SIGTERM, self.old_sigterm)


if __name__ == '__main__':
    print("Try pressing ctrl+c while the sleep is running!")
    from time import sleep
    with TerminateProtected():
        sleep(10)
        print("Finished anyway!")
    print("This only prints if there was no sigint or sigterm")

InformationsquelleAutor der Antwort Okke

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.