fixcore-engine 0.1.0__py3-none-any.whl

fixcore/session/session_settings.py

@@ -0,0 +1,146 @@
+"""SessionSettings — parse QuickFIX-style INI configuration."""
+
+from __future__ import annotations
+
+import configparser
+from pathlib import Path
+from typing import Any
+
+from fixcore.session.session_id import SessionID
+
+_DEFAULT_SECTION = "DEFAULT"
+_SESSION_SECTION_PREFIX = "SESSION"
+
+
+class SessionSettings:
+    """Holds per-session and default configuration values.
+
+    Parses a QuickFIX-compatible INI file of the form::
+
+        [DEFAULT]
+        ConnectionType=initiator
+        HeartBtInt=30
+        ResetOnLogon=N
+
+        [SESSION]
+        BeginString=FIX.4.2
+        SenderCompID=CLIENT
+        TargetCompID=SERVER
+        SocketConnectHost=127.0.0.1
+        SocketConnectPort=9878
+
+    Multiple ``[SESSION]`` blocks are allowed; each must define
+    ``BeginString``, ``SenderCompID``, and ``TargetCompID``.
+    """
+
+    def __init__(self) -> None:
+        self._defaults: dict[str, str] = {}
+        # session_id → settings dict
+        self._sessions: dict[SessionID, dict[str, str]] = {}
+
+    # ------------------------------------------------------------------
+    # Parsing
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def from_file(cls, path: str | Path) -> "SessionSettings":
+        settings = cls()
+        text = Path(path).read_text()
+        parser = configparser.RawConfigParser()
+        parser.optionxform = str  # preserve case
+        import io
+        parser.read_file(io.StringIO(cls._preprocess(text)))
+
+        if parser.has_section(_DEFAULT_SECTION) or parser.defaults():
+            settings._defaults = dict(parser.defaults())
+
+        for section in parser.sections():
+            if section.upper().startswith(_SESSION_SECTION_PREFIX):
+                items = dict(parser.items(section))
+                session_id = SessionID(
+                    begin_string=items["BeginString"],
+                    sender_comp_id=items["SenderCompID"],
+                    target_comp_id=items["TargetCompID"],
+                    qualifier=items.get("SessionQualifier", ""),
+                )
+                settings._sessions[session_id] = items
+
+        return settings
+
+    @staticmethod
+    def _preprocess(text: str) -> str:
+        """Rename duplicate [SESSION] headers to [SESSION_0], [SESSION_1], ...
+
+        configparser rejects duplicate section names; QuickFIX configs routinely
+        have multiple [SESSION] blocks.
+        """
+        lines = text.splitlines(keepends=True)
+        result: list[str] = []
+        session_count = 0
+        for line in lines:
+            if line.strip().upper() == "[SESSION]":
+                line = f"[SESSION_{session_count}]\n"
+                session_count += 1
+            result.append(line)
+        return "".join(result)
+
+    @classmethod
+    def from_string(cls, text: str) -> "SessionSettings":
+        """Parse from a configuration string (useful in tests)."""
+        import io
+
+        settings = cls()
+        parser = configparser.RawConfigParser()
+        parser.optionxform = str
+        parser.read_file(io.StringIO(cls._preprocess(text)))
+
+        settings._defaults = dict(parser.defaults())
+
+        for section in parser.sections():
+            if section.upper().startswith(_SESSION_SECTION_PREFIX):
+                items = dict(parser.items(section))
+                session_id = SessionID(
+                    begin_string=items["BeginString"],
+                    sender_comp_id=items["SenderCompID"],
+                    target_comp_id=items["TargetCompID"],
+                    qualifier=items.get("SessionQualifier", ""),
+                )
+                settings._sessions[session_id] = items
+
+        return settings
+
+    # ------------------------------------------------------------------
+    # Access
+    # ------------------------------------------------------------------
+
+    def get(self, session_id: SessionID, key: str) -> str:
+        """Return the value for *key* in *session_id*'s section.
+
+        Falls back to the DEFAULT section.  Raises KeyError if not found.
+        """
+        session = self._sessions.get(session_id, {})
+        if key in session:
+            return session[key]
+        if key in self._defaults:
+            return self._defaults[key]
+        raise KeyError(f"Setting {key!r} not found for {session_id}")
+
+    def get_or(self, session_id: SessionID, key: str, default: Any = None) -> Any:
+        try:
+            return self.get(session_id, key)
+        except KeyError:
+            return default
+
+    def get_bool(self, session_id: SessionID, key: str, default: bool = False) -> bool:
+        val = self.get_or(session_id, key)
+        if val is None:
+            return default
+        return val.strip().upper() in ("Y", "YES", "TRUE", "1")
+
+    def get_int(self, session_id: SessionID, key: str, default: int = 0) -> int:
+        val = self.get_or(session_id, key)
+        return int(val) if val is not None else default
+
+    @property
+    def session_ids(self) -> list[SessionID]:
+        return list(self._sessions.keys())

