test_fixture_lifetimes.py (15581B)
1 """Real child and socket regressions for fixture elapsed bounds and cleanup.""" 2 3 import hashlib 4 import http.client 5 import json 6 import os 7 import socket 8 import subprocess 9 import sys 10 import tempfile 11 import threading 12 import time 13 import unittest 14 from contextlib import contextmanager 15 from pathlib import Path 16 from unittest import mock 17 18 from scripts import fixture_connections as connections 19 from scripts import fixture_tool_dispatch as dispatch 20 from scripts import test_local_social_fixture as support 21 22 fixture = support.fixture 23 24 25 def wait_for(predicate, seconds=5): 26 until = time.monotonic() + seconds 27 while not predicate(): 28 if time.monotonic() >= until: 29 raise AssertionError("fixture readiness or cleanup did not complete") 30 time.sleep(0.005) 31 32 33 @contextmanager 34 def http_fixture(root, maximum=32): 35 control = root / "control" 36 control.touch() 37 state = fixture.FixtureState(root / "evidence.json", control, 0) 38 entered = threading.Event() 39 40 class Handler(fixture.BlossomHandler): 41 def setup(self): 42 super().setup() 43 entered.set() 44 45 Handler.state = state 46 server = fixture.ObservableLoopbackHTTPServer(("127.0.0.1", 0), Handler, state) 47 server.max_handlers = maximum 48 state.blossom_port = server.server_address[1] 49 thread = threading.Thread( 50 target=server.serve_forever, kwargs={"poll_interval": 0.01} 51 ) 52 thread.start() 53 try: 54 yield server, state, entered 55 finally: 56 server.shutdown() 57 server.server_close() 58 thread.join(5) 59 assert not thread.is_alive() 60 assert server.active_handlers == 0 61 assert all(not item.is_alive() for item in server._handler_threads) 62 63 64 def upload_headers(body): 65 digest = hashlib.sha256(body).hexdigest() 66 _, authorization = support.mutate_bud11_event( 67 support.bud11_event(int(time.time()), digest), "none", int(time.time()) 68 ) 69 return { 70 "Authorization": authorization, 71 "Content-Type": "image/png", 72 "Content-Length": str(len(body)), 73 "X-SHA-256": digest, 74 } 75 76 77 def request_headers(body): 78 fields = "".join( 79 f"{key}: {value}\r\n" for key, value in upload_headers(body).items() 80 ) 81 return ("PUT /upload HTTP/1.1\r\nHost: 127.0.0.1\r\n" + fields + "\r\n").encode() 82 83 84 class SelectorLifetimeTests(unittest.TestCase): 85 def test_json_success_retains_bytes_and_closed_stdin(self): 86 command = [ 87 sys.executable, 88 "-c", 89 "import sys; assert sys.stdin.read() == ''; sys.stdout.write('{\"x\":1}')", 90 ] 91 self.assertEqual(fixture.run_json_command_bounded(command, 7), {"x": 1}) 92 with self.assertRaisesRegex(ValueError, "byte bound"): 93 fixture.run_json_command_bounded(command, 6) 94 95 def test_nonzero_status_and_empty_output_remain_failures(self): 96 command = [sys.executable, "-c", "raise SystemExit(7)"] 97 with self.assertRaises(subprocess.CalledProcessError) as caught: 98 fixture.run_json_command_bounded(command, 128) 99 self.assertEqual(caught.exception.returncode, 7) 100 self.assertEqual(caught.exception.cmd, command) 101 with self.assertRaisesRegex(ValueError, "byte bound"): 102 fixture.run_json_command_bounded([sys.executable, "-c", "pass"], 128) 103 104 def test_silent_partial_and_closed_pipe_children_expire_and_are_reaped(self): 105 bodies = ["pass", "os.write(1,b'{\"x\":')", "os.close(1); os.close(2)"] 106 for body in bodies: 107 with self.subTest(body=body), tempfile.TemporaryDirectory() as directory: 108 ready = Path(directory) / "ready" 109 command = [ 110 sys.executable, 111 "-c", 112 "import os,time; from pathlib import Path; Path(" 113 + repr(str(ready)) 114 + ").write_text(str(os.getpid())); " 115 + body 116 + "; time.sleep(60)", 117 ] 118 started = time.monotonic() 119 with self.assertRaises(subprocess.TimeoutExpired): 120 fixture.run_json_command_bounded(command, 128, timeout=3) 121 self.assertTrue(ready.exists(), "Actual child readiness is required") 122 self.assertLess(time.monotonic() - started, 6) 123 with self.assertRaises(ProcessLookupError): 124 os.kill(int(ready.read_text()), 0) 125 126 def test_ignoring_descendant_is_settled_without_late_write_or_sentinel_loss(self): 127 with tempfile.TemporaryDirectory() as directory: 128 root = Path(directory) 129 sentinel = subprocess.Popen( 130 [sys.executable, "-c", "import time; time.sleep(60)"], 131 stdin=subprocess.DEVNULL, 132 stdout=subprocess.DEVNULL, 133 stderr=subprocess.DEVNULL, 134 start_new_session=True, 135 ) 136 source = """import os,signal,time 137 from pathlib import Path 138 root=Path(ROOT_LITERAL) 139 root.joinpath('leader').write_text(str(os.getpid())) 140 if os.fork()==0: 141 signal.signal(signal.SIGTERM,signal.SIG_IGN) 142 root.joinpath('descendant').write_text(str(os.getpid())) 143 os.close(1);os.close(2) 144 time.sleep(10) 145 root.joinpath('late').write_text('unexpected') 146 time.sleep(60) 147 else: 148 while not root.joinpath('descendant').exists():time.sleep(.005) 149 os.close(1);os.close(2) 150 time.sleep(60) 151 """.replace("ROOT_LITERAL", repr(str(root))) 152 try: 153 with self.assertRaises(subprocess.TimeoutExpired): 154 fixture.run_json_command_bounded( 155 [sys.executable, "-c", source], 128, timeout=3 156 ) 157 for name in ["leader", "descendant"]: 158 self.assertTrue((root / name).exists()) 159 with self.assertRaises(ProcessLookupError): 160 os.kill(int((root / name).read_text()), 0) 161 self.assertIsNone(sentinel.poll()) 162 self.assertFalse((root / "late").exists()) 163 time.sleep(0.1) 164 self.assertFalse((root / "late").exists()) 165 finally: 166 sentinel.terminate() 167 sentinel.wait(timeout=5) 168 169 def test_caller_interruption_settles_the_actual_started_child(self): 170 with tempfile.TemporaryDirectory() as directory: 171 ready = Path(directory) / "ready" 172 command = [ 173 sys.executable, 174 "-c", 175 "import os,time; from pathlib import Path; Path(" 176 + repr(str(ready)) 177 + ").write_text(str(os.getpid())); time.sleep(60)", 178 ] 179 original = dispatch.CompilerCommand.read_ready 180 delivered = False 181 182 def interrupted(capture, *args, **kwargs): 183 nonlocal delivered 184 original(capture, *args, **kwargs) 185 if ready.exists() and not delivered: 186 delivered = True 187 raise KeyboardInterrupt 188 189 with mock.patch.object(dispatch.CompilerCommand, "read_ready", interrupted): 190 with self.assertRaises(KeyboardInterrupt): 191 fixture.run_json_command_bounded(command, 128, timeout=3) 192 self.assertTrue(ready.exists()) 193 with self.assertRaises(ProcessLookupError): 194 os.kill(int(ready.read_text()), 0) 195 196 197 class SocketLifetimeTests(unittest.TestCase): 198 def test_partial_frame_drips_share_one_elapsed_deadline(self): 199 client, server = socket.socketpair() 200 finished = threading.Event() 201 values = [] 202 203 def read(): 204 values.append(fixture.read_frame(server)) 205 finished.set() 206 207 with mock.patch.object(connections, "READ_SECONDS", 0.25): 208 thread = threading.Thread(target=read) 209 thread.start() 210 try: 211 client.sendall(b"\x81\x9f") 212 started = time.monotonic() 213 while not finished.is_set() and time.monotonic() - started < 1: 214 client.sendall(b"x") 215 time.sleep(0.03) 216 self.assertTrue(finished.wait(0.5)) 217 self.assertEqual(values, [None]) 218 self.assertLess(time.monotonic() - started, 1) 219 finally: 220 client.close() 221 thread.join(1) 222 server.close() 223 self.assertFalse(thread.is_alive()) 224 225 226 class HTTPLifetimeTests(unittest.TestCase): 227 def test_teardown_keeps_owned_descriptor_until_late_reader_settles(self): 228 started = threading.Event() 229 release = threading.Event() 230 observed = [] 231 232 class Handler: 233 def __init__(self, request, client_address, server): 234 del client_address, server 235 started.set() 236 if not release.wait(connections.TEARDOWN_SECONDS): 237 observed.append("reader was not released") 238 return 239 try: 240 observed.append(request.recv(1)) 241 except OSError as error: 242 observed.append(type(error).__name__) 243 244 class JoinedReader(threading.Thread): 245 def join(self, timeout=None): 246 observed.append(("descriptor_at_join", accepted.fileno() >= 0)) 247 release.set() 248 return super().join(timeout) 249 250 client, accepted = socket.socketpair() 251 sentinel_a, sentinel_b = socket.socketpair() 252 server = connections.OwnedHTTPServer(("127.0.0.1", 0), Handler) 253 try: 254 with mock.patch.object(connections.threading, "Thread", JoinedReader): 255 server.process_request(accepted, ("127.0.0.1", 1)) 256 self.assertTrue(started.wait(connections.TEARDOWN_SECONDS)) 257 server.server_close() 258 self.assertEqual(observed, [("descriptor_at_join", True), b""]) 259 self.assertEqual(server.active_handlers, 0) 260 self.assertTrue( 261 all(not item.is_alive() for item in server._handler_threads) 262 ) 263 self.assertEqual(accepted.fileno(), -1) 264 server.server_close() 265 sentinel_a.sendall(b"alive") 266 sentinel_b.settimeout(1) 267 self.assertEqual(sentinel_b.recv(5), b"alive") 268 finally: 269 release.set() 270 client.close() 271 server.server_close() 272 sentinel_a.close() 273 sentinel_b.close() 274 275 def test_complete_authorized_body_remains_admitted(self): 276 body = b"canonical-bud11-photo" 277 headers = upload_headers(body) 278 with ( 279 tempfile.TemporaryDirectory() as directory, 280 http_fixture(Path(directory)) as (_, state, _), 281 ): 282 client = http.client.HTTPConnection( 283 "127.0.0.1", state.blossom_port, timeout=5 284 ) 285 try: 286 client.request("PUT", "/upload", body=body, headers=headers) 287 response = client.getresponse() 288 self.assertEqual(response.status, 200) 289 self.assertEqual(json.loads(response.read())["size"], len(body)) 290 finally: 291 client.close() 292 293 def test_stalled_and_partial_bodies_close_without_upload(self): 294 body = b"complete-body" 295 headers = request_headers(body) 296 for partial in [b"", body[:1]]: 297 with ( 298 self.subTest(partial=partial), 299 tempfile.TemporaryDirectory() as directory, 300 mock.patch.object(connections, "READ_SECONDS", 0.25), 301 http_fixture(Path(directory)) as (server, state, entered), 302 ): 303 with socket.create_connection( 304 server.server_address, timeout=5 305 ) as client: 306 self.assertTrue(entered.wait(5)) 307 client.sendall(headers + partial) 308 client.settimeout(2) 309 self.assertEqual(client.recv(1), b"") 310 wait_for(lambda: server.active_handlers == 0) 311 evidence = json.loads((Path(directory) / "evidence.json").read_text()) 312 self.assertEqual(evidence["upload_attempts"], 0) 313 314 def test_trickling_header_and_body_cannot_restart_deadline(self): 315 body = b"complete-body" 316 headers = request_headers(body) 317 for prefix, drip in [(b"G", b"E"), (headers, b"x")]: 318 with ( 319 self.subTest(prefix=prefix[:4]), 320 tempfile.TemporaryDirectory() as directory, 321 mock.patch.object(connections, "READ_SECONDS", 0.25), 322 http_fixture(Path(directory)) as (server, _, entered), 323 ): 324 with socket.create_connection( 325 server.server_address, timeout=5 326 ) as client: 327 self.assertTrue(entered.wait(5)) 328 client.sendall(prefix) 329 started = time.monotonic() 330 while server.active_handlers and time.monotonic() - started < 1: 331 time.sleep(0.03) 332 try: 333 client.sendall(drip) 334 except OSError: 335 break 336 wait_for(lambda: server.active_handlers == 0, 0.5) 337 self.assertLess(time.monotonic() - started, 1) 338 339 def test_active_teardown_preserves_unrelated_socket(self): 340 sentinel_a, sentinel_b = socket.socketpair() 341 client = None 342 try: 343 with ( 344 tempfile.TemporaryDirectory() as directory, 345 http_fixture(Path(directory)) as (server, _, entered), 346 ): 347 client = socket.create_connection(server.server_address, timeout=5) 348 self.assertTrue(entered.wait(5)) 349 self.assertEqual(server.active_handlers, 1) 350 self.assertEqual(server.active_handlers, 0) 351 client.settimeout(1) 352 self.assertEqual(client.recv(1), b"") 353 sentinel_a.sendall(b"alive") 354 sentinel_b.settimeout(1) 355 self.assertEqual(sentinel_b.recv(5), b"alive") 356 finally: 357 if client is not None: 358 client.close() 359 sentinel_a.close() 360 sentinel_b.close() 361 362 def test_concurrent_admission_is_bounded_and_capacity_is_released(self): 363 with ( 364 tempfile.TemporaryDirectory() as directory, 365 http_fixture(Path(directory), maximum=1) as (server, _, entered), 366 ): 367 with socket.create_connection(server.server_address, timeout=5) as first: 368 self.assertTrue(entered.wait(5)) 369 with socket.create_connection( 370 server.server_address, timeout=5 371 ) as excess: 372 self.assertEqual(excess.recv(1), b"") 373 self.assertEqual(server.active_handlers, 1) 374 first.shutdown(socket.SHUT_RDWR) 375 wait_for(lambda: server.active_handlers == 0) 376 entered.clear() 377 with socket.create_connection( 378 server.server_address, timeout=5 379 ) as replacement: 380 self.assertTrue(entered.wait(5)) 381 self.assertEqual(server.active_handlers, 1) 382 replacement.sendall(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n") 383 self.assertTrue(replacement.recv(4096).startswith(b"HTTP/1.1 404")) 384 385 386 if __name__ == "__main__": 387 unittest.main()