fix no auto reconnect after close/connect in TCPclient

pymodbus/client/tcp.py

@@ -57,9 +57,15 @@ def __init__(
         self.loop = None
         self.connected = False
         self.delay_ms = self.params.reconnect_delay
+        self._reconnect_future = None
 
     async def connect(self):  # pylint: disable=invalid-overridden-method
         """Initiate connection to start client."""
+
+        # if delay_ms was set to 0 by close(), we need to set it back again
+        # so this instance will work
+        self.reset_delay()
+
         # force reconnect if required:
         self.loop = asyncio.get_running_loop()
 
@@ -70,6 +76,11 @@ async def connect(self):  # pylint: disable=invalid-overridden-method
     async def close(self):  # pylint: disable=invalid-overridden-method
         """Stop client."""
 
+        # if there is an unfinished delayed reconnection attempt pending, cancel it
+        if self._reconnect_future:
+            self._reconnect_future.cancel()
+            self._reconnect_future = None
+
         # prevent reconnect:
         self.delay_ms = 0
         if self.connected:
@@ -121,7 +132,7 @@ async def _connect(self):
             txt = f"Failed to connect: {exc}"
             _logger.warning(txt)
             if self.delay_ms > 0:
-                asyncio.ensure_future(self._reconnect())
+                self._launch_reconnect()
         else:
             txt = f"Connected to {self.params.host}:{self.params.port}."
             _logger.info(txt)
@@ -150,7 +161,18 @@ def protocol_lost_connection(self, protocol):
             del self.protocol
             self.protocol = None
         if self.delay_ms > 0:
-            asyncio.ensure_future(self._reconnect())
+            self._launch_reconnect()
+
+    def _launch_reconnect(self):
+        """Launch delayed reconnection coroutine"""
+        if self._reconnect_future:
+            _logger.warning(
+                "Ignoring attempt to launch a delayed reconnection while another is already in progress"
+            )
+        else:
+            # store the future in a member variable so we know we have a pending reconnection attempt
+            # also prevents its garbage collection
+            self._reconnect_future = asyncio.ensure_future(self._reconnect())
 
     async def _reconnect(self):
         """Reconnect."""
@@ -159,6 +181,7 @@ async def _reconnect(self):
         await asyncio.sleep(self.delay_ms / 1000)
         self.delay_ms = min(2 * self.delay_ms, self.params.reconnect_delay_max)
 
+        self._reconnect_future = None
         return await self._connect()
 
 

test/test_client.py

@@ -538,7 +538,9 @@ async def test_client_reconnect(mock_sleep):
     client = lib_client.AsyncModbusTcpClient(
         "127.0.0.1", protocol_class=mock_protocol_class
     )
-    client.delay_ms = 5000
+
+    # set delay long enough so we have only one connection attempt below
+    client.params.reconnect_delay = 5000
     await client.connect()
 
     run_coroutine(client._reconnect())  # pylint: disable=protected-access