| 1 |
"""PyUnit testing that threads honor our signal semantics""" |
| 2 |
|
| 3 |
import unittest |
| 4 |
import signal |
| 5 |
import os |
| 6 |
import sys |
| 7 |
from test.support import threading_helper |
| 8 |
import _thread as thread |
| 9 |
import time |
| 10 |
|
| 11 |
if (sys.platform[:3] == 'win'): |
| 12 |
raise unittest.SkipTest("Can't test signal on %s" % sys.platform) |
| 13 |
|
| 14 |
process_pid = os.getpid() |
| 15 |
signalled_all=thread.allocate_lock() |
| 16 |
|
| 17 |
USING_PTHREAD_COND = (sys.thread_info.name == 'pthread' |
| 18 |
and sys.thread_info.lock == 'mutex+cond') |
| 19 |
|
| 20 |
def registerSignals(for_usr1, for_usr2, for_alrm): |
| 21 |
usr1 = signal.signal(signal.SIGUSR1, for_usr1) |
| 22 |
usr2 = signal.signal(signal.SIGUSR2, for_usr2) |
| 23 |
alrm = signal.signal(signal.SIGALRM, for_alrm) |
| 24 |
return usr1, usr2, alrm |
| 25 |
|
| 26 |
|
| 27 |
# The signal handler. Just note that the signal occurred and |
| 28 |
# from who. |
| 29 |
def handle_signals(sig,frame): |
| 30 |
signal_blackboard[sig]['tripped'] += 1 |
| 31 |
signal_blackboard[sig]['tripped_by'] = thread.get_ident() |
| 32 |
|
| 33 |
# a function that will be spawned as a separate thread. |
| 34 |
def send_signals(): |
| 35 |
# We use `raise_signal` rather than `kill` because: |
| 36 |
# * It verifies that a signal delivered to a background thread still has |
| 37 |
# its Python-level handler called on the main thread. |
| 38 |
# * It ensures the signal is handled before the thread exits. |
| 39 |
signal.raise_signal(signal.SIGUSR1) |
| 40 |
signal.raise_signal(signal.SIGUSR2) |
| 41 |
signalled_all.release() |
| 42 |
|
| 43 |
|
| 44 |
@threading_helper.requires_working_threading() |
| 45 |
class ThreadSignals(unittest.TestCase): |
| 46 |
|
| 47 |
def test_signals(self): |
| 48 |
with threading_helper.wait_threads_exit(): |
| 49 |
# Test signal handling semantics of threads. |
| 50 |
# We spawn a thread, have the thread send itself two signals, and |
| 51 |
# wait for it to finish. Check that we got both signals |
| 52 |
# and that they were run by the main thread. |
| 53 |
signalled_all.acquire() |
| 54 |
self.spawnSignallingThread() |
| 55 |
signalled_all.acquire() |
| 56 |
|
| 57 |
self.assertEqual( signal_blackboard[signal.SIGUSR1]['tripped'], 1) |
| 58 |
self.assertEqual( signal_blackboard[signal.SIGUSR1]['tripped_by'], |
| 59 |
thread.get_ident()) |
| 60 |
self.assertEqual( signal_blackboard[signal.SIGUSR2]['tripped'], 1) |
| 61 |
self.assertEqual( signal_blackboard[signal.SIGUSR2]['tripped_by'], |
| 62 |
thread.get_ident()) |
| 63 |
signalled_all.release() |
| 64 |
|
| 65 |
def spawnSignallingThread(self): |
| 66 |
thread.start_new_thread(send_signals, ()) |
| 67 |
|
| 68 |
def alarm_interrupt(self, sig, frame): |
| 69 |
raise KeyboardInterrupt |
| 70 |
|
| 71 |
@unittest.skipIf(USING_PTHREAD_COND, |
| 72 |
'POSIX condition variables cannot be interrupted') |
| 73 |
@unittest.skipIf(sys.platform.startswith('linux') and |
| 74 |
not sys.thread_info.version, |
| 75 |
'Issue 34004: musl does not allow interruption of locks ' |
| 76 |
'by signals.') |
| 77 |
# Issue #20564: sem_timedwait() cannot be interrupted on OpenBSD |
| 78 |
@unittest.skipIf(sys.platform.startswith('openbsd'), |
| 79 |
'lock cannot be interrupted on OpenBSD') |
| 80 |
def test_lock_acquire_interruption(self): |
| 81 |
# Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck |
| 82 |
# in a deadlock. |
| 83 |
# XXX this test can fail when the legacy (non-semaphore) implementation |
| 84 |
# of locks is used in thread_pthread.h, see issue #11223. |
| 85 |
oldalrm = signal.signal(signal.SIGALRM, self.alarm_interrupt) |
| 86 |
try: |
| 87 |
lock = thread.allocate_lock() |
| 88 |
lock.acquire() |
| 89 |
signal.alarm(1) |
| 90 |
t1 = time.monotonic() |
| 91 |
self.assertRaises(KeyboardInterrupt, lock.acquire, timeout=5) |
| 92 |
dt = time.monotonic() - t1 |
| 93 |
# Checking that KeyboardInterrupt was raised is not sufficient. |
| 94 |
# We want to assert that lock.acquire() was interrupted because |
| 95 |
# of the signal, not that the signal handler was called immediately |
| 96 |
# after timeout return of lock.acquire() (which can fool assertRaises). |
| 97 |
self.assertLess(dt, 3.0) |
| 98 |
finally: |
| 99 |
signal.alarm(0) |
| 100 |
signal.signal(signal.SIGALRM, oldalrm) |
| 101 |
|
| 102 |
@unittest.skipIf(USING_PTHREAD_COND, |
| 103 |
'POSIX condition variables cannot be interrupted') |
| 104 |
@unittest.skipIf(sys.platform.startswith('linux') and |
| 105 |
not sys.thread_info.version, |
| 106 |
'Issue 34004: musl does not allow interruption of locks ' |
| 107 |
'by signals.') |
| 108 |
# Issue #20564: sem_timedwait() cannot be interrupted on OpenBSD |
| 109 |
@unittest.skipIf(sys.platform.startswith('openbsd'), |
| 110 |
'lock cannot be interrupted on OpenBSD') |
| 111 |
def test_rlock_acquire_interruption(self): |
| 112 |
# Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck |
| 113 |
# in a deadlock. |
| 114 |
# XXX this test can fail when the legacy (non-semaphore) implementation |
| 115 |
# of locks is used in thread_pthread.h, see issue #11223. |
| 116 |
oldalrm = signal.signal(signal.SIGALRM, self.alarm_interrupt) |
| 117 |
try: |
| 118 |
rlock = thread.RLock() |
| 119 |
# For reentrant locks, the initial acquisition must be in another |
| 120 |
# thread. |
| 121 |
def other_thread(): |
| 122 |
rlock.acquire() |
| 123 |
|
| 124 |
with threading_helper.wait_threads_exit(): |
| 125 |
thread.start_new_thread(other_thread, ()) |
| 126 |
# Wait until we can't acquire it without blocking... |
| 127 |
while rlock.acquire(blocking=False): |
| 128 |
rlock.release() |
| 129 |
time.sleep(0.01) |
| 130 |
signal.alarm(1) |
| 131 |
t1 = time.monotonic() |
| 132 |
self.assertRaises(KeyboardInterrupt, rlock.acquire, timeout=5) |
| 133 |
dt = time.monotonic() - t1 |
| 134 |
# See rationale above in test_lock_acquire_interruption |
| 135 |
self.assertLess(dt, 3.0) |
| 136 |
finally: |
| 137 |
signal.alarm(0) |
| 138 |
signal.signal(signal.SIGALRM, oldalrm) |
| 139 |
|
| 140 |
def acquire_retries_on_intr(self, lock): |
| 141 |
self.sig_recvd = False |
| 142 |
def my_handler(signal, frame): |
| 143 |
self.sig_recvd = True |
| 144 |
|
| 145 |
old_handler = signal.signal(signal.SIGUSR1, my_handler) |
| 146 |
try: |
| 147 |
def other_thread(): |
| 148 |
# Acquire the lock in a non-main thread, so this test works for |
| 149 |
# RLocks. |
| 150 |
lock.acquire() |
| 151 |
# Wait until the main thread is blocked in the lock acquire, and |
| 152 |
# then wake it up with this. |
| 153 |
time.sleep(0.5) |
| 154 |
os.kill(process_pid, signal.SIGUSR1) |
| 155 |
# Let the main thread take the interrupt, handle it, and retry |
| 156 |
# the lock acquisition. Then we'll let it run. |
| 157 |
time.sleep(0.5) |
| 158 |
lock.release() |
| 159 |
|
| 160 |
with threading_helper.wait_threads_exit(): |
| 161 |
thread.start_new_thread(other_thread, ()) |
| 162 |
# Wait until we can't acquire it without blocking... |
| 163 |
while lock.acquire(blocking=False): |
| 164 |
lock.release() |
| 165 |
time.sleep(0.01) |
| 166 |
result = lock.acquire() # Block while we receive a signal. |
| 167 |
self.assertTrue(self.sig_recvd) |
| 168 |
self.assertTrue(result) |
| 169 |
finally: |
| 170 |
signal.signal(signal.SIGUSR1, old_handler) |
| 171 |
|
| 172 |
def test_lock_acquire_retries_on_intr(self): |
| 173 |
self.acquire_retries_on_intr(thread.allocate_lock()) |
| 174 |
|
| 175 |
def test_rlock_acquire_retries_on_intr(self): |
| 176 |
self.acquire_retries_on_intr(thread.RLock()) |
| 177 |
|
| 178 |
def test_interrupted_timed_acquire(self): |
| 179 |
# Test to make sure we recompute lock acquisition timeouts when we |
| 180 |
# receive a signal. Check this by repeatedly interrupting a lock |
| 181 |
# acquire in the main thread, and make sure that the lock acquire times |
| 182 |
# out after the right amount of time. |
| 183 |
# NOTE: this test only behaves as expected if C signals get delivered |
| 184 |
# to the main thread. Otherwise lock.acquire() itself doesn't get |
| 185 |
# interrupted and the test trivially succeeds. |
| 186 |
self.start = None |
| 187 |
self.end = None |
| 188 |
self.sigs_recvd = 0 |
| 189 |
done = thread.allocate_lock() |
| 190 |
done.acquire() |
| 191 |
lock = thread.allocate_lock() |
| 192 |
lock.acquire() |
| 193 |
def my_handler(signum, frame): |
| 194 |
self.sigs_recvd += 1 |
| 195 |
old_handler = signal.signal(signal.SIGUSR1, my_handler) |
| 196 |
try: |
| 197 |
def timed_acquire(): |
| 198 |
self.start = time.monotonic() |
| 199 |
lock.acquire(timeout=0.5) |
| 200 |
self.end = time.monotonic() |
| 201 |
def send_signals(): |
| 202 |
for _ in range(40): |
| 203 |
time.sleep(0.02) |
| 204 |
os.kill(process_pid, signal.SIGUSR1) |
| 205 |
done.release() |
| 206 |
|
| 207 |
with threading_helper.wait_threads_exit(): |
| 208 |
# Send the signals from the non-main thread, since the main thread |
| 209 |
# is the only one that can process signals. |
| 210 |
thread.start_new_thread(send_signals, ()) |
| 211 |
timed_acquire() |
| 212 |
# Wait for thread to finish |
| 213 |
done.acquire() |
| 214 |
# This allows for some timing and scheduling imprecision |
| 215 |
self.assertLess(self.end - self.start, 2.0) |
| 216 |
self.assertGreater(self.end - self.start, 0.3) |
| 217 |
# If the signal is received several times before PyErr_CheckSignals() |
| 218 |
# is called, the handler will get called less than 40 times. Just |
| 219 |
# check it's been called at least once. |
| 220 |
self.assertGreater(self.sigs_recvd, 0) |
| 221 |
finally: |
| 222 |
signal.signal(signal.SIGUSR1, old_handler) |
| 223 |
|
| 224 |
|
| 225 |
def setUpModule(): |
| 226 |
global signal_blackboard |
| 227 |
|
| 228 |
signal_blackboard = { signal.SIGUSR1 : {'tripped': 0, 'tripped_by': 0 }, |
| 229 |
signal.SIGUSR2 : {'tripped': 0, 'tripped_by': 0 }, |
| 230 |
signal.SIGALRM : {'tripped': 0, 'tripped_by': 0 } } |
| 231 |
|
| 232 |
oldsigs = registerSignals(handle_signals, handle_signals, handle_signals) |
| 233 |
unittest.addModuleCleanup(registerSignals, *oldsigs) |
| 234 |
|
| 235 |
|
| 236 |
if __name__ == '__main__': |
| 237 |
unittest.main() |