fixtureqa 0.4.25__tar.gz → 0.4.26__tar.gz

{fixtureqa-0.4.25/fixtureqa.egg-info → fixtureqa-0.4.26}/PKG-INFO

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

{fixtureqa-0.4.25 → fixtureqa-0.4.26}/fixture/api/routers/perf.py

@@ -17,7 +17,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query, WebSocket, WebSock
 from fastapi.responses import FileResponse, Response, StreamingResponse
 
 from ...core.models import SessionStatus
-from ...core.perf_models import RunConfig, RunStatus
+from ...core.perf_models import RunConfig, RunStatus, est_msgs_per_order
 from ...core.perf_charts import render_latency_chart
 from ...core.perf_engine import RunRegistry
 from ...core.perf_payload import PerfConfigError
@@ -54,18 +54,6 @@ _TERMINAL = ("completed", "stopped", "error")
 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
@@ -100,17 +88,32 @@ async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
     if need_venue:
         participating.append(("venue", _require_started(sm, body.venue_session_id, "venue").config))
 
+    # Optional per-session msgs/s ceiling: validate the named session actually
+    # participates, then fold it into the effective order rate (the injector is
+    # throttled to min(configured, ceiling) — see PerfRun). mpo every message
+    # crosses the link, so each leg touches ~mpo messages per order.
+    participant_sids = {sid for sid in (body.client_session_id, body.venue_session_id) if sid}
+    csid = body.rate.ceiling_session_id
+    if body.rate.max_msgs_per_sec is not None and csid and csid not in participant_sids:
+        raise HTTPException(status_code=422, detail=(
+            f"rate.ceiling_session_id {csid!r} is not a session this run drives "
+            f"(participants: {', '.join(sorted(participant_sids)) or 'none'})"))
+    mpo = est_msgs_per_order(body)
+    effective_ops = _order_rate_per_s(body)
+    if body.rate.max_msgs_per_sec is not None:
+        effective_ops = min(effective_ops, body.rate.max_msgs_per_sec / mpo)
+
     # 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.
+    # whole server. Evaluated on the EFFECTIVE rate, so a msgs/s ceiling that
+    # holds a logged session under the limit is a legitimate escape hatch (the run
+    # is allowed, just throttled) instead of being refused outright.
     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
+        est_msg_rate = effective_ops * mpo
         safe_order_rate = DURABLE_SAFE_MSG_RATE / mpo
 
         def _flags(cfg) -> str:
@@ -122,13 +125,14 @@ async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
         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"(~{mpo} msgs/order × {effective_ops:.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."))
+                f"≤ {safe_order_rate:.0f}/s, set a per-session messages/sec ceiling "
+                f"that holds the logged session under ~{DURABLE_SAFE_MSG_RATE} msg/s, "
+                f"or convert the session(s) to a Performance session (durable_seqnums "
+                f"+ log_messages 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 "

{fixtureqa-0.4.25 → fixtureqa-0.4.26}/fixture/core/perf_engine.py

@@ -35,6 +35,7 @@ from .latency_csv_writer import LatencyCsvWriter
 from .fix_time import utc_timestamp
 from .perf_models import (
     RunConfig, RunStatus, LiveSnapshot, ClientLeg, VenueLeg, SnapshotErrors, LatencyStats,
+    est_msgs_per_order,
 )
 from .perf_payload import PayloadFactory, ScenarioSelector
 from .perf_stats import BurstGate, PerfStats, TokenBucket
@@ -189,6 +190,17 @@ class PerfRun:
         self._order_bucket = _pacer(r.orders_per_window, r.order_window_ms, r.dispatch)
         self._fill_bucket = _pacer(r.fills_per_window, r.fill_window_ms, r.fill_dispatch)
 
