fixtureqa 0.4.26__tar.gz → 0.4.28__tar.gz

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

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

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

@@ -80,19 +80,25 @@ def _require_started(sm: SessionManager, sid: str, label: str):
 async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
     # async so PerfRun.start()'s asyncio.create_task runs on the event loop
     # (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")
+    need_client = body.mode in ("loopback", "manager", "client", "middle_manager")
+    need_venue = body.mode in ("loopback", "manager", "venue", "middle_manager")
     participating: list[tuple[str, object]] = []   # (label, config) for fixture legs
     if need_client:
         participating.append(("client", _require_started(sm, body.client_session_id, "client").config))
     if need_venue:
         participating.append(("venue", _require_started(sm, body.venue_session_id, "venue").config))
+    if body.mode == "middle_manager":
+        # The relay's two sessions are driven too — require them started and let the
+        # durable guard / ceiling participant set cover them like any other leg.
+        participating.append(("relay_in", _require_started(sm, body.relay_in_session_id, "relay_in").config))
+        participating.append(("relay_out", _require_started(sm, body.relay_out_session_id, "relay_out").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}
+    participant_sids = {sid for sid in (body.client_session_id, body.venue_session_id,
+                                        body.relay_in_session_id, body.relay_out_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=(
@@ -291,7 +297,7 @@ async def run_chart(run_id: str, reg: REG, _admin: Admin,
     # label it so the chart can't be misread as the single-clock measurement.
     st = reg.get_status(run_id)
     one_way_label = None
-    if st is not None and st.mode not in ("loopback", "manager"):
+    if st is not None and st.mode not in ("loopback", "manager", "middle_manager"):
         one_way_label = "one-way (tag-60 wire send → recv; needs synced clocks)"
     out_path = f"{csv_path[:-len('.csv.gz')]}_{metric}_{agg}_{scale}.png"
     if not os.path.exists(out_path):

{fixtureqa-0.4.26 → fixtureqa-0.4.28}/fixture/core/perf_charts.py

@@ -33,10 +33,14 @@ _KIND_COLOR = {
     "canceled": "#2dd4bf",
     "cancel-reject": "#f43f5e",
     "amend-reject": "#ef4444",
+    "relay-down": "#34d399",       # middle_manager relay pass-through, client→venue
+    "relay-up": "#10b981",         # middle_manager relay pass-through, venue→client
 }
-# Drawing order: order lifecycle, then amend, then cancel (request before reply).
+# Drawing order: order lifecycle, then amend, then cancel (request before reply),
+# then the middle_manager relay pass-through pair.
 _KIND_ORDER = ["order", "ack", "fill", "amend", "pending-replace", "replace",
-               "cancel", "pending-cancel", "canceled", "cancel-reject", "amend-reject"]
+               "cancel", "pending-cancel", "canceled", "cancel-reject", "amend-reject",
+               "relay-down", "relay-up"]
 
 # Per metric: (latency column, x-axis column, axis label).
 _METRIC = {

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

@@ -32,10 +32,11 @@ from typing import Optional
 from fixcore.message.message import Message
 
 from .latency_csv_writer import LatencyCsvWriter
+from .fix_builder import build_message_from_raw
 from .fix_time import utc_timestamp
 from .perf_models import (
-    RunConfig, RunStatus, LiveSnapshot, ClientLeg, VenueLeg, SnapshotErrors, LatencyStats,
-    est_msgs_per_order,
+    RunConfig, RunStatus, LiveSnapshot, ClientLeg, VenueLeg, RelayLeg, SnapshotErrors,
+    LatencyStats, est_msgs_per_order,
 )
 from .perf_payload import PayloadFactory, ScenarioSelector
 from .perf_stats import BurstGate, PerfStats, TokenBucket
@@ -142,11 +143,15 @@ class PerfRun:
         self._draining_full = False   # pause timeout sweeper during a full drain
         self._injecting = True
 
-        self._has_client = config.mode in ("loopback", "manager", "client")
-        self._has_venue = config.mode in ("loopback", "manager", "venue")
+        self._has_client = config.mode in ("loopback", "manager", "client", "middle_manager")
+        self._has_venue = config.mode in ("loopback", "manager", "venue", "middle_manager")
+        # middle_manager: a 2-session relay (relay_in acceptor + relay_out initiator)
+        # spliced between the gen-client and the venue. The relay forwards verbatim
+        # and times its own pass-through; the injector/correlator/venue are unchanged.
+        self._has_relay = config.mode == "middle_manager"
         # One-way per-message latency (recv at far leg − send at near leg) needs
-        # both legs in this process on one clock — i.e. loopback/manager. In
-        # client/venue mode we only see one leg, so the recorder falls back to
+        # both legs in this process on one clock — i.e. loopback/manager/middle_manager.
+        # In client/venue mode we only see one leg, so the recorder falls back to
         # round-trip (see _emit_crossing / _record_rt).
         self._one_way = self._has_client and self._has_venue
 
@@ -203,6 +208,9 @@ class PerfRun:
 
         self._client_sub = None
         self._venue_sub = None
+        self._relay_in_sub = None
+        self._relay_out_sub = None
+        self._relay_dd = None        # DataDictionary for group-safe relay re-emit
         self._tasks: list[asyncio.Task] = []
         self._main: Optional[asyncio.Task] = None
         self._stop = asyncio.Event()
@@ -257,6 +265,15 @@ class PerfRun:
         if self._has_venue:
             self._venue_sub = self._sm.subscribe_session(self.config.venue_session_id)
             self._sm.mark_perf_active(self.config.venue_session_id)
+        if self._has_relay:
+            self._relay_in_sub = self._sm.subscribe_session(self.config.relay_in_session_id)
+            self._sm.mark_perf_active(self.config.relay_in_session_id)
+            self._relay_out_sub = self._sm.subscribe_session(self.config.relay_out_session_id)
+            self._sm.mark_perf_active(self.config.relay_out_session_id)
+            try:
+                self._relay_dd = self._sm.get_data_dictionary(self.config.relay_out_session_id)
+            except Exception:
+                self._relay_dd = None   # flat re-emit still works for non-group messages
         self._writer.write_run(self._run_record())
         self._main = asyncio.create_task(self._run())
 
@@ -275,6 +292,8 @@ class PerfRun:
             tasks += [self._injector(), self._correlator(), self._timeout_sweeper()]
         if self._has_venue:
             tasks += [self._fill_dispatcher(), self._fill_sender()]
+        if self._has_relay:
+            tasks += [self._relay_forward("down"), self._relay_forward("up")]
         self._tasks = [asyncio.create_task(t) for t in tasks]
         dur = self.config.test.duration
         try:
@@ -323,6 +342,12 @@ class PerfRun:
         if self._venue_sub:
             self._venue_sub.close()
             self._sm.unmark_perf_active(self.config.venue_session_id)
+        if self._relay_in_sub:
+            self._relay_in_sub.close()
+            self._sm.unmark_perf_active(self.config.relay_in_session_id)
+        if self._relay_out_sub:
+            self._relay_out_sub.close()
+            self._sm.unmark_perf_active(self.config.relay_out_session_id)
         if self._latency_csv is not None:
             # Correlator is cancelled (no more enqueues); drain + gzip-finalize
             # off-loop — close() joins the writer thread.
@@ -424,6 +449,50 @@ class PerfRun:
         self._finalize(entry, "dropped")
         return True
 
+    # ------------------------------------------------------------------
+    # Relay forwarder (middle_manager)
+    # ------------------------------------------------------------------
+
+    async def _relay_forward(self, direction: str) -> None:
+        """Verbatim FIX relay for middle_manager. "down" reads relay_in (from the
+        gen-client) and re-emits on relay_out (to the venue); "up" is the reverse.
+        The message body forwards as-is (correlation + ClOrdID preserved) while
+        the destination session stamps its own comp-ids/seqnum on send. Times the
+        per-hop pass-through and optionally injects an ordered delay. A single
+        coroutine per direction keeps forwarding FIFO (no reordering)."""
+        down = direction == "down"
+        sub = self._relay_in_sub if down else self._relay_out_sub
+        dst = self.config.relay_out_session_id if down else self.config.relay_in_session_id
+        reservoir = self.stats.relay_down_latency if down else self.stats.relay_up_latency
+        kind = "relay-down" if down else "relay-up"
+        rcfg = self.config.relay
+        while True:
+            inb = await sub.get()
+            if inb.admin:
+                continue   # session-level (Logon/Heartbeat/…) is per-session, not relayed
+            recv_ns = inb.recv_perf_ns or time.perf_counter_ns()
+            if rcfg.inject_delay_ms or rcfg.jitter_ms:
+                delay = rcfg.inject_delay_ms + (random.random() * rcfg.jitter_ms)
+                if delay > 0:
+                    await asyncio.sleep(delay / 1000.0)
+            try:
+                msg = build_message_from_raw(inb.raw, self._relay_dd)
+            except Exception:
+                continue   # unparseable (shouldn't happen) — drop, don't wedge the loop
+            pass_us = (time.perf_counter_ns() - recv_ns) / 1000.0
+            if await self._send(dst, msg):
+                reservoir.add(pass_us)
+                if down:
+                    self.stats.relay_fwd_down += 1
+                else:
+                    self.stats.relay_fwd_up += 1
+                self._emit_crossing(
+                    corr=inb.fields.get(self.config.correlation_tag),
+                    clordid=inb.fields.get(T_CLORDID), exec_id=None, kind=kind,
+                    direction="c2v" if down else "v2c",
+                    send_at=time.time(), recv_at=time.time(), req_send_at=None,
+                    one_way_us=pass_us, round_trip_us=None)
+
     async def _send(self, session_id: str, msg: Message) -> bool:
         """Single send path — tallies every outbound app message per leg
         (type-agnostic) for the messages-per-second chart, then delegates."""
@@ -431,8 +500,9 @@ class PerfRun:
         if ok:
             if session_id == self.config.client_session_id:
                 self.stats.msgs_sent_client += 1
-            else:
+            elif session_id == self.config.venue_session_id:
                 self.stats.msgs_sent_venue += 1
+            # relay (middle_manager) sends are tallied by _relay_forward, not here
         return ok
 
     async def _send_order(self, corr: str, msg: Message) -> bool:
@@ -1284,11 +1354,22 @@ class PerfRun:
                 cancels_uncorrelated=self.stats.cancels_uncorrelated,
                 msgs_out_live=round(r.mvo, 1),
                 msgs_in_live=round(r.mvi, 1))
+        relay = None
+        if self._has_relay:
+            relay = RelayLeg(
+                msgs_down=self.stats.relay_fwd_down,
+                msgs_up=self.stats.relay_fwd_up,
+                dropped=((self._relay_in_sub.dropped if self._relay_in_sub else 0)
+                         + (self._relay_out_sub.dropped if self._relay_out_sub else 0)),
+                mdps_live=round(r.mrd, 1),
+                mups_live=round(r.mru, 1),
+                down_latency=LatencyStats(**self.stats.relay_down_latency.stats()),
+                up_latency=LatencyStats(**self.stats.relay_up_latency.stats()))
         snap = LiveSnapshot(
             run_id=self.run_id, status=self.status, mode=self.config.mode,
             elapsed_s=round(self._elapsed_s(), 1), duration_s=self.config.test.duration,
             rate_config=self.config.rate.model_dump(),
-            client=client, venue=venue,
+            client=client, venue=venue, relay=relay,
             response_latency=LatencyStats(**self.stats.response_latency.stats()),
             fill_completion_latency=LatencyStats(**self.stats.fill_completion_latency.stats()),
             amend_latency=LatencyStats(**self.stats.amend_latency.stats()),

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

@@ -18,7 +18,7 @@ from typing import Literal, Optional
 
 from pydantic import AliasChoices, BaseModel, Field, model_validator
 
-RunMode = Literal["loopback", "manager", "client", "venue"]
+RunMode = Literal["loopback", "manager", "client", "venue", "middle_manager"]
 SaturationPolicy = Literal["pause", "drop_oldest"]
 RunState = Literal["pending", "running", "completed", "stopped", "error", "saturated"]
 Sequence = Literal["parallel", "sequential", "sequential_timed"]
@@ -195,11 +195,26 @@ class PayloadConfig(BaseModel):
         return self
 
 
+class RelayConfig(BaseModel):
+    """middle_manager relay behaviour. Verbatim forward by default; an optional
+    ordered delay (with jitter) injected before each forward simulates a slow
+    hub hop. inject_delay_ms applies to both directions; jitter_ms adds a random
+    0..jitter_ms on top per message."""
+    inject_delay_ms: int = Field(default=0, ge=0)
+    jitter_ms: int = Field(default=0, ge=0)
+
+
 class RunConfig(BaseModel):
     name: str = Field(min_length=1)
     mode: RunMode = "loopback"
     client_session_id: Optional[str] = None
     venue_session_id: Optional[str] = None
+    # middle_manager only: the relay's two sessions. relay_in is the acceptor the
+    # gen-client connects to; relay_out is the initiator that connects to the venue.
+    # The run forwards client→relay_in→relay_out→venue and the replies back.
+    relay_in_session_id: Optional[str] = None
+    relay_out_session_id: Optional[str] = None
+    relay: "RelayConfig" = Field(default_factory=lambda: RelayConfig())
     # Correlation: the tag carrying the order-identity GUID echoed end-to-end by
     # the stack (default 376 ComplianceID); exec_id_tag (25116) identifies distinct
     # ExecutionReports for dedupe.
@@ -213,12 +228,21 @@ class RunConfig(BaseModel):
 
     @model_validator(mode="after")
     def _sessions(self) -> "RunConfig":
-        need_client = self.mode in ("loopback", "manager", "client")
-        need_venue = self.mode in ("loopback", "manager", "venue")
+        need_client = self.mode in ("loopback", "manager", "client", "middle_manager")
+        need_venue = self.mode in ("loopback", "manager", "venue", "middle_manager")
         if need_client and not self.client_session_id:
             raise ValueError(f"mode {self.mode!r} requires client_session_id")
         if need_venue and not self.venue_session_id:
             raise ValueError(f"mode {self.mode!r} requires venue_session_id")
+        if self.mode == "middle_manager":
+            if not (self.relay_in_session_id and self.relay_out_session_id):
+                raise ValueError("mode 'middle_manager' requires relay_in_session_id "
+                                 "and relay_out_session_id")
+            ids = [self.client_session_id, self.relay_in_session_id,
+                   self.relay_out_session_id, self.venue_session_id]
+            if len(set(ids)) != 4:
+                raise ValueError("middle_manager needs four distinct sessions "
+                                 "(client, relay_in, relay_out, venue)")
         if self.payload.fill.fills_per_order == 0:
             # Ack-only orders never complete via fills: without a cancel reply
             # to finalize them, every order just times out as lost.
@@ -300,6 +324,18 @@ class VenueLeg(BaseModel):
     msgs_in_live: float = 0.0    # all app messages this leg received/s
 
 
+class RelayLeg(BaseModel):
+    # middle_manager: the in-process relay hop. "down" = client→venue direction
+    # (orders/amends/cancels), "up" = venue→client (execs/rejects).
+    msgs_down: int = 0
+    msgs_up: int = 0
+    dropped: int = 0
+    mdps_live: float = 0.0       # relay msgs forwarded downstream/s
+    mups_live: float = 0.0       # relay msgs forwarded upstream/s
+    down_latency: LatencyStats = Field(default_factory=LatencyStats)
+    up_latency: LatencyStats = Field(default_factory=LatencyStats)
+
+
 class SnapshotErrors(BaseModel):
     lost_timeout: int = 0
     rejected: int = 0
@@ -315,6 +351,7 @@ class LiveSnapshot(BaseModel):
     rate_config: dict = Field(default_factory=dict)
     client: Optional[ClientLeg] = None
     venue: Optional[VenueLeg] = None
+    relay: Optional[RelayLeg] = None
     response_latency: LatencyStats = Field(default_factory=LatencyStats)
     fill_completion_latency: LatencyStats = Field(default_factory=LatencyStats)
     amend_latency: LatencyStats = Field(default_factory=LatencyStats)

{fixtureqa-0.4.26 → fixtureqa-0.4.28}/fixture/core/perf_stats.py

@@ -31,6 +31,8 @@ class Rates(NamedTuple):
     mci: float    # client leg messages received/s (acks + fills + replies …)
     mvo: float    # venue leg messages sent/s    (acks + fills + replies …)
     mvi: float    # venue leg messages received/s (orders + amends + cancels …)
+    mrd: float    # middle_manager relay messages forwarded downstream/s
+    mru: float    # middle_manager relay messages forwarded upstream/s
 
 
 class TokenBucket:
@@ -158,6 +160,9 @@ class PerfStats:
         self.msgs_recv_client = 0
         self.msgs_sent_venue = 0
         self.msgs_recv_venue = 0
+        # middle_manager relay: messages forwarded each direction
+        self.relay_fwd_down = 0      # client→venue direction (orders/amends/cancels)
+        self.relay_fwd_up = 0        # venue→client direction (execs/rejects)
         self.lost_timeout = 0
         self.dropped = 0
         self.rejected = 0
@@ -172,6 +177,8 @@ class PerfStats:
         self.amend_latency = _Reservoir(reservoir_size)
         self.cancel_latency = _Reservoir(reservoir_size)
         self.scenario_latency = _Reservoir(reservoir_size)
+        self.relay_down_latency = _Reservoir(reservoir_size)
+        self.relay_up_latency = _Reservoir(reservoir_size)
 
         self._last_t = time.monotonic()
         self._last_orders = 0
@@ -185,6 +192,8 @@ class PerfStats:
         self._last_mrc = 0
         self._last_msv = 0
         self._last_mrv = 0
+        self._last_rfd = 0
+        self._last_rfu = 0
 
     def rates(self) -> Rates:
         """Per-second deltas since the last call. Stateful — call exactly once
@@ -192,7 +201,7 @@ class PerfStats:
         now = time.monotonic()
         dt = now - self._last_t
         if dt <= 0:
-            return Rates(*([0.0] * 11))
+            return Rates(*([0.0] * len(Rates._fields)))
         r = Rates(
             ops=(self.orders_sent - self._last_orders) / dt,
             fps=(self.fills_sent - self._last_fills) / dt,
@@ -205,6 +214,8 @@ class PerfStats:
             mci=(self.msgs_recv_client - self._last_mrc) / dt,
             mvo=(self.msgs_sent_venue - self._last_msv) / dt,
             mvi=(self.msgs_recv_venue - self._last_mrv) / dt,
+            mrd=(self.relay_fwd_down - self._last_rfd) / dt,
+            mru=(self.relay_fwd_up - self._last_rfu) / dt,
         )
         self._last_t = now
         self._last_orders = self.orders_sent
@@ -218,6 +229,8 @@ class PerfStats:
         self._last_mrc = self.msgs_recv_client
         self._last_msv = self.msgs_sent_venue
         self._last_mrv = self.msgs_recv_venue
+        self._last_rfd = self.relay_fwd_down
+        self._last_rfu = self.relay_fwd_up
         return r
 
     def fill_ratio(self) -> float:
@@ -261,4 +274,8 @@ class PerfStats:
             "amend_latency": self.amend_latency.stats(),
             "cancel_latency": self.cancel_latency.stats(),
             "scenario_latency": self.scenario_latency.stats(),
+            "relay_fwd_down": self.relay_fwd_down,
+            "relay_fwd_up": self.relay_fwd_up,
+            "relay_down_latency": self.relay_down_latency.stats(),
+            "relay_up_latency": self.relay_up_latency.stats(),
         }