field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

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()