Jak z wdziękiem przetwarzać sygnał SIGTERM?

197

Załóżmy, że mamy taki trywialny demon napisany w pythonie:

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

mainloop()

i demonizujemy go, używając start-stop-daemondomyślnie włączonego sygnału SIGTERM( TERM) --stop.

Załóżmy, że aktualnie wykonywany krok to #2. I w tej chwili wysyłamy TERMsygnał.

Dzieje się tak, że wykonanie kończy się natychmiast.

Przekonałem się, że mogę obsłużyć zdarzenie sygnałowe, signal.signal(signal.SIGTERM, handler)ale chodzi o to, że nadal przerywa ono bieżące wykonanie i przekazuje kontrolę handler.

Zatem moje pytanie brzmi - czy można nie przerywać bieżącego wykonania, ale obsługiwać TERMsygnał w oddzielnym wątku (?), Aby móc ustawić shutdown_flag = Truetak, aby mainloop()miał szansę zatrzymać się z gracją?

zerkms
źródło
2
Zrobiłem to, o co wcześniej signalfdprosiłeś, wykorzystując i maskując dostawę SIGTERMdo procesu.
Eric Urban

Odpowiedzi:

275

Czyste w użyciu rozwiązanie oparte na klasie:

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 not killer.kill_now:
    time.sleep(1)
    print("doing something in a loop ...")

  print("End of the program. I was killed gracefully :)")
Mayank Jaiswal
źródło
1
Dzięki za pomysł! Użyłem zmodyfikowanego podejścia w ochronie przed ponownym uruchomieniem. github.com/ryran/reboot-guard/blob/master/rguard#L284:L304
rsaw
7
To najlepsza odpowiedź (nie wymaga wątków) i powinna być preferowanym podejściem przy pierwszej próbie.
jose.angel.jimenez
2
@ Mausy5043 Python pozwala nie mieć nawiasów do definiowania klas. Chociaż jest to całkowicie w porządku dla Pythona 3.x, ale dla Pythona 2.x, najlepszą praktyką jest użycie „klasy XYZ (obiekt):”. Powodem jest: docs.python.org/2/reference/datamodel.html#newstyle
Mayank Jaiswal
2
Kontynuuj, aby utrzymać motywację, dziękuję. Używam tego cały czas.
chrisfauerbach
2
W gorszym przypadku oznaczałoby to po prostu wykonanie kolejnej iteracji przed zamknięciem z gracją. FalseWartość jest ustawiona tylko raz, a następnie można przejść tylko z false na true tak Multiple Access nie jest problemem.
Alceste_,
52

Po pierwsze, nie jestem pewien, czy potrzebujesz drugiego wątku, aby ustawić shutdown_flag.
Dlaczego nie ustawić go bezpośrednio w module obsługi SIGTERM?

Alternatywą jest zgłoszenie wyjątku od modułu SIGTERMobsługi, który będzie propagowany w górę stosu. Zakładając, że masz odpowiednią obsługę wyjątków (np. Z with/ contextmanageri try: ... finally:blokami), powinno to być dość płynne zamknięcie, podobnie jak w przypadku Ctrl+Ctwojego programu.

Przykładowy program 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"

Teraz zobacz Ctrl+Czachowanie:

$ ./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

Tym razem wysyłam go SIGTERMpo 4 iteracjach z 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

Tym razem włączam mój niestandardowy SIGTERMmoduł obsługi i wysyłam go SIGTERM:

$ ./signals-test.py handle_signal
Hello
Iteration #1
Iteration #2
Iteration #3
Iteration #4
Goodbye
$ echo $?
0
Will Manley
źródło
3
„Dlaczego nie ustawić go bezpośrednio w module obsługi SIGTERM” - ponieważ wątek roboczy przerywałby w przypadkowym miejscu. Jeśli umieścisz wiele instrukcji w pętli roboczej, zobaczysz, że twoje rozwiązanie kończy pracę pracownika na losowej pozycji, co pozostawia zadanie w nieznanym stanie.
zerkms
Działa dla mnie dobrze, również w kontekście Docker. Dzięki!
Marian
4
Jeśli po prostu ustawisz flagę i nie zgłosisz wyjątku, będzie ona taka sama jak w przypadku wątku. Dlatego używanie nici jest tutaj zbędne.
Suor
28

Myślę, że jesteś blisko możliwego rozwiązania.

Wykonaj mainloopw osobnym wątku i rozszerz go o właściwość shutdown_flag. Sygnał może zostać przechwycony signal.signal(signal.SIGTERM, handler)w głównym wątku (nie w oddzielnym wątku). Procedura obsługi sygnału powinna mieć wartość shutdown_flagTrue i czekać na zakończenie wątkuthread.join()

Moliware
źródło
4
Tak, oddzielny wątek jest tym, jak w końcu go rozwiązałem, dzięki
zerkms
7
Wątki nie są tutaj wymagane. W samym programie jednowątkowym możesz najpierw zarejestrować procedurę obsługi sygnału (rejestracja procedury obsługi sygnału nie jest blokująca), a następnie napisać pętlę główną. Funkcja obsługi sygnału powinna ustawić flagę, a pętla powinna sprawdzić tę flagę. Mam wklejony rozwiązanie oparte klasy dla samo tutaj .
Mayank Jaiswal
2
Drugi wątek nie jest konieczny. Zarejestruj procedurę obsługi sygnału.
oneloop
pomocna strona: g-loaded.eu/2016/11/24/…
Kamil Sindi
26

Oto prosty przykład bez wątków i klas.

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
tablica myślowa
źródło
11

Na podstawie poprzednich odpowiedzi stworzyłem menedżera kontekstu, który chroni przed sigint i 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")
Okke
źródło
4

Znaleziono dla mnie najprostszy sposób. Oto przykład z widelcem dla jasności, że ten sposób jest użyteczny do kontroli przepływu.

import signal
import time
import sys
import os

def handle_exit(sig, frame):
    raise(SystemExit)

def main():
    time.sleep(120)

signal.signal(signal.SIGTERM, handle_exit)

p = os.fork()
if p == 0:
    main()
    os._exit()

try:
    os.waitpid(p, 0)
except (KeyboardInterrupt, SystemExit):
    print('exit handled')
    os.kill(p, 15)
    os.waitpid(p, 0)
Kron
źródło
0

Najprostszym rozwiązaniem, jakie znalazłem, czerpiąc inspirację z powyższych odpowiedzi jest

class SignalHandler:

    def __init__(self):

        # register signal handlers
        signal.signal(signal.SIGINT, self.exit_gracefully)
        signal.signal(signal.SIGTERM, self.exit_gracefully)

        self.logger = Logger(level=ERROR)

    def exit_gracefully(self, signum, frame):
        self.logger.info('captured signal %d' % signum)
        traceback.print_stack(frame)

        ###### do your resources clean up here! ####

        raise(SystemExit)
loretoparisi
źródło