Skip to content

Secure, Fast, and Extensible Sandbox runtime for AI agents.

test(egress): release H2 admission barrier before state wait

leo pein83e4acc65ade
diff --git a/components/egress/tests/fixtures/h2_production_observer.py b/components/egress/tests/fixtures/h2_production_observer.py
index 49a1df5aa..a463ce28a 100644
--- a/components/egress/tests/fixtures/h2_production_observer.py
+++ b/components/egress/tests/fixtures/h2_production_observer.py
@@ -135,12 +135,15 @@ def running():
if not _barrier_release.exists():
emit("pre_admission_barrier_timeout", stream_id=client_stream_id)
raise RuntimeError("pre-admission test barrier timed out")
+ emit("pre_admission_release_observed", stream_id=client_stream_id,
+ before_registry_acquire=True)
admission = original(token, client_stream_id=client_stream_id)
state = live.registry.drain_state(token)
emit("pre_admission_result", stream_id=client_stream_id,
action=admission.action, reason=admission.reason,
handle_created=admission.handle is not None,
fenced=None if state is None else state.fenced,
+ frozen=None if state is None else state.frozen_last_stream_id,
registry_request_count=live.registry.request_count)
return admission
return original(token, client_stream_id=client_stream_id)
diff --git a/components/egress/tests/test_credential_bound_h2_runtime.py b/components/egress/tests/test_credential_bound_h2_runtime.py
index 110061809..64ca1ac87 100644
--- a/components/egress/tests/test_credential_bound_h2_runtime.py
+++ b/components/egress/tests/test_credential_bound_h2_runtime.py
@@ -103,6 +103,21 @@ def require(condition, message):
raise AssertionError(message)
+def pre_admission_order_is_valid(
+ entered_ns, ack_ns, release_ns, result_ns,
+ entered_sequence, release_sequence, result_sequence,
+):
+ """Prove ACK precedes release; event sequence disambiguates clock ties."""
+ timestamps = (entered_ns, ack_ns, release_ns, result_ns)
+ sequences = (entered_sequence, release_sequence, result_sequence)
+ return (
+ all(type(value) is int and value > 0 for value in timestamps)
+ and all(type(value) is int and value > 0 for value in sequences)
+ and entered_ns < ack_ns < release_ns <= result_ns
+ and entered_sequence < release_sequence < result_sequence
+ )
+
+
def wait_for(predicate, timeout=10, message="condition did not become true"):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
@@ -901,21 +916,34 @@ def case_pre_admission_barrier(harness):
"barrier did not pause the real stream before LiveRuntime.acquire_request")
harness.install(2, None, retry=True)
- fenced = harness.wait_connection(lambda state: state["fenced"])
- require(fenced["frozen"] == 1,
- "real IPC barrier scope must freeze the admitted stream-1 high-water mark")
require(harness.final_ack_ns > 0 and harness.ipc.active() is not None,
"authenticated Unix IPC fence was not acknowledged before release")
harness.barrier_release_path.write_text("release\n")
+ released = wait_for(
+ lambda: next((item for item in harness.events()
+ if item.get("kind") == "pre_admission_release_observed"), None),
+ timeout=10, message="paused admission did not observe the release after ACK")
admission = wait_for(
lambda: next((item for item in harness.events()
if item.get("kind") == "pre_admission_result"), None),
timeout=10, message="paused real admission did not resume after the fence ACK")
+ require(released.get("stream_id") == 3
+ and released.get("before_registry_acquire") is True,
+ "barrier release must be observed before the real Registry admission")
+ require(pre_admission_order_is_valid(
+ entered.get("monotonic_ns"), harness.final_ack_ns,
+ released.get("monotonic_ns"), admission.get("monotonic_ns"),
+ entered.get("sequence"), released.get("sequence"),
+ admission.get("sequence")),
+ "pre-admission order must be entered, authenticated ACK, release, then Registry result")
require(admission.get("action") == "deny"
and admission.get("reason") == "connection_fenced"
and admission.get("handle_created") is False
- and admission.get("fenced") is True,
+ and admission.get("fenced") is True
+ and admission.get("frozen") == 1
+ and admission.get("registry_request_count") == 1
+ and admission.get("stream_id") == 3,
"Registry did not deny the request that resumed after fence publication")
client.until(lambda: 3 in client.resets,
message="post-ACK pre-admission request did not receive REFUSED_STREAM")
@@ -928,10 +956,12 @@ def case_pre_admission_barrier(harness):
require(hook.get("attached") is True and hook.get("admitted") is False
and hook.get("fenced") is True and hook.get("private_token_present") is False,
"denied request acquired a handle or received credential injection")
- harness.wait_connection(lambda value: value["fenced"]
- and [item["stream_id"] for item in value["active"]] == [1])
- registry = wait_for(lambda: (state := harness.state())
- if state.get("registry_requests") == 1 else None,
+ fenced = harness.wait_connection(lambda value: value["fenced"]
+ and [item["stream_id"] for item in value["active"]] == [1])
+ require(fenced["frozen"] == 1,
+ "real IPC barrier scope must freeze the admitted stream-1 high-water mark")
+ registry = wait_for(lambda: (state if state.get("registry_requests") == 1 else None)
+ if (state := harness.state()) else None,
timeout=5, message="rejected stream changed the Registry request count")
require(registry["registry_requests"] == 1,
"the rejected stream changed the Registry request count or released the old request")
diff --git a/components/egress/tests/test_credential_bound_h2_runtime_selection.py b/components/egress/tests/test_credential_bound_h2_runtime_selection.py
index 20b7f4f4f..e65e7173c 100644
--- a/components/egress/tests/test_credential_bound_h2_runtime_selection.py
+++ b/components/egress/tests/test_credential_bound_h2_runtime_selection.py
@@ -4,6 +4,7 @@
"""Pure case-selection and denominator checks for the opt-in runtime runner."""
import unittest
+from types import SimpleNamespace
import test_credential_bound_h2_runtime as runner
@@ -16,7 +17,208 @@ def initial_cases(overrides=None):
]
+class _BarrierScheduleClient:
+ def __init__(self, harness):
+ self.harness = harness
+ self.resets = {}
+ self.headers = {}
+ self.bodies = {1: bytearray(b"old-prefix")}
+ self.ended = set()
+ self.closed = False
+ self.requests = []
+
+ def request(self, stream_id, path, logical_id):
+ self.requests.append((stream_id, path, logical_id))
+ self.harness.emit(
+ "pre_admission_barrier_entered",
+ stream_id=stream_id,
+ before_registry_acquire=True,
+ )
+
+ def until(self, predicate, timeout=10, message="condition did not become true"):
+ if not predicate():
+ raise AssertionError(message)
+
+ def credit(self):
+ self.bodies[1] = runner.BODY
+ self.ended.add(1)
+
+ def close(self):
+ self.closed = True
+
+
+class _BarrierReleasePath:
+ def __init__(self, harness):
+ self.harness = harness
+
+ def write_text(self, _value):
+ self.harness.released = True
+ self.harness.emit(
+ "pre_admission_release_observed",
+ stream_id=3,
+ before_registry_acquire=True,
+ )
+ self.harness.emit(
+ "pre_admission_result",
+ stream_id=3,
+ action="deny",
+ reason="connection_fenced",
+ handle_created=False,
+ fenced=True,
+ frozen=1,
+ registry_request_count=1,
+ )
+ self.harness.client.resets[3] = 7
+ self.harness.emit(
+ "requestheaders",
+ logical_id="new",
+ attached=True,
+ admitted=False,
+ fenced=True,
+ private_token_present=False,
+ )
+
+
+class _BarrierScheduleHarness:
+ """Stdlib-only scheduler that rejects H2 state waits while paused."""
+
+ def __init__(self):
+ self.protocol = "h2"
+ self.final_ack_ns = 0
+ self._clock = 100
+ self._sequence = 0
+ self._events = []
+ self.released = False
+ self.wait_connection_calls = 0
+ self.cleaned = False
+ self.registry_requests = 1
+ self.install_calls = []
+ self.backpressured_calls = []
+ self.origin = SimpleNamespace(records=[
+ {"path": "/v1/old", "credential": "one", "protocol": "h2"}
+ ])
+ self.client = _BarrierScheduleClient(self)
+ self.ipc = SimpleNamespace(active=lambda: {"epoch": 2})
+ self.barrier_release_path = _BarrierReleasePath(self)
+
+ def emit(self, kind, **values):
+ self._clock += 10
+ self._sequence += 1
+ self._events.append({
+ "kind": kind,
+ "monotonic_ns": self._clock,
+ "sequence": self._sequence,
+ **values,
+ })
+ return self._events[-1]
+
+ def install(self, epoch, secret=runner.SECRET_ONE, *, retry=False):
+ self.install_calls.append((epoch, secret, retry))
+ if epoch == 2:
+ self._clock += 10
+ self.final_ack_ns = self._clock
+
+ def connect(self):
+ return self.client
+
+ def backpressured(self, client):
+ self.backpressured_calls.append(client)
+ return {
+ "adapter": "BoundH2Server",
+ "client_h2": True,
+ "destination_port": 443,
+ "layer_chain": [
+ "Socks5Proxy", "NextLayer", "ServerTLSLayer",
+ "ClientTLSLayer", "NextLayer", "HttpLayer",
+ ],
+ "active": [{"stream_id": 1}],
+ }
+
+ def events(self):
+ return list(self._events)
+
+ def wait_connection(self, predicate, timeout=10):
+ self.wait_connection_calls += 1
+ if not self.released:
+ raise AssertionError(
+ "production state cannot be observed while pre-admission is paused"
+ )
+ active = [] if 1 in self.client.ended else [{"stream_id": 1}]
+ state = {"fenced": True, "frozen": 1, "active": active}
+ if not predicate(state):
+ raise AssertionError("expected production H2 state was not observed")
+ return state
+
+ def state(self):
+ return {"registry_requests": self.registry_requests}
+
+ def evidence(self):
+ return {"origin_attempt_counts": {"manual-1": 1}}
+
+ def expect_clean_runtime(self):
+ if (not self.client.closed or 1 not in self.client.ended
+ or bytes(self.client.bodies[1]) != runner.BODY):
+ raise AssertionError("old stream cleanup was not completed")
+ self.cleaned = True
+
+
class RuntimeSelectionTests(unittest.TestCase):
+ def test_pre_admission_barrier_requires_enter_ack_release_result_order(self):
+ self.assertTrue(
+ runner.pre_admission_order_is_valid(10, 20, 30, 30, 1, 2, 3)
+ )
+ self.assertFalse(
+ runner.pre_admission_order_is_valid(0, 20, 30, 30, 1, 2, 3)
+ )
+ self.assertFalse(
+ runner.pre_admission_order_is_valid(20, 10, 30, 30, 1, 2, 3)
+ )
+ self.assertFalse(
+ runner.pre_admission_order_is_valid(10, 20, 20, 30, 1, 2, 3)
+ )
+ self.assertFalse(
+ runner.pre_admission_order_is_valid(10, 20, 30, 29, 1, 2, 3)
+ )
+ self.assertFalse(
+ runner.pre_admission_order_is_valid(10, 20, 30, 30, 1, 3, 2)
+ )
+ self.assertFalse(
+ runner.pre_admission_order_is_valid(10, 20, 30, 30, True, 2, 3)
+ )
+
+ def test_pre_admission_runner_releases_before_waiting_for_h2_state(self):
+ harness = _BarrierScheduleHarness()
+ runner.case_pre_admission_barrier(harness)
+
+ events = harness.events()
+ kinds = [event["kind"] for event in events]
+ entered, released, admission = (
+ next(event for event in events if event["kind"] == kind)
+ for kind in (
+ "pre_admission_barrier_entered",
+ "pre_admission_release_observed",
+ "pre_admission_result",
+ )
+ )
+ self.assertTrue(harness.released)
+ self.assertLess(kinds.index("pre_admission_barrier_entered"),
+ kinds.index("pre_admission_release_observed"))
+ self.assertLess(kinds.index("pre_admission_release_observed"),
+ kinds.index("pre_admission_result"))
+ self.assertLess(entered["monotonic_ns"], harness.final_ack_ns)
+ self.assertLess(harness.final_ack_ns, released["monotonic_ns"])
+ self.assertLess(released["sequence"], admission["sequence"])
+ self.assertEqual(harness.client.requests, [(3, "/v1/new", "new")])
+ self.assertEqual(harness.client.resets, {3: 7})
+ self.assertNotIn(3, harness.client.headers)
+ self.assertEqual(bytes(harness.client.bodies[1]), runner.BODY)
+ self.assertEqual(harness.install_calls, [
+ (1, runner.SECRET_ONE, False), (2, None, True)
+ ])
+ self.assertEqual(harness.backpressured_calls, [harness.client])
+ self.assertEqual(harness.wait_connection_calls, 2)
+ self.assertTrue(harness.cleaned)
+
def test_no_go_client_keeps_existing_runtime_denominator(self):
self.assertEqual(runner.select_cases(None, False), runner.CASES)