fixcore-engine 0.1.3__tar.gz → 0.1.5__tar.gz

{fixcore_engine-0.1.3/fixcore_engine.egg-info → fixcore_engine-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixcore-engine
-Version: 0.1.3
+Version: 0.1.5
 Summary: Pure Python FIX protocol engine
 Author-email: Aidan Chisholm <aidan.chisholm@gmail.com>
 License: MIT License

{fixcore_engine-0.1.3 → fixcore_engine-0.1.5}/fixcore/transport/initiator.py

@@ -3,8 +3,11 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 
 from fixcore.application import Application
+
+logger = logging.getLogger(__name__)
 from fixcore.log.base import LogFactory
 from fixcore.session.session import Session
 from fixcore.session.session_id import SessionID
@@ -61,16 +64,20 @@ class SocketInitiator:
         """Launch a connect-loop task for each configured initiator session."""
         self._stop_event.clear()
         self._no_reconnect.clear()
+        logger.info("SocketInitiator starting %d session(s)", len(self._sessions))
         for sid, session in self._sessions.items():
             task = asyncio.create_task(
                 self._connect_loop(sid, session),
                 name=f"initiator-{sid}",
             )
             self._tasks.append(task)
+            logger.debug("Connect-loop task created for %s", sid)
 
     async def stop(self) -> None:
         """Signal all connect loops to exit and wait for them to finish."""
         self._stop_event.set()
+        for task in self._tasks:
+            task.cancel()
         if self._tasks:
             await asyncio.gather(*self._tasks, return_exceptions=True)
             self._tasks.clear()
@@ -106,14 +113,17 @@ class SocketInitiator:
         port = int(self._settings.get(sid, "SocketConnectPort"))
         reconnect = self._settings.get_int(sid, "ReconnectInterval", 10)
 
+        logger.info("[%s] Connect loop started — target %s:%s", sid, host, port)
         while not self._stop_event.is_set():
+            logger.debug("[%s] Attempting connection to %s:%s", sid, host, port)
             try:
                 reader, writer = await asyncio.open_connection(host, port)
-            except OSError:
-                # Connection refused or network error — wait and retry
+            except OSError as exc:
+                logger.warning("[%s] Connection failed: %s — retrying in %ss", sid, exc, reconnect)
                 await self._interruptible_sleep(reconnect)
                 continue
 
+            logger.info("[%s] TCP connected to %s:%s", sid, host, port)
             framer = MessageFramer()
 
             async def send_fn(data: bytes, _w: asyncio.StreamWriter = writer) -> None:
@@ -121,22 +131,26 @@ class SocketInitiator:
                 await _w.drain()
 
             await session.on_connect(send_fn)
+            logger.debug("[%s] on_connect complete — Logon sent", sid)
 
             try:
                 while not self._stop_event.is_set():
                     try:
-                        data = await asyncio.wait_for(reader.read(4096), timeout=1.0)
-                    except asyncio.TimeoutError:
-                        continue
-                    except (ConnectionResetError, asyncio.IncompleteReadError):
+                        data = await reader.read(4096)
+                    except (ConnectionResetError, asyncio.IncompleteReadError,
+                            asyncio.CancelledError) as exc:
+                        logger.info("[%s] Read interrupted: %s", sid, type(exc).__name__)
                         break
                     if not data:
+                        logger.info("[%s] Connection closed by peer", sid)
                         break
 
+                    logger.debug("[%s] Received %d bytes", sid, len(data))
                     for raw_msg in framer.feed(data):
                         await session.on_data(raw_msg)
 
             finally:
+                logger.info("[%s] Disconnecting", sid)
                 await session.on_disconnect()
                 try:
                     writer.close()
@@ -146,14 +160,12 @@ class SocketInitiator:
                 framer.reset()
 
             if not self._stop_event.is_set() and not self._no_reconnect.is_set():
+                logger.info("[%s] Waiting %ss before reconnect", sid, reconnect)
                 await self._interruptible_sleep(reconnect)
 
     async def _interruptible_sleep(self, seconds: float) -> None:
         """Sleep for *seconds* but wake immediately if stop is requested."""
         try:
-            await asyncio.wait_for(
-                asyncio.shield(self._stop_event.wait()),
-                timeout=seconds,
-            )
+            await asyncio.wait_for(self._stop_event.wait(), timeout=seconds)
         except asyncio.TimeoutError:
             pass

{fixcore_engine-0.1.3 → fixcore_engine-0.1.5/fixcore_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixcore-engine
-Version: 0.1.3
+Version: 0.1.5
 Summary: Pure Python FIX protocol engine
 Author-email: Aidan Chisholm <aidan.chisholm@gmail.com>
 License: MIT License

{fixcore_engine-0.1.3 → fixcore_engine-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fixcore-engine"
-version = "0.1.3"
+version = "0.1.5"
 description = "Pure Python FIX protocol engine"
 readme = "README.md"
 license = { file = "LICENSE" }