python - Cómo procesar la señal SIGTERM con gracia?

daemon start-stop-daemon

Question

Supongamos que tenemos un daemon tan trivial escrito en python:

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

y lo demonizamos utilizando start-stop-daemon que por defecto envía la señal SIGTERM ( TERM ) en " --stop .

Supongamos que el paso actual realizado es #2 . Y en este mismo momento estamos enviando señal TERM .

Lo que sucede es que la ejecución termina inmediatamente.

Descubrí que puedo manejar el evento de señal usando signal.signal(signal.SIGTERM, handler) pero la cosa es que aún interrumpe la ejecución actual y pasa el control al handler .

Entonces, mi pregunta es: ¿es posible no interrumpir la ejecución actual, sino manejar la señal TERM en un hilo separado (?) Para poder configurar shutdown_flag = True para que mainloop() tuviera la oportunidad de detenerse con gracia?

Answer 1

Aquí hay un ejemplo simple sin hilos o clases.

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

Answer 2

Basado en las respuestas anteriores, he creado un administrador de contexto que protege de sigint y 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")

Answer 3

Creo que estás cerca de una posible solución.

Ejecute mainloop en un hilo separado y mainloop con la propiedad shutdown_flag . La señal se puede capturar con signal.signal(signal.SIGTERM, handler) en el hilo principal (no en un hilo separado). El manejador de señal debe establecer shutdown_flag en True y esperar a que el subproceso finalice con thread.join()

Answer 4

En primer lugar, no estoy seguro de que necesite un segundo hilo para configurar shutdown_flag. ¿Por qué no configurarlo directamente en el controlador SIGTERM?

Una alternativa es generar una excepción desde el controlador SIGTERM , que se propagará por la pila. Asumiendo que tienes un manejo de excepciones adecuado (por ejemplo, con / contextmanager y try: ... finally: bloques) esto debería ser un cierre bastante elegante, similar a si tuvieras que Ctrl-C tu programa.

Ejemplo de programa 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"

Ahora vea el comportamiento de Ctrl-C:

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

Esta vez lo envío SIGTERM después de 4 iteraciones con 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

Esta vez habilito mi controlador SIGTERM personalizado y lo envío SIGTERM :

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

Answer 5

Una solución limpia basada en clases para usar:

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 :)"