Log disconnect and reconnect once.

Author: denpamusic

pyplumio/connection.py

@@ -37,11 +37,12 @@ class Connection(ABC, TaskManager):
     All specific connection classes MUST be inherited from this class.
     """
 
-    __slots__ = ("_protocol", "_reconnect_on_failure", "_options")
+    __slots__ = ("_protocol", "_reconnect_on_failure", "_options", "_retries")
 
     _protocol: Protocol
     _reconnect_on_failure: bool
     _options: dict[str, Any]
+    _retries: int
 
     def __init__(
         self,
@@ -60,6 +61,7 @@ def __init__(
         self._reconnect_on_failure = reconnect_on_failure
         self._protocol = protocol
         self._options = options
+        self._retries = 0
 
     async def __aenter__(self) -> Connection:
         """Provide an entry point for the context manager."""
@@ -86,11 +88,21 @@ async def _reconnect(self) -> None:
         """Try to connect and reconnect on failure."""
         try:
             await self._connect()
+            if self._retries > 0:
+                _LOGGER.info(
+                    "Connection to device restored after %i retries", self._retries
+                )
+                self._retries = 0
         except ConnectionFailedError:
-            _LOGGER.error(
-                "Can't connect to the device, retrying in %.1f seconds",
-                RECONNECT_AFTER_SECONDS,
-            )
+            if self._retries == 0:
+                _LOGGER.error(
+                    (
+                        "Unable to connect to the device. Connection we be retried "
+                        "automatically every %i seconds in background."
+                    ),
+                    RECONNECT_AFTER_SECONDS,
+                )
+            self._retries += 1
             await asyncio.sleep(RECONNECT_AFTER_SECONDS)
             self.create_task(self._reconnect(), name="reconnect_task")
 

tests/test_connection.py

@@ -13,7 +13,12 @@
 from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE
 
 import pyplumio.connection
-from pyplumio.connection import Connection, SerialConnection, TcpConnection
+from pyplumio.connection import (
+    RECONNECT_AFTER_SECONDS,
+    Connection,
+    SerialConnection,
+    TcpConnection,
+)
 from pyplumio.devices.ecomax import EcoMAX
 from pyplumio.exceptions import ConnectionFailedError
 from pyplumio.protocol import AsyncProtocol, DummyProtocol, Protocol
@@ -115,33 +120,43 @@ async def test_connect(self, mock_open_connection, mock_protocol) -> None:
         await connection.close()
         mock_protocol.shutdown.assert_called_once()
 
-    @pytest.mark.parametrize(
-        ("reconnect_on_failure", "expected_log"),
-        [
-            (True, "Can't connect to the device"),
-            (False, None),
-        ],
+    @pytest.mark.parametrize("reconnect_on_failure", [True, False])
+    @patch.object(
+        DummyConnection,
+        "_open_connection",
+        side_effect=(OSError, (AsyncMock(), AsyncMock), None),
     )
-    @patch.object(DummyConnection, "_open_connection", side_effect=(OSError, None))
+    @patch("pyplumio.protocol.AsyncProtocol.connection_established")
     async def test_reconnect(
         self,
+        mock_connection_established,
         mock_open_connection,
         caplog,
         reconnect_on_failure: bool,
-        expected_log: str | None,
     ) -> None:
         """Test reconnect logic."""
         connection = DummyConnection(reconnect_on_failure=reconnect_on_failure)
         if reconnect_on_failure:
             with caplog.at_level(logging.ERROR):
                 await connection.connect()
+                assert "Unable to connect to the device." in caplog.text
+                assert (
+                    f"Will attempt to reconnect every {RECONNECT_AFTER_SECONDS} seconds"
+                    in caplog.text
+                )
+
+            with caplog.at_level(logging.INFO):
+                await connection.connect()
+                assert "Connection to device restored after 1 retries" in caplog.text
+                mock_connection_established.assert_called_once()
+
+            assert mock_open_connection.await_count == 2
 
-            assert expected_log in caplog.text
         else:
             with pytest.raises(ConnectionFailedError):
                 await connection.connect()
 
-        mock_open_connection.assert_awaited_once()
+            mock_open_connection.assert_awaited_once()
 
     @patch.object(DummyConnection, "close")
     @patch.object(DummyConnection, "connect")