aioads 0.1.0.dev6__tar.gz → 0.1.0.dev7__tar.gz

{aioads-0.1.0.dev6 → aioads-0.1.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioads
-Version: 0.1.0.dev6
+Version: 0.1.0.dev7
 Summary: An asynchronous Python library for communicating with Beckhoff TwinCAT PLCs
 Author-email: MkKiefer <102972583+MkKiefer@users.noreply.github.com>
 License: MIT

{aioads-0.1.0.dev6 → aioads-0.1.0.dev7}/aioads/transport.py

@@ -7,6 +7,7 @@ import enum
 import logging
 import random
 import re
+import socket
 from abc import ABC
 from dataclasses import dataclass
 from dataclasses import field
@@ -211,6 +212,22 @@ class AdsTcpTransport(BaseTransport, ITransport):
     RECONNECT_INITIAL_BACKOFF = 1.0
     RECONNECT_MAX_BACKOFF = 30.0
 
+    # TCP keepalive / liveness tuning.
+    # Without these, a half-open connection (peer power-cut, cable pull, NAT
+    # idle-eviction) is never detected: no FIN/RST arrives, so the read loop
+    # blocks forever and the supervisor never reconnects. These force the kernel
+    # to probe an idle peer and to bound how long unacked writes wait, so a dead
+    # link surfaces as a socket error within ~KEEPALIVE_IDLE + KEEPALIVE_INTERVAL
+    # * KEEPALIVE_COUNT seconds.
+    KEEPALIVE_IDLE = 10
+    """Seconds of idle before the kernel starts sending keepalive probes (Linux: TCP_KEEPIDLE)."""
+    KEEPALIVE_INTERVAL = 3
+    """Seconds between keepalive probes (Linux: TCP_KEEPINTVL)."""
+    KEEPALIVE_COUNT = 3
+    """Unanswered probes before the connection is considered dead (Linux: TCP_KEEPCNT)."""
+    USER_TIMEOUT_MS = 15_000
+    """Milliseconds an unacked write may wait before the socket errors (Linux: TCP_USER_TIMEOUT)."""
+
     def __init__(
         self,
         src_address: AmsAddress,
@@ -279,10 +296,43 @@ class AdsTcpTransport(BaseTransport, ITransport):
         reader, writer = await asyncio.wait_for(
             asyncio.open_connection(self.ip, self.port), self.CONNECT_TIMEOUT
         )
+
+        self._enable_keepalive(writer)
         async with self._stream_lock:
             self._stream = (reader, writer)
         self._state = ConnectionState.CONNECTED
 
+    def _enable_keepalive(self, writer: asyncio.StreamWriter) -> None:
+        """
+        Enable TCP keepalive so a half-open connection is detected 
+        even when no FIN/RST is ever sent.
+
+        The per-option settings beyond SO_KEEPALIVE are platform specific; each
+        is applied only when the running platform exposes it, so this stays a
+        no-op on systems that lack the knob rather than raising.
+        """
+
+        sock: socket.socket | None = writer.get_extra_info("socket")
+        if sock is None:
+            self.logger.warning(
+                "Failed to enable TCP keepalive: StreamWriter has no socket"
+            )
+            return
+
+        try:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+            for opt_name, value in (
+                ("TCP_KEEPIDLE", self.KEEPALIVE_IDLE),
+                ("TCP_KEEPINTVL", self.KEEPALIVE_INTERVAL),
+                ("TCP_KEEPCNT", self.KEEPALIVE_COUNT),
+                ("TCP_USER_TIMEOUT", self.USER_TIMEOUT_MS),
+            ):
+                opt = getattr(socket, opt_name, None)
+                if opt is not None:
+                    sock.setsockopt(socket.IPPROTO_TCP, opt, value)
+        except OSError as e:
+            self.logger.warning("Failed to enable TCP keepalive: %s", e)
+
     async def _teardown_stream(self, ex: BaseException):
         """
         Fail all in-flight requests and close the current stream (if any).
@@ -364,7 +414,7 @@ class AdsTcpTransport(BaseTransport, ITransport):
         while self._state is not ConnectionState.CLOSED:
             try:
                 await self._read_loop()
-            except asyncio.CancelledError: #pylint: disable=try-except-raise
+            except asyncio.CancelledError:  # pylint: disable=try-except-raise
                 # Except everything... except a cancellation event
                 raise
             except Exception as e:
@@ -382,7 +432,7 @@ class AdsTcpTransport(BaseTransport, ITransport):
                     self.logger.info("Reconnected to the remote")
                     backoff = self.RECONNECT_INITIAL_BACKOFF
                     break
-                except asyncio.CancelledError: #pylint: disable=try-except-raise
+                except asyncio.CancelledError:  # pylint: disable=try-except-raise
                     raise
                 except Exception as e:  # pylint: disable=broad-exception-caught
                     self.logger.info(

{aioads-0.1.0.dev6 → aioads-0.1.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioads"
-version = "0.1.0.dev6"
+version = "0.1.0.dev7"
 description = "An asynchronous Python library for communicating with Beckhoff TwinCAT PLCs"
 authors = [
     { name = "MkKiefer", email = "102972583+MkKiefer@users.noreply.github.com" },

{aioads-0.1.0.dev6 → aioads-0.1.0.dev7}/tests/unit/test_transport.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+import socket
 import unittest
 from unittest.mock import Mock
 
@@ -216,5 +217,73 @@ class TestAdsTcpTransport(unittest.IsolatedAsyncioTestCase):
         self.assertIsInstance(ctx.exception.__cause__, asyncio.IncompleteReadError)
 
 
+class TestAdsTcpTransportKeepalive(unittest.TestCase):
+    """TCP keepalive / liveness configuration applied to the active socket."""
+
+    def setUp(self) -> None:
+        self.transport = AdsTcpTransport(
+            src_address=make_ams_address(), ip="127.0.0.1"
+        )
+        # A real AF_INET TCP socket whose options we can read back. It does not
+        # need to be connected to accept these socket options.
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.addCleanup(self.sock.close)
+        # A StreamWriter exposes its underlying socket via get_extra_info("socket").
+        self.writer = Mock()
+        self.writer.get_extra_info.return_value = self.sock
+
+    def test_enable_keepalive_turns_on_so_keepalive(self) -> None:
+        # Act
+        self.transport._enable_keepalive(self.writer)
+
+        # Assert
+        self.assertEqual(
+            self.sock.getsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE), 1
+        )
+
+    @unittest.skipUnless(
+        hasattr(socket, "TCP_KEEPIDLE"), "platform lacks TCP keepalive tuning"
+    )
+    def test_enable_keepalive_applies_configured_tuning_values(self) -> None:
+        # Act
+        self.transport._enable_keepalive(self.writer)
+
+        # Assert — each kernel knob reflects the transport's configured constant
+        expected = [
+            ("TCP_KEEPIDLE", AdsTcpTransport.KEEPALIVE_IDLE),
+            ("TCP_KEEPINTVL", AdsTcpTransport.KEEPALIVE_INTERVAL),
+            ("TCP_KEEPCNT", AdsTcpTransport.KEEPALIVE_COUNT),
+            ("TCP_USER_TIMEOUT", AdsTcpTransport.USER_TIMEOUT_MS),
+        ]
+        for opt_name, value in expected:
+            opt = getattr(socket, opt_name, None)
+            if opt is None:
+                continue
+            with self.subTest(option=opt_name):
+                self.assertEqual(
+                    self.sock.getsockopt(socket.IPPROTO_TCP, opt), value
+                )
+
+    def test_enable_keepalive_without_socket_does_not_raise(self) -> None:
+        # Arrange — a StreamWriter without an underlying socket
+        self.writer.get_extra_info.return_value = None
+
+        # Act / Assert — keepalive is best-effort, so it is skipped quietly
+        try:
+            self.transport._enable_keepalive(self.writer)
+        except Exception as e:  # pragma: no cover - failure path
+            self.fail(f"_enable_keepalive must not raise when no socket: {e}")
+
+    def test_enable_keepalive_on_closed_socket_does_not_raise(self) -> None:
+        # Arrange — a closed socket makes setsockopt fail with OSError
+        self.sock.close()
+
+        # Act / Assert — keepalive is best-effort, so the error is swallowed
+        try:
+            self.transport._enable_keepalive(self.writer)
+        except OSError:
+            self.fail("_enable_keepalive must not propagate socket errors")
+
+
 if __name__ == "__main__":
     unittest.main()