fixtureqa 0.1.0__py3-none-any.whl

fixture/core/scenario_store.py

@@ -0,0 +1,70 @@
+"""
+Per-user scenario storage.
+Scenarios are persisted as data/<uid>/scenarios.json — same directory structure
+as template_store.py / config_store.py.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from typing import Optional
+
+
+class ScenarioStore:
+    def __init__(self, data_dir: str):
+        self._data_dir = os.path.abspath(data_dir)
+
+    def _path(self, uid: str) -> str:
+        return os.path.join(self._data_dir, uid, "scenarios.json")
+
+    def _load(self, uid: str) -> list[dict]:
+        path = self._path(uid)
+        if not os.path.isfile(path):
+            return []
+        try:
+            with open(path) as f:
+                return json.load(f)
+        except (OSError, json.JSONDecodeError):
+            return []
+
+    def _save(self, uid: str, scenarios: list[dict]) -> None:
+        user_dir = os.path.join(self._data_dir, uid)
+        os.makedirs(user_dir, exist_ok=True)
+        path = self._path(uid)
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump(scenarios, f, indent=2)
+        os.replace(tmp, path)
+
+    def list_scenarios(self, uid: str) -> list[dict]:
+        return self._load(uid)
+
+    def get_scenario(self, uid: str, scenario_id: str) -> Optional[dict]:
+        return next((s for s in self._load(uid) if s.get("id") == scenario_id), None)
+
+    def create_scenario(self, uid: str, data: dict) -> dict:
+        scenarios = self._load(uid)
+        scenario = {**data, "id": str(uuid.uuid4())}
+        scenarios.append(scenario)
+        self._save(uid, scenarios)
+        return scenario
+
+    def update_scenario(self, uid: str, scenario_id: str, data: dict) -> Optional[dict]:
+        scenarios = self._load(uid)
+        for i, s in enumerate(scenarios):
+            if s.get("id") == scenario_id:
+                updated = {**data, "id": scenario_id}
+                scenarios[i] = updated
+                self._save(uid, scenarios)
+                return updated
+        return None
+
+    def delete_scenario(self, uid: str, scenario_id: str) -> bool:
+        scenarios = self._load(uid)
+        new = [s for s in scenarios if s.get("id") != scenario_id]
+        if len(new) == len(scenarios):
+            return False
+        self._save(uid, new)
+        return True

fixture/core/session.py

@@ -0,0 +1,278 @@
+import asyncio
+import os
+import time
+from typing import TYPE_CHECKING, Optional
+
+from fixcore.message.message import Message
+from fixcore.session.session_id import SessionID
+from fixcore.session.session_settings import SessionSettings
+from fixcore.store import FileStoreFactory, MemoryStoreFactory
+from fixcore.log import FileLogFactory, ScreenLogFactory
+from fixcore.transport import SocketInitiator, SocketAcceptor
+
+from .models import SessionConfig, SessionState, SessionStatus, ConnectionType
+from .events import EventHandler, EventType, SessionEvent
+from .fix_application import FixApplication
+
+if TYPE_CHECKING:
+    from .message_store import MessageWriter
+
+
+class Session:
+    """
+    Owns exactly one fixcore transport (SocketInitiator or SocketAcceptor).
+    The transport runs as asyncio tasks on the same event loop as FastAPI —
+    no daemon threads or thread-crossing required.
+
+    Lifecycle: STOPPED -> await start() -> CONNECTING/LISTENING -> await stop() -> STOPPED
+    """
+
+    def __init__(self, config: SessionConfig, event_handler: EventHandler,
+                 msg_writer: Optional["MessageWriter"] = None):
+        self.config = config
+        if msg_writer is not None:
+            from .message_store import MessageStore
+            self._message_log = MessageStore(config.session_id, msg_writer)
+        else:
+            from .message_log import MessageLog
+            self._message_log = MessageLog()
+        self.state = SessionState(config=config, message_log=self._message_log)
+        self._event_handler = event_handler
+        self._transport: Optional[SocketInitiator | SocketAcceptor] = None
+        self._app: Optional[FixApplication] = None
+        self._fixcore_session_id: Optional[SessionID] = None
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    async def start(self) -> None:
+        if self.state.status != SessionStatus.STOPPED:
+            raise RuntimeError(f"Session {self.config.session_id!r} is already running")
+
+        self._app = FixApplication(self.config.session_id, self._handle_event)
+
+        store_path = os.path.abspath(
+            os.path.join(self.config.file_store_path, self.config.session_id)
+        )
+        os.makedirs(store_path, exist_ok=True)
+
+        store_factory = FileStoreFactory(store_path)
+
+        if self.config.use_file_log:
+            log_path = os.path.abspath(
+                os.path.join(self.config.file_log_path, self.config.session_id)
+            )
+            os.makedirs(log_path, exist_ok=True)
+            log_factory = FileLogFactory(log_path)
+        else:
+            log_factory = ScreenLogFactory()
+
+        settings = self._build_settings()
+
+        if self.config.connection_type == ConnectionType.INITIATOR:
+            self._transport = SocketInitiator(settings, self._app, store_factory, log_factory)
+            self.state.status = SessionStatus.CONNECTING
+        else:
+            self._transport = SocketAcceptor(settings, self._app, store_factory, log_factory)
+            self.state.status = SessionStatus.LISTENING
+
+        self.state.status_changed_at = time.time()
+
+        # Store the SessionID for later use (send, seqnums)
+        self._fixcore_session_id = list(settings.session_ids)[0]
+
+        # Start transport tasks on the current event loop
+        try:
+            await self._transport.start()
+        except Exception as e:
+            self.state.status = SessionStatus.ERROR
+            self.state.error_message = str(e)
+            self._event_handler(SessionEvent(
+                event_type=EventType.ENGINE_ERROR,
+                session_id=self.config.session_id,
+                payload={"error": str(e)},
+            ))
+
+    async def stop(self, force: bool = False) -> None:
+        if self._transport is not None:
+            try:
+                await self._transport.stop()
+            except Exception:
+                pass
+        self.state.status = SessionStatus.STOPPED
+        self.state.status_changed_at = time.time()
+        self._event_handler(SessionEvent(
+            event_type=EventType.SESSION_STATUS_CHANGED,
+            session_id=self.config.session_id,
+            payload={
+                "status": "STOPPED",
+                "status_changed_at": self.state.status_changed_at,
+                "last_heartbeat_at": self.state.last_heartbeat_at,
+            },
+        ))
+
+    async def send_message(self, message: Message) -> bool:
+        """Send an application-level FIX message. Returns False if not logged on."""
+        if self._transport is None or self._fixcore_session_id is None:
+            return False
+        transport_session = self._transport.sessions.get(self._fixcore_session_id)
+        if transport_session is None or not transport_session.is_logged_on:
+            return False
+        try:
+            await transport_session.send_app(message)
+            return True
+        except Exception:
+            return False
+
+    # ------------------------------------------------------------------
+    # Sequence number management
+    # ------------------------------------------------------------------
+
+    def get_seqnums(self) -> tuple:
+        """Return (next_sender, next_target) from the FileStore."""
+        store = self._get_store()
+        if store:
+            return store.next_sender_msg_seq_num(), store.next_target_msg_seq_num()
+        return 1, 1
+
+    def set_seqnums(self, sender, target) -> tuple:
+        """Set one or both seqnums. Works on stopped and running sessions."""
+        store = self._get_store()
+        if store is None:
+            return 1, 1
+
+        cur_sender = store.next_sender_msg_seq_num()
+        cur_target = store.next_target_msg_seq_num()
+        new_sender = sender if sender is not None else cur_sender
+        new_target = target if target is not None else cur_target
+
+        if sender is not None:
+            store.set_next_sender_msg_seq_num(new_sender)
+        if target is not None:
+            store.set_next_target_msg_seq_num(new_target)
+
+        self.state.last_sent_seq_num = new_sender - 1
+        self.state.last_recv_seq_num = new_target - 1
+        return new_sender, new_target
+
+    def _get_store(self):
+        """Return the live MessageStore if available, else None."""
+        if self._transport is None or self._fixcore_session_id is None:
+            return None
+        transport_session = self._transport.sessions.get(self._fixcore_session_id)
+        if transport_session is not None:
+            return transport_session._store
+        return None
+
+    # ------------------------------------------------------------------
+    # Internal event handling
+    # ------------------------------------------------------------------
+
+    def _handle_event(self, event: SessionEvent) -> None:
+        """Update local state then forward to the session manager's handler."""
+        if event.event_type == EventType.SESSION_STATUS_CHANGED:
+            status_str = event.payload.get("status", "")
+            if status_str == "LOGGED_ON":
+                self.state.status = SessionStatus.LOGGED_ON
+                self.state.status_changed_at = time.time()
+            elif status_str == "LOGGED_OUT":
+                if self.state.status != SessionStatus.STOPPED:
+                    if self.config.connection_type == ConnectionType.INITIATOR:
+                        self.state.status = SessionStatus.CONNECTING
+                    else:
+                        self.state.status = SessionStatus.LISTENING
+                    self.state.status_changed_at = time.time()
+            event.payload["status"] = self.state.status.name
+            event.payload["status_changed_at"] = self.state.status_changed_at
+            event.payload["last_heartbeat_at"] = self.state.last_heartbeat_at
+
+        elif event.event_type in (EventType.MESSAGE_RECEIVED, EventType.MESSAGE_SENT):
+            direction = "IN" if event.event_type == EventType.MESSAGE_RECEIVED else "OUT"
+            entry = self._message_log.add(
+                direction=direction,
+                admin=event.payload.get("admin", False),
+                raw=event.payload.get("raw", ""),
+            )
+            event.payload["seq_num"] = entry.seq_num
+            event.payload["msg_type"] = entry.msg_type
+            event.payload["msg_type_name"] = entry.msg_type_name
+            event.payload["fields"] = entry.fields
+            if direction == "OUT":
+                self.state.last_sent_seq_num = entry.seq_num
+            else:
+                self.state.last_recv_seq_num = entry.seq_num
+                if entry.msg_type == "0":  # Heartbeat
+                    self.state.last_heartbeat_at = time.time()
+                if (entry.msg_type == "D" and not entry.admin
+                        and self.config.session_role.value == "venue"):
+                    self._schedule_venue_responses(entry.fields)
+
+        self._event_handler(event)
+
+    def _schedule_venue_responses(self, order_fields: dict) -> None:
+        from .venue_responses import build_ack, build_fill, new_order_id
+        order_id = new_order_id()
+
+        async def _delayed(msg: Message, delay: float) -> None:
+            await asyncio.sleep(delay)
+            await self.send_message(msg)
+
+        if self.config.auto_ack:
+            asyncio.create_task(_delayed(build_ack(order_fields, order_id),
+                                         self.config.auto_ack_delay_ms / 1000.0))
+        if self.config.auto_fill:
+            asyncio.create_task(_delayed(build_fill(order_fields, order_id),
+                                         self.config.auto_fill_delay_ms / 1000.0))
+
+    # ------------------------------------------------------------------
+    # Settings builder
+    # ------------------------------------------------------------------
+
+    def _build_settings(self) -> SessionSettings:
+        """Build fixcore SessionSettings from SessionConfig."""
+        ct = "initiator" if self.config.connection_type == ConnectionType.INITIATOR else "acceptor"
+        dd_path = self._resolve_data_dictionary()
+
+        store_path = os.path.abspath(
+            os.path.join(self.config.file_store_path, self.config.session_id)
+        )
+        log_path = os.path.abspath(
+            os.path.join(self.config.file_log_path, self.config.session_id)
+        )
+
+        lines = [
+            "[DEFAULT]",
+            f"ConnectionType={ct}",
+            f"BeginString={self.config.begin_string}",
+            f"SenderCompID={self.config.sender_comp_id}",
+            f"TargetCompID={self.config.target_comp_id}",
+            f"HeartBtInt={self.config.heartbeat_interval}",
+            f"StartTime={self.config.start_time}",
+            f"EndTime={self.config.end_time}",
+            f"DataDictionary={dd_path}",
+            f"FileStorePath={store_path}",
+            f"FileLogPath={log_path}",
+            f"ResetOnLogon={'Y' if self.config.reset_on_logon else 'N'}",
+            f"ResetOnLogout={'Y' if self.config.reset_on_logout else 'N'}",
+            "",
+            "[SESSION]",
+        ]
+
+        if self.config.connection_type == ConnectionType.INITIATOR:
+            lines += [
+                f"SocketConnectHost={self.config.host}",
+                f"SocketConnectPort={self.config.port}",
+                f"ReconnectInterval={self.config.reconnect_interval}",
+            ]
+        else:
+            lines.append(f"SocketAcceptPort={self.config.port}")
+
+        return SessionSettings.from_string("\n".join(lines))
+
+    def _resolve_data_dictionary(self) -> str:
+        if self.config.data_dictionary_path:
+            return os.path.abspath(self.config.data_dictionary_path)
+        here = os.path.dirname(os.path.abspath(__file__))
+        fname = "FIX42.xml" if "4.2" in self.config.begin_string else "FIX44.xml"
+        return os.path.abspath(os.path.join(here, "..", "fix_specs", fname))

