fixtureqa 0.4.23__tar.gz → 0.4.24__tar.gz

{fixtureqa-0.4.23/fixtureqa.egg-info → fixtureqa-0.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.4.23
+Version: 0.4.24
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE

{fixtureqa-0.4.23 → fixtureqa-0.4.24}/fixture/api/routers/perf.py

@@ -44,6 +44,32 @@ Admin = Annotated[User, Depends(require_platform_admin)]
 
 _TERMINAL = ("completed", "stopped", "error")
 
+# Per-message persistence — durable_seqnums (fsync per message) and log_messages
+# (a messages.db write per message) — happens inline on the event loop's
+# send/receive path. Measured sustainable rate is ~36 msg/s on a local disk and
+# materially worse on a Docker/WSL2 named volume; past that the loop stalls on
+# fsync and the whole server appears frozen. We hold a conservative ceiling so a
+# logged run at a low rate still works, while a high-rate logged run is refused
+# up front (before the run starts) rather than wedging the server.
+DURABLE_SAFE_MSG_RATE = 30  # messages/second a logged/durable session can sustain
+
+
+def _est_msgs_per_order(body: RunConfig) -> int:
+    """Rough peak FIX message count generated per order, for the durability rate
+    guard: 35=D out + 35=8 ack + fills, plus a request+reply pair for each of the
+    amend / cancel flavours when enabled. Deliberately an upper-ish bound."""
+    n = 2 + body.payload.fill.fills_per_order   # order + ack + fills
+    if body.amend.enabled:
+        n += 2                                  # 35=G + 35=8 replace
+    if body.cancel.enabled:
+        n += 2                                  # 35=F + 35=8/9 reply
+    return max(1, n)
+
+
+def _order_rate_per_s(body: RunConfig) -> float:
+    r = body.rate
+    return r.orders_per_window * 1000.0 / r.order_window_ms
+
 
 def _require_started(sm: SessionManager, sid: str, label: str):
     try:
@@ -68,10 +94,45 @@ async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
     # (a sync def route runs in a threadpool with no running loop).
     need_client = body.mode in ("loopback", "manager", "client")
     need_venue = body.mode in ("loopback", "manager", "venue")
+    participating: list[tuple[str, object]] = []   # (label, config) for fixture legs
     if need_client:
-        _require_started(sm, body.client_session_id, "client")
+        participating.append(("client", _require_started(sm, body.client_session_id, "client").config))
     if need_venue:
-        _require_started(sm, body.venue_session_id, "venue")
+        participating.append(("venue", _require_started(sm, body.venue_session_id, "venue").config))
+
+    # Durability rate guard — BEFORE reg.create() (which starts the run). A
+    # session with durable_seqnums or log_messages persists every message inline
+    # on the event loop; above a low rate this stalls the loop and freezes the
+    # whole server. Allow a logged run at a safe low rate (useful to inspect the
+    # messages); refuse above it with the safe order rate spelled out.
+    logged = [(label, cfg) for label, cfg in participating
+              if cfg.durable_seqnums or cfg.log_messages]
+    durable_warnings: list[str] = []
+    if logged:
+        mpo = _est_msgs_per_order(body)
+        est_msg_rate = _order_rate_per_s(body) * mpo
+        safe_order_rate = DURABLE_SAFE_MSG_RATE / mpo
+
+        def _flags(cfg) -> str:
+            f = [n for n, on in (("durable_seqnums", cfg.durable_seqnums),
+                                 ("log_messages", cfg.log_messages)) if on]
+            return "+".join(f)
+        who = ", ".join(f"{label} ({_flags(cfg)})" for label, cfg in logged)
+
+        if est_msg_rate > DURABLE_SAFE_MSG_RATE:
+            raise HTTPException(status_code=409, detail=(
+                f"This run would generate ~{est_msg_rate:.0f} msg/s "
+                f"(~{mpo} msgs/order × {_order_rate_per_s(body):.0f} orders/s), but "
+                f"{who} persist every message inline on the event loop "
+                f"(fsync / messages.db write). Above ~{DURABLE_SAFE_MSG_RATE} msg/s "
+                f"this stalls the server. Either lower the order rate to "
+                f"≤ {safe_order_rate:.0f}/s to keep message logging, or convert the "
+                f"session(s) to a Performance session (durable_seqnums + log_messages "
+                f"off) for high-rate runs."))
+        durable_warnings.append(
+            f"message persistence is on for {who}; safe only up to "
+            f"~{safe_order_rate:.0f} orders/s (~{DURABLE_SAFE_MSG_RATE} msg/s) — at "
+            f"higher rates the event loop stalls on per-message fsync/DB writes")
 
     # CompIDs from the driving (client, else venue) session — for template tokens.
     drive_sid = body.client_session_id if need_client else body.venue_session_id
@@ -82,18 +143,7 @@ async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
     except PerfConfigError as e:
         raise HTTPException(status_code=422, detail=str(e))
 
-    # Soft perf warnings — don't block, but flag footguns.
-    checked = []
-    if need_client:
-        checked.append((body.client_session_id, "client"))
-    if need_venue:
-        checked.append((body.venue_session_id, "venue"))
-    for sid, label in checked:
-        cfg = sm.get_state(sid).config
-        if cfg.durable_seqnums:
-            run.warnings.append(f"{label} session has durable_seqnums=True — fsync per message caps throughput")
-        if cfg.log_messages:
-            run.warnings.append(f"{label} session has log_messages=True — persistence churn adds loop latency")
+    run.warnings.extend(durable_warnings)
     return {"run_id": run.run_id}
 
 

{fixtureqa-0.4.23 → fixtureqa-0.4.24/fixtureqa.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.4.23
+Version: 0.4.24
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE

{fixtureqa-0.4.23 → fixtureqa-0.4.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fixtureqa"
-version = "0.4.23"
+version = "0.4.24"
 description = "FIXture — FIX Protocol Testing Tool"
 requires-python = ">=3.10"
 dependencies = [

{fixtureqa-0.4.23 → fixtureqa-0.4.24}/tests/test_perf_api.py

@@ -15,12 +15,13 @@ def _free_port() -> int:
         return s.getsockname()[1]
 
 
-def _perf_session(port, *, acceptor: bool, sender, target, role):
+def _perf_session(port, *, acceptor: bool, sender, target, role,
+                  durable=False, log=False):
     body = {
         "sender_comp_id": sender, "target_comp_id": target,
         "connection_type": "acceptor" if acceptor else "initiator",
         "port": port, "use_file_log": False,
-        "durable_seqnums": False, "log_messages": False, "session_role": role,
+        "durable_seqnums": durable, "log_messages": log, "session_role": role,
     }
     if not acceptor:
         body["host"] = "127.0.0.1"
@@ -38,12 +39,14 @@ def _wait_status(client, sid, target, timeout=10.0):
     raise TimeoutError(f"{sid} did not reach {target} (last {st})")
 
 
-def _loopback_pair(client):
+def _loopback_pair(client, *, durable=False, log=False):
     port = _free_port()
     acc = client.post("/api/sessions/", json=_perf_session(
-        port, acceptor=True, sender="VENUE", target="CLIENT", role="venue")).json()["session_id"]
+        port, acceptor=True, sender="VENUE", target="CLIENT", role="venue",
+        durable=durable, log=log)).json()["session_id"]
     ini = client.post("/api/sessions/", json=_perf_session(
-        port, acceptor=False, sender="CLIENT", target="VENUE", role="client")).json()["session_id"]
+        port, acceptor=False, sender="CLIENT", target="VENUE", role="client",
+        durable=durable, log=log)).json()["session_id"]
     client.post(f"/api/sessions/{acc}/start")
     client.post(f"/api/sessions/{ini}/start")
     _wait_status(client, ini, "LOGGED_ON")
