如何优雅地处理SIGTERM信号?


197

假设我们有一个用python编写的琐碎守护程序:

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

mainloop()

我们将它守护起来start-stop-daemon,默认情况下使用它发送SIGTERMTERM)信号--stop

假设当前执行的步骤是#2。此时此刻,我们正在发送TERM信号。

发生的事情是执行立即终止。

我发现我可以使用处理信号事件,signal.signal(signal.SIGTERM, handler)但事实是它仍然会中断当前执行并将控制权传递给handler

所以,我的问题是-它可以不中断当前执行,但处理TERM在一个独立的线程信号,使我能够设置(?) shutdown_flag = True,这样mainloop()有机会停止正常?


2
我通过使用signalfd和屏蔽SIGTERM流程的交付来满足您的要求。
Eric Urban

Answers:


275

基于类的干净使用解决方案:

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

1
谢谢你的主意!我在重新启动防护中使用了一种经过修改的方法。github.com/ryran/reboot-guard/blob/master/rguard#L284:L304
rsaw 2015年

7
这是最好的答案(不需要线程),应该是首选的尝试方法。
jose.angel.jimenez

2
@ Mausy5043 Python允许您没有括号来定义类。尽管对于python 3.x来说是完全可以的,但是对于python 2.x来说,最佳实践是使用“类XYZ(object):”。原因是:docs.python.org/2/reference/datamodel.html#newstyle
Mayank Jaiswal

2
跟进,保持动力,谢谢。我经常用这个。
chrisfauerbach '12

2
在更坏的情况下,这仅意味着在正常关闭之前进行另一次迭代。该False值仅设置一次,然后只能从False变为True,因此多路访问不是问题。
Alceste_

52

首先,我不确定您是否需要第二个线程来设置shutdown_flag
为什么不直接在SIGTERM处理程序中设置它?

一种替代方法是从SIGTERM处理程序引发异常,该异常将在堆栈中传播。假设您已经进行了适当的异常处理(例如,使用with/ contextmanagertry: ... 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

3
“为什么不直接在SIGTERM处理程序中设置它” ---因为工作线程会在随机的地方中断。如果将多个语句放入工作程序循环,您将看到解决方案将工作程序终止于随机位置,从而使作业处于未知状态。
zerkms 2014年

在Docker上下文中,对我来说效果很好。谢谢!
玛丽安

4
如果您只是设置一个标志而不引发异常,那么它将与线程相同。因此在这里使用线程是多余的。
Suor 2015年

28

我认为您已接近可能的解决方案。

mainloop在单独的线程中执行并使用属性扩展它shutdown_flag。信号可以signal.signal(signal.SIGTERM, handler)在主线程中捕获(而不是在单独的线程中)。信号处理程序应设置shutdown_flag为True并等待线程以thread.join()


4
是的,一个单独的线程是我终于解决了这个问题,谢谢
zerkms 2013年

7
此处不需要线程。在单线程程序本身中,您可以先注册一个信号处理程序(注册一个信号处理程序是非阻塞的),然后编写mainloop。信号处理函数应在何时设置一个标志,而循环应检查该标志。我已经贴了同样的一类基础的解决方案在这里
Mayank Jaiswal,2015年

2
不必再拥有第二个线程。注册信号处理程序。
2016年


26

这是一个没有线程或类的简单示例。

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

11

根据先前的答案,我创建了一个上下文管理器,可以防止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")

4

为我找到了最简单的方法。为了清楚起见,这里有一个带有fork的示例,这种方式对流量控制很有用。

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)

0

我发现的最简单的解决方案是,通过以上响应获得灵感

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)
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.