+        # Optional per-session messages/sec ceiling: a second smooth bucket the
+        # injector acquires in series with _order_bucket, so the effective order
+        # rate is the min of the two. ceiling_ops = max_msgs_per_sec / est-msgs/order;
+        # expressed as TokenBucket(1, window) the rate is 1000/window_ms orders/s
+        # with capacity 1 (smooth, no over-capacity acquire(n) deadlock).
+        self._ceiling_bucket: Optional[TokenBucket] = None
+        if r.max_msgs_per_sec is not None:
+            mpo = est_msgs_per_order(config)
+            self._ceiling_ops = r.max_msgs_per_sec / mpo
+            self._ceiling_bucket = TokenBucket(1, max(1, round(1000 * mpo / r.max_msgs_per_sec)))
+
         self._client_sub = None
         self._venue_sub = None
         self._tasks: list[asyncio.Task] = []
@@ -230,6 +242,15 @@ class PerfRun:
             self.warnings.append(
                 "cancel injection has no effect in venue mode (no client leg); "
                 "inbound 35=F from the external client is still answered")
+        if self._ceiling_bucket is not None and self._has_client:
+            r = self.config.rate
+            order_ops = r.orders_per_window * 1000.0 / r.order_window_ms
+            if self._ceiling_ops < order_ops:
+                who = r.ceiling_session_id or "the chosen session"
+                self.warnings.append(
+                    f"injector capped to ~{self._ceiling_ops:.0f} orders/s to hold "
+                    f"{who} under {r.max_msgs_per_sec} msg/s (order rate "
+                    f"{order_ops:.0f}/s would exceed it)")
         if self._has_client:
             self._client_sub = self._sm.subscribe_session(self.config.client_session_id)
             self._sm.mark_perf_active(self.config.client_session_id)
@@ -370,6 +391,8 @@ class PerfRun:
                 await self._dispatch_scenario(scn)
             else:
                 await self._order_bucket.acquire()
+                if self._ceiling_bucket is not None:
+                    await self._ceiling_bucket.acquire()
                 if not self._injecting:
                     break
                 msg, meta = self._factory.build_single_order()
@@ -453,6 +476,8 @@ class PerfRun:
 
         for tpl in scn.messages:
             await self._order_bucket.acquire()
+            if self._ceiling_bucket is not None:
+                await self._ceiling_bucket.acquire()   # approx in scenario mode: per message
             if not self._injecting:
                 return
             msg, meta = self._factory.build_template_message(tpl, ctx, refs)

{fixtureqa-0.4.25 → fixtureqa-0.4.26}/fixture/core/perf_models.py

@@ -40,6 +40,15 @@ class RateConfig(BaseModel):
     fill_ratio: float = Field(default=1.0, ge=0.0, le=1.0)
     allow_burst: bool = False
     max_burst_multiplier: float = Field(default=2.0, ge=1.0)
+    # Optional per-session messages/sec ceiling. The injector is throttled to the
+    # order rate that keeps the chosen session under `max_msgs_per_sec` (using
+    # est_msgs_per_order — every per-order message crosses the link, so each leg
+    # touches ~the same count). ceiling_session_id is the session it protects:
+    # informational (UI label, warning text, participant validation), not the math.
+    # Throttling only the injector keeps latency clean and can't deadlock the
+    # lifecycle (replies/acks stay immediate). None = no ceiling.
+    max_msgs_per_sec: Optional[int] = Field(default=None, gt=0)
+    ceiling_session_id: Optional[str] = None
 
 
 class TestConfig(BaseModel):
@@ -222,6 +231,20 @@ class RunConfig(BaseModel):
         return self
 
 
+def est_msgs_per_order(cfg: "RunConfig") -> int:
+    """Rough peak FIX message count generated per order — the one formula shared
+    by the durability rate guard (api/routers/perf.py) and the per-session msgs/s
+    ceiling (perf_engine.py): 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 (a tighter divisor → a more conservative cap)."""
+    n = 2 + cfg.payload.fill.fills_per_order   # order + ack + fills
+    if cfg.amend.enabled:
+        n += 2                                 # 35=G + 35=8 replace
+    if cfg.cancel.enabled:
+        n += 2                                 # 35=F + 35=8/9 reply
+    return max(1, n)
+
+
 # ---------------------------------------------------------------------------
 # Responses (read by key downstream — keep stable)
 # ---------------------------------------------------------------------------