@@ -101,6 +104,44 @@ def test_perf_run_lifecycle_and_ws(authed):
     assert exp.status_code == 200 and exp.text.startswith("id,run_id,")
 
 
+def test_perf_run_refused_on_durable_session_at_high_rate(authed):
+    # A durable/logged session persists every message inline on the event loop;
+    # a high-rate run would stall the server, so it must be refused up front
+    # (before the run starts) — not silently freeze.
+    client, _ = authed
+    ini, acc = _loopback_pair(client, durable=True, log=True)
+    # _run_body default: 20 orders/100ms = 200 orders/s → far over the safe rate.
+    r = client.post("/api/perf/runs", json=_run_body(ini, acc, duration=2))
+    assert r.status_code == 409, r.text
+    detail = r.json()["detail"]
+    assert "Performance session" in detail and "msg/s" in detail
+
+
+def test_perf_run_allows_durable_session_at_low_rate(authed):
+    # Logging a perf run at a low rate is allowed (useful to inspect messages) —
+    # it just carries a warning about the safe ceiling.
+    client, _ = authed
+    ini, acc = _loopback_pair(client, durable=True, log=True)
+    body = _run_body(ini, acc, duration=2)
+    body["rate"] = {"orders_per_window": 1, "order_window_ms": 1000,
+                    "fills_per_window": 1, "fill_window_ms": 1000}   # 1 order/s
+    r = client.post("/api/perf/runs", json=body)
+    assert r.status_code == 201, r.text
+    run_id = r.json()["run_id"]
+    st = client.get(f"/api/perf/runs/{run_id}").json()
+    assert any("message persistence is on" in w for w in st["warnings"]), st["warnings"]
+    client.delete(f"/api/perf/runs/{run_id}")   # stop the slow run
+
+
+def test_perf_run_no_rate_limit_on_perf_sessions(authed):
+    # Performance sessions (durability off) carry no rate guard — high rate ok.
+    client, _ = authed
+    ini, acc = _loopback_pair(client)   # durable=False, log=False
+    r = client.post("/api/perf/runs", json=_run_body(ini, acc, duration=2))
+    assert r.status_code == 201, r.text
+    client.delete(f"/api/perf/runs/{r.json()['run_id']}")
+
+
 def test_perf_configs_crud(authed):
     client, _ = authed
     r = client.post("/api/perf/configs", json=_run_body("c", "v"))