fixcore/session/state.py

@@ -0,0 +1,60 @@
+"""Session state enum and FIX session-layer constants."""
+
+from enum import Enum, auto
+
+
+class SessionState(Enum):
+    DISCONNECTED = auto()
+    LOGON_TIMEOUT = auto()   # connected, Logon sent (initiator) or awaited (acceptor)
+    LOGGED_ON = auto()
+    LOGOUT_TIMEOUT = auto()  # Logout sent, waiting for counterparty Logout
+
+
+# ---------------------------------------------------------------------------
+# Tag constants used by the session layer
+# ---------------------------------------------------------------------------
+
+TAG_BEGIN_STRING = 8
+TAG_BODY_LENGTH = 9
+TAG_MSG_TYPE = 35
+TAG_CHECKSUM = 10
+
+TAG_MSG_SEQ_NUM = 34
+TAG_SENDER_COMP_ID = 49
+TAG_TARGET_COMP_ID = 56
+TAG_SENDING_TIME = 52
+TAG_POSS_DUP_FLAG = 43
+TAG_ORIG_SENDING_TIME = 122
+
+TAG_ENCRYPT_METHOD = 98
+TAG_HEART_BT_INT = 108
+TAG_RESET_SEQ_NUM_FLAG = 141
+TAG_TEST_REQ_ID = 112
+
+TAG_BEGIN_SEQ_NO = 7
+TAG_END_SEQ_NO = 16
+TAG_NEW_SEQ_NO = 36
+TAG_GAP_FILL_FLAG = 123
+
+TAG_REF_SEQ_NUM = 45
+TAG_REF_TAG_ID = 371
+TAG_REF_MSG_TYPE = 372
+TAG_SESSION_REJECT_REASON = 373
+TAG_TEXT = 58
+
+# ---------------------------------------------------------------------------
+# Message type constants
+# ---------------------------------------------------------------------------
+
+MSG_HEARTBEAT = "0"
+MSG_TEST_REQUEST = "1"
+MSG_RESEND_REQUEST = "2"
+MSG_REJECT = "3"
+MSG_SEQUENCE_RESET = "4"
+MSG_LOGOUT = "5"
+MSG_LOGON = "A"
+
+ADMIN_MSG_TYPES: frozenset[str] = frozenset({
+    MSG_HEARTBEAT, MSG_TEST_REQUEST, MSG_RESEND_REQUEST,
+    MSG_REJECT, MSG_SEQUENCE_RESET, MSG_LOGOUT, MSG_LOGON,
+})

fixcore/store/__init__.py

@@ -0,0 +1,11 @@
+"""Message store — persistence of sent/received messages and sequence numbers."""
+
+from fixcore.store.base import MessageStore
+from fixcore.store.factory import FileStoreFactory, MemoryStoreFactory, StoreFactory
+from fixcore.store.file_store import FileStore
+from fixcore.store.memory import MemoryStore
+
+__all__ = [
+    "MessageStore", "StoreFactory", "MemoryStoreFactory", "FileStoreFactory",
+    "FileStore", "MemoryStore",
+]

fixcore/store/base.py

@@ -0,0 +1,49 @@
+"""MessageStore abstract base class."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+
+class MessageStore(ABC):
+    """Persists sent messages and tracks sequence numbers for a single session."""
+
+    @abstractmethod
+    def get(self, begin_seq: int, end_seq: int) -> list[bytes]:
+        """Return stored messages with sequence numbers in [begin_seq, end_seq]."""
+
+    @abstractmethod
+    def set(self, seq_num: int, message: bytes) -> None:
+        """Store *message* at *seq_num*."""
+
+    @abstractmethod
+    def next_sender_msg_seq_num(self) -> int:
+        """Return the next outbound sequence number."""
+
+    @abstractmethod
+    def next_target_msg_seq_num(self) -> int:
+        """Return the next expected inbound sequence number."""
+
+    @abstractmethod
+    def incr_next_sender_msg_seq_num(self) -> None:
+        """Increment the outbound sequence number by 1."""
+
+    @abstractmethod
+    def incr_next_target_msg_seq_num(self) -> None:
+        """Increment the expected inbound sequence number by 1."""
+
+    @abstractmethod
+    def set_next_sender_msg_seq_num(self, seq_num: int) -> None:
+        """Override the outbound sequence number."""
+
+    @abstractmethod
+    def set_next_target_msg_seq_num(self, seq_num: int) -> None:
+        """Override the expected inbound sequence number."""
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Clear all stored messages and reset sequence numbers to 1."""
+
+    @abstractmethod
+    def refresh(self) -> None:
+        """Reload state from the underlying store (no-op for in-memory)."""

