如何避免在 Python 中覆盖信号处理程序？

Question

My experiment code is like:

import signal

def hi(signum, frame):
    print "hi"

signal.signal(signal.SIGINT, hi)
signal.signal(signal.SIGINT, signal.SIG_IGN)

hi didn't get printed, because the signal handler is overridden by signal.SIG_IGN .

How can I avoid this?

Answer 1

You could try to check whether there is already a handler. If so put your desired handler and the old handler in a wrapper function that calls both of them.

def append_signal(sig, f):

    old = None
    if callable(signal.getsignal(sig)):
        old = signal.getsignal(sig)

    def helper(*args, **kwargs):
        if old is not None:
            old(*args, **kwargs)
        f(*args, **kwargs)

    signal.signal(sig, helper)

Answer 2

If you don't want to override your own handler, check to see if you've set one:

if signal.getsignal(signal.SIGINT) in [signal.SIG_IGN, signal.SIG_DFL]:
    signal.signal(signal.SIGINT, hi)

According to the documentation , is is possible that some superior process had already reassigned the handler from the default. If you don't want to override that, add None to the list of signals.

The obvious wrapper for signal.signal(..., signal.SIG_IGN) would be a not in test.

added in response to comment

Chaining signal handlers is not often done because signals are so granular. If I really wanted to do this, I'd follow the model of atexit and register functions to be called by your handler.

Answer 3

Simply do the same as it would be done in C:

sig_hand_prev = None

def signal_handler(signum, frame):
  ...
  signal.signal(signum, sig_hand_prev)
  os.kill(os.getpid(), signum)

def install_handler(signum):
  global sig_hand_prev
  sig_hand_prev = signal.signal(signum, signal_handler)

The key idea here is that you save only the previous handler and raise it again when you finished your stuff. In this way the signal handling is a single linked list OOB.