fixture/core/session_manager.py

@@ -0,0 +1,173 @@
+from typing import Dict, List, Optional
+from .models import SessionConfig, SessionState, SessionStatus
+from .session import Session
+from .events import EventHandler, SessionEvent
+from .config_store import ConfigStore
+
+
+class SessionManager:
+    """
+    The sole public facade for all session operations.
+
+    All session lifecycle methods (start/stop/send) are async — they run on
+    the same asyncio event loop as FastAPI and fixcore transports.
+    """
+
+    def __init__(self, config_store: Optional[ConfigStore] = None,
+                 msg_db_path: Optional[str] = None):
+        self._sessions: Dict[str, Session] = {}
+        self._handlers: List[EventHandler] = []
+        self._store = config_store
+        self._message_writer = None
+        if msg_db_path:
+            from .message_store import MessageWriter
+            self._message_writer = MessageWriter(msg_db_path)
+
+    # ------------------------------------------------------------------
+    # Session lifecycle
+    # ------------------------------------------------------------------
+
+    def load_persisted(self) -> None:
+        """Load and register sessions from the config store (does not start engines)."""
+        if self._store is None:
+            return
+        for config in self._store.load_all():
+            try:
+                self.add_session(config)
+            except (ValueError, KeyError):
+                pass
+
+    def add_session(self, config: SessionConfig) -> str:
+        """Register a session. Does NOT start the engine. Returns session_id."""
+        if config.session_id in self._sessions:
+            raise ValueError(f"Session {config.session_id!r} already exists")
+        self._validate_config(config)
+        session = Session(config, self._dispatch_event, self._message_writer)
+        self._sessions[config.session_id] = session
+        self._persist()
+        return config.session_id
+
+    async def start_session(self, session_id: str) -> None:
+        await self._get(session_id).start()
+
+    async def stop_session(self, session_id: str, force: bool = False) -> None:
+        await self._get(session_id).stop(force=force)
+
+    def update_session(self, session_id: str, req) -> SessionConfig:
+        """Update config fields on a stopped session."""
+        from .models import ConnectionType, SessionRole
+        session = self._get(session_id)
+        if session.state.status != SessionStatus.STOPPED:
+            raise RuntimeError("Session must be stopped before editing")
+        cfg = session.config
+        updates = {k: v for k, v in req.model_dump().items() if v is not None}
+        if "connection_type" in updates:
+            updates["connection_type"] = ConnectionType(updates["connection_type"])
+        if "session_role" in updates:
+            updates["session_role"] = SessionRole(updates["session_role"])
+        for key, value in updates.items():
+            setattr(cfg, key, value)
+        self._validate_config(cfg, exclude_id=session_id)
+        self._persist()
+        return cfg
+
+    async def remove_session(self, session_id: str) -> None:
+        """Force-stop and remove a session."""
+        session = self._get(session_id)
+        await session.stop(force=True)
+        del self._sessions[session_id]
+        self._persist()
+
+    def get_state(self, session_id: str) -> SessionState:
+        return self._get(session_id).state
+
+    def list_sessions(self) -> List[SessionConfig]:
+        return [s.config for s in self._sessions.values()]
+
+    def list_sessions_for_user(self, uid: str, is_admin: bool = False) -> List[SessionConfig]:
+        configs = list(self._sessions.values())
+        if is_admin:
+            return [s.config for s in configs]
+        return [s.config for s in configs if s.config.owner_uid == uid]
+
+    def is_running(self, session_id: str) -> bool:
+        state = self.get_state(session_id)
+        return state.status not in (SessionStatus.STOPPED, SessionStatus.ERROR)
+
+    # ------------------------------------------------------------------
+    # Message sending / seqnums
+    # ------------------------------------------------------------------
+
+    def get_seqnums(self, session_id: str) -> tuple:
+        return self._get(session_id).get_seqnums()
+
+    def set_seqnums(self, session_id: str, sender, target) -> tuple:
+        return self._get(session_id).set_seqnums(sender, target)
+
+    async def send_message(self, session_id: str, message) -> bool:
+        return await self._get(session_id).send_message(message)
+
+    # ------------------------------------------------------------------
+    # Event subscription
+    # ------------------------------------------------------------------
+
+    def close(self) -> None:
+        if self._message_writer is not None:
+            self._message_writer.close()
+
+    def subscribe(self, handler: EventHandler) -> None:
+        self._handlers.append(handler)
+
+    def unsubscribe(self, handler: EventHandler) -> None:
+        if handler in self._handlers:
+            self._handlers.remove(handler)
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _get(self, session_id: str) -> Session:
+        session = self._sessions.get(session_id)
+        if session is None:
+            raise KeyError(f"Unknown session: {session_id!r}")
+        return session
+
+    def _validate_config(self, config: SessionConfig, exclude_id: Optional[str] = None) -> None:
+        if not config.sender_comp_id:
+            raise ValueError("sender_comp_id is required")
+        if not config.target_comp_id:
+            raise ValueError("target_comp_id is required")
+        if config.begin_string not in ("FIX.4.2", "FIX.4.4"):
+            raise ValueError(f"Unsupported FIX version: {config.begin_string!r}")
+        from .models import ConnectionType
+        if config.connection_type == ConnectionType.ACCEPTOR:
+            for sid, s in self._sessions.items():
+                if sid == exclude_id:
+                    continue
+                if (s.config.connection_type == ConnectionType.ACCEPTOR
+                        and s.config.port == config.port):
+                    raise ValueError(
+                        f"Port {config.port} already in use by acceptor session {sid!r}"
+                    )
+
+    def _persist(self) -> None:
+        if self._store is None:
+            return
+        configs = [s.config for s in self._sessions.values()]
+        by_user: dict = {}
+        for cfg in configs:
+            if cfg.owner_uid:
+                by_user.setdefault(cfg.owner_uid, []).append(cfg)
+        for uid, user_configs in by_user.items():
+            self._store.save_for_user(uid, user_configs)
+
+    def _dispatch_event(self, event: SessionEvent) -> None:
+        handlers = list(self._handlers)
+        session = self._sessions.get(event.session_id)
+        if session:
+            event.owner_uid = session.config.owner_uid
+        for handler in handlers:
+            try:
+                handler(event)
+            except Exception:
+                pass