fixcore/store/factory.py

@@ -0,0 +1,33 @@
+"""MessageStore factory — creates a store per session."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from fixcore.session.session_id import SessionID
+from fixcore.store.base import MessageStore
+
+
+class StoreFactory(ABC):
+    @abstractmethod
+    def create(self, session_id: SessionID) -> MessageStore: ...
+
+
+class MemoryStoreFactory(StoreFactory):
+    """Creates a fresh in-memory store for each session (non-persistent)."""
+
+    def create(self, session_id: SessionID) -> MessageStore:
+        from fixcore.store.memory import MemoryStore
+        return MemoryStore()
+
+
+class FileStoreFactory(StoreFactory):
+    """Creates a FileStore for each session under *store_dir*."""
+
+    def __init__(self, store_dir: str | Path) -> None:
+        self._dir = Path(store_dir)
+
+    def create(self, session_id: SessionID) -> MessageStore:
+        from fixcore.store.file_store import FileStore
+        return FileStore(self._dir, session_id)

fixcore/store/file_store.py

@@ -0,0 +1,162 @@
+"""File-backed MessageStore — persists messages and sequence numbers to disk.
+
+Layout (one set of files per session, under *store_dir*)::
+
+    FIX.4.2-CLIENT-SERVER.body      — raw FIX messages, newline-separated
+    FIX.4.2-CLIENT-SERVER.index     — "seq_num=offset,length\\n" per stored message
+    FIX.4.2-CLIENT-SERVER.seqnums   — "sender=N\\ntarget=M\\n"
+
+The index is held in memory after init for O(1) random access.  The body and
+index files are append-only; ``reset()`` truncates them.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from fixcore.session.session_id import SessionID
+from fixcore.store.base import MessageStore
+
+
+def _session_prefix(session_id: SessionID) -> str:
+    """Convert a SessionID to a safe filesystem name."""
+    return (
+        f"{session_id.begin_string}-"
+        f"{session_id.sender_comp_id}-"
+        f"{session_id.target_comp_id}"
+        + (f"-{session_id.qualifier}" if session_id.qualifier else "")
+    )
+
+
+class FileStore(MessageStore):
+    """Durable MessageStore backed by three flat files per session.
+
+    Parameters
+    ----------
+    store_dir:
+        Directory where session files are written.  Created if absent.
+    session_id:
+        Identifies the session; used to derive file names.
+    """
+
+    def __init__(self, store_dir: str | Path, session_id: SessionID) -> None:
+        self._dir = Path(store_dir)
+        self._dir.mkdir(parents=True, exist_ok=True)
+
+        prefix = self._dir / _session_prefix(session_id)
+        self._body_path = Path(f"{prefix}.body")
+        self._index_path = Path(f"{prefix}.index")
+        self._seqnums_path = Path(f"{prefix}.seqnums")
+
+        # In-memory index: seq_num → (byte_offset, length)
+        self._index: dict[int, tuple[int, int]] = {}
+
+        self._next_sender: int = 1
+        self._next_target: int = 1
+
+        self._init_files()
+
+    # ------------------------------------------------------------------
+    # Initialisation
+    # ------------------------------------------------------------------
+
+    def _init_files(self) -> None:
+        """Create files if absent, then load persisted state."""
+        for path in (self._body_path, self._index_path, self._seqnums_path):
+            if not path.exists():
+                path.touch()
+
+        self._load_seqnums()
+        self._load_index()
+
+    def _load_seqnums(self) -> None:
+        text = self._seqnums_path.read_text()
+        self._next_sender = 1
+        self._next_target = 1
+        for line in text.splitlines():
+            if line.startswith("sender="):
+                self._next_sender = int(line[7:])
+            elif line.startswith("target="):
+                self._next_target = int(line[7:])
+
+    def _load_index(self) -> None:
+        self._index.clear()
+        for line in self._index_path.read_text().splitlines():
+            if not line:
+                continue
+            # format: seq_num=offset,length
+            eq = line.index("=")
+            seq = int(line[:eq])
+            offset_str, length_str = line[eq + 1:].split(",")
+            self._index[seq] = (int(offset_str), int(length_str))
+
+    def _flush_seqnums(self) -> None:
+        self._seqnums_path.write_text(
+            f"sender={self._next_sender}\ntarget={self._next_target}\n"
+        )
+
+    # ------------------------------------------------------------------
+    # MessageStore interface
+    # ------------------------------------------------------------------
+
+    def get(self, begin_seq: int, end_seq: int) -> list[bytes]:
+        results: list[bytes] = []
+        with self._body_path.open("rb") as fh:
+            for seq in range(begin_seq, end_seq + 1):
+                entry = self._index.get(seq)
+                if entry is None:
+                    continue
+                offset, length = entry
+                fh.seek(offset)
+                results.append(fh.read(length))
+        return results
+
+    def set(self, seq_num: int, message: bytes) -> None:
+        # Append message to body (newline-terminated for human readability)
+        with self._body_path.open("ab") as fh:
+            offset = fh.seek(0, os.SEEK_END)
+            fh.write(message)
+            fh.write(b"\n")
+            length = len(message)
+
+        # Append index entry
+        with self._index_path.open("a") as fh:
+            fh.write(f"{seq_num}={offset},{length}\n")
+
+        self._index[seq_num] = (offset, length)
+
+    def next_sender_msg_seq_num(self) -> int:
+        return self._next_sender
+
+    def next_target_msg_seq_num(self) -> int:
+        return self._next_target
+
+    def incr_next_sender_msg_seq_num(self) -> None:
+        self._next_sender += 1
+        self._flush_seqnums()
+
+    def incr_next_target_msg_seq_num(self) -> None:
+        self._next_target += 1
+        self._flush_seqnums()
+
+    def set_next_sender_msg_seq_num(self, seq_num: int) -> None:
+        self._next_sender = seq_num
+        self._flush_seqnums()
+
+    def set_next_target_msg_seq_num(self, seq_num: int) -> None:
+        self._next_target = seq_num
+        self._flush_seqnums()
+
+    def reset(self) -> None:
+        self._body_path.write_bytes(b"")
+        self._index_path.write_text("")
+        self._index.clear()
+        self._next_sender = 1
+        self._next_target = 1
+        self._flush_seqnums()
+
+    def refresh(self) -> None:
+        """Reload all state from disk (e.g. after external modification)."""
+        self._load_seqnums()
+        self._load_index()

