Как правильно обработать сигнал SIGTERM?

Question

Как правильно обработать сигнал SIGTERM?

Давайте предположим, что у нас есть такой тривиальный демон, написанный на python:

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

mainloop()

и мы демонизируем это с помощью start-stop-daemon который по умолчанию отправляет SIGTERM (TERM) сигнал включен --stop,

Давайте предположим, что текущий шаг выполнен #2, И в этот самый момент мы отправляем TERM сигнал.

То, что происходит, - то, что выполнение немедленно прекращается.

Я обнаружил, что могу обработать событие сигнала, используя signal.signal(signal.SIGTERM, handler) но дело в том, что он по-прежнему прерывает текущее выполнение и передает управление handler,

Итак, мой вопрос - можно ли не прерывать текущее выполнение, а обрабатывать TERM сигнал в отдельном потоке (?), чтобы я смог установить shutdown_flag = True чтобы mainloop() был шанс остановиться изящно?

332

python daemon sigterm start-stop-daemon

Источник

user251311 28 авг '13 в 22:44

10 ответов

Решение

Во-первых, я не уверен, что вам нужен второй поток для установки shutdown_flag. Почему бы не установить его непосредственно в обработчике SIGTERM?

Альтернатива состоит в том, чтобы поднять исключение из SIGTERM обработчик, который будет распространяться вверх по стеку. Предполагая, что у вас есть правильная обработка исключений (например, с with/contextmanager а также try: ... finally: блоки) это должно быть довольно изящное отключение, как если бы вы Ctrl-C ваша программа

Пример программы 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"

Теперь посмотрите поведение 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

На этот раз я отправил это SIGTERM после 4 итераций с 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

На этот раз я включаю свой обычай SIGTERM обработчик и отправить его SIGTERM:

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

89

Источник

user65031 04 июл '14 в 12:45

Вот простой пример без потоков или классов.

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

56

Источник

user4245799 19 янв '17 в 23:21

Я думаю, что вы близки к возможному решению.

казнить mainloop в отдельном потоке и расширяем его свойством shutdown_flag, Сигнал может быть пойман с signal.signal(signal.SIGTERM, handler) в основной теме (не в отдельной теме). Обработчик сигнала должен установить shutdown_flag в True и дождитесь окончания потока thread.join()

31

Источник

user340298 29 авг '13 в 00:08

Основываясь на предыдущих ответах, я создал менеджер контекста, который защищает от sigint и 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")

18

Источник

user126434 04 май '18 в 11:44

Нашел самый простой способ для меня. Вот пример с вилкой для ясности, что этот способ полезен для управления потоком.

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)

8

Источник

user2020593 07 фев '19 в 16:43

Самое простое решение, которое я нашел, вдохновленное приведенными выше ответами, -

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)

1

Источник

user758836 11 ноя '19 в 20:47

Аналогично ответу thinkarray, но с использованием asyncio:

      loop = asyncio.get_event_loop()

def handle_signal(signum: int, frame: FrameType):
    loop.stop()
    # ...
    # additional steps to gracefully handle sigterm
    # ...
    sys.exit(signum)

signal.signal(signal.SIGINT, handle_signal)
signal.signal(signal.SIGTERM, handle_signal)
loop.run_forever()

Предполагается, что задачи планируются в цикле событий, полученном get_event_loop, и цикл останавливается на sigterm.

1

Источник

user4503593 27 июн '23 в 15:18

образец моего кода, как я использую Singnal.

      #!/usr/bin/env python

import signal
def ctrl_handler(signum, frm) :
    print " You can't cannot kill me"

print "Installing signal handler..."
signal.signal(signal.SIGINT, ctrl_handler)
print "done"

while True :

    #do somthing

    pass

1

Источник

user11164028 25 май '21 в 17:37

Вы можете установить при ловле сигнала.

threading.Event является потокобезопасным для использования и передачи, его можно ждать, и то же событие можно установить и удалить из других мест.

      import signal, threading

quit_event = threading.Event()
signal.signal(signal.SIGTERM, lambda *_args: quit_event.set())

while not quit_event.is_set():
    print("Working...")

1

Источник

user2261717 01 сен '21 в 18:10

Другие вопросы по тегам python daemon sigterm start-stop-daemon

user578989 16 июл '15 в 20:55 2015-07-16 20:55 · Accepted Answer · 2015-07-16 20:55

Чистое в использовании решение на основе классов:

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