fixture/core/template_store.py

@@ -0,0 +1,70 @@
+"""
+Per-user FIX message template storage.
+Templates are persisted as data/<uid>/templates.json — same directory structure
+as config_store.py.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from typing import Optional
+
+
+class TemplateStore:
+    def __init__(self, data_dir: str):
+        self._data_dir = os.path.abspath(data_dir)
+
+    def _path(self, uid: str) -> str:
+        return os.path.join(self._data_dir, uid, "templates.json")
+
+    def _load(self, uid: str) -> list[dict]:
+        path = self._path(uid)
+        if not os.path.isfile(path):
+            return []
+        try:
+            with open(path) as f:
+                return json.load(f)
+        except (OSError, json.JSONDecodeError):
+            return []
+
+    def _save(self, uid: str, templates: list[dict]) -> None:
+        user_dir = os.path.join(self._data_dir, uid)
+        os.makedirs(user_dir, exist_ok=True)
+        path = self._path(uid)
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump(templates, f, indent=2)
+        os.replace(tmp, path)
+
+    def list_templates(self, uid: str) -> list[dict]:
+        return self._load(uid)
+
+    def get_template(self, uid: str, template_id: str) -> Optional[dict]:
+        return next((t for t in self._load(uid) if t.get("id") == template_id), None)
+
+    def create_template(self, uid: str, data: dict) -> dict:
+        templates = self._load(uid)
+        template = {**data, "id": str(uuid.uuid4())}
+        templates.append(template)
+        self._save(uid, templates)
+        return template
+
+    def update_template(self, uid: str, template_id: str, data: dict) -> Optional[dict]:
+        templates = self._load(uid)
+        for i, t in enumerate(templates):
+            if t.get("id") == template_id:
+                updated = {**data, "id": template_id}
+                templates[i] = updated
+                self._save(uid, templates)
+                return updated
+        return None
+
+    def delete_template(self, uid: str, template_id: str) -> bool:
+        templates = self._load(uid)
+        new = [t for t in templates if t.get("id") != template_id]
+        if len(new) == len(templates):
+            return False
+        self._save(uid, new)
+        return True