fixcore/store/memory.py

@@ -0,0 +1,50 @@
+"""In-memory MessageStore implementation."""
+
+from __future__ import annotations
+
+from fixcore.store.base import MessageStore
+
+
+class MemoryStore(MessageStore):
+    """Non-persistent store — useful for testing and ephemeral sessions."""
+
+    def __init__(self) -> None:
+        self._messages: dict[int, bytes] = {}
+        self._next_sender: int = 1
+        self._next_target: int = 1
+
+    def get(self, begin_seq: int, end_seq: int) -> list[bytes]:
+        return [
+            self._messages[seq]
+            for seq in range(begin_seq, end_seq + 1)
+            if seq in self._messages
+        ]
+
+    def set(self, seq_num: int, message: bytes) -> None:
+        self._messages[seq_num] = message
+
+    def next_sender_msg_seq_num(self) -> int:
+        return self._next_sender
+
+    def next_target_msg_seq_num(self) -> int:
+        return self._next_target
+
+    def incr_next_sender_msg_seq_num(self) -> None:
+        self._next_sender += 1
+
+    def incr_next_target_msg_seq_num(self) -> None:
+        self._next_target += 1
+
+    def set_next_sender_msg_seq_num(self, seq_num: int) -> None:
+        self._next_sender = seq_num
+
+    def set_next_target_msg_seq_num(self, seq_num: int) -> None:
+        self._next_target = seq_num
+
+    def reset(self) -> None:
+        self._messages.clear()
+        self._next_sender = 1
+        self._next_target = 1
+
+    def refresh(self) -> None:
+        pass  # nothing to reload

fixcore/transport/__init__.py

@@ -0,0 +1,7 @@
+"""Transport layer — asyncio-based TCP acceptor and initiator."""
+
+from fixcore.transport.acceptor import SocketAcceptor
+from fixcore.transport.framer import MessageFramer
+from fixcore.transport.initiator import SocketInitiator
+
+__all__ = ["MessageFramer", "SocketAcceptor", "SocketInitiator"]

fixcore/transport/acceptor.py

@@ -0,0 +1,166 @@
+"""SocketAcceptor — listens for inbound FIX connections."""
+
+from __future__ import annotations
+
+import asyncio
+
+from fixcore.application import Application
+from fixcore.log.base import LogFactory
+from fixcore.message.message import Message
+from fixcore.session.session import Session
+from fixcore.session.session_id import SessionID
+from fixcore.session.session_settings import SessionSettings
+from fixcore.session.state import TAG_BEGIN_STRING, TAG_SENDER_COMP_ID, TAG_TARGET_COMP_ID
+from fixcore.store.factory import StoreFactory
+from fixcore.transport.framer import MessageFramer
+
+
+class SocketAcceptor:
+    """Listens on a TCP port and routes incoming connections to the correct Session.
+
+    One :class:`~fixcore.session.Session` is pre-created per configured
+    acceptor session.  When a connection arrives, the first FIX message
+    (expected to be a Logon) is used to look up the matching session by
+    BeginString/SenderCompID/TargetCompID.
+
+    Usage::
+
+        acceptor = SocketAcceptor(settings, app, store_factory, log_factory)
+        async with acceptor:
+            await asyncio.sleep(3600)   # serve for an hour
+    """
+
+    def __init__(
+        self,
+        settings: SessionSettings,
+        application: Application,
+        store_factory: StoreFactory,
+        log_factory: LogFactory,
+    ) -> None:
+        self._settings = settings
+        self._app = application
+        self._store_factory = store_factory
+        self._log_factory = log_factory
+
+        self._sessions: dict[SessionID, Session] = {}
+        self._server: asyncio.Server | None = None
+        self._connection_tasks: set[asyncio.Task[None]] = set()
+
+        for sid in settings.session_ids:
+            conn_type = settings.get_or(sid, "ConnectionType", "acceptor").lower()
+            if conn_type == "acceptor":
+                self._sessions[sid] = Session(
+                    sid, settings, application,
+                    store_factory.create(sid),
+                    log_factory.create(sid),
+                )
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def start(self) -> None:
+        """Start the TCP server.  Binds to SocketAcceptPort (default 9878)."""
+        # Use the first acceptor session to get host/port
+        sid = next(iter(self._sessions))
+        host = self._settings.get_or(sid, "SocketAcceptHost", "0.0.0.0")
+        port = int(self._settings.get_or(sid, "SocketAcceptPort", "9878"))
+
+        self._server = await asyncio.start_server(
+            self._handle_connection, host, port
+        )
+
+    async def stop(self) -> None:
+        """Stop accepting new connections and close all active sessions."""
+        # Cancel all in-flight connection handlers (triggers their finally blocks)
+        for task in list(self._connection_tasks):
+            task.cancel()
+        if self._connection_tasks:
+            await asyncio.gather(*self._connection_tasks, return_exceptions=True)
+            self._connection_tasks.clear()
+
+        if self._server is not None:
+            self._server.close()
+            await self._server.wait_closed()
+            self._server = None
+
+    async def __aenter__(self) -> "SocketAcceptor":
+        await self.start()
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.stop()
+
+    @property
+    def sessions(self) -> dict[SessionID, Session]:
+        return dict(self._sessions)
+
+    # ------------------------------------------------------------------
+    # Connection handler
+    # ------------------------------------------------------------------
+
+    async def _handle_connection(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+    ) -> None:
+        framer = MessageFramer()
+        session: Session | None = None
+        task = asyncio.current_task()
+        if task is not None:
+            self._connection_tasks.add(task)
+
+        async def send_fn(data: bytes) -> None:
+            writer.write(data)
+            await writer.drain()
+
+        try:
+            while True:
+                try:
+                    data = await reader.read(4096)
+                except (ConnectionResetError, asyncio.IncompleteReadError, asyncio.CancelledError):
+                    break
+                if not data:
+                    break
+
+                for raw_msg in framer.feed(data):
+                    if session is None:
+                        session = self._find_session(raw_msg)
+                        if session is None:
+                            # Unknown session — close connection
+                            return
+                        await session.on_connect(send_fn)
+
+                    await session.on_data(raw_msg)
+
+        finally:
+            task = asyncio.current_task()
+            if task is not None:
+                self._connection_tasks.discard(task)
+            if session is not None:
+                await session.on_disconnect()
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except Exception:
+                pass
+
+    def _find_session(self, raw_msg: bytes) -> Session | None:
+        """Match an incoming message to a pre-configured session."""
+        try:
+            msg = Message.decode(raw_msg)
+        except ValueError:
+            return None
+
+        begin = msg.header.get_or(TAG_BEGIN_STRING)
+        sender = msg.header.get_or(TAG_SENDER_COMP_ID)
+        target = msg.header.get_or(TAG_TARGET_COMP_ID)
+
+        for sid, session in self._sessions.items():
+            if (
+                sid.begin_string == begin
+                and sid.sender_comp_id == target   # our sender == their target
+                and sid.target_comp_id == sender   # our target == their sender
+            ):
+                return session
+        return None