fix: shared TCP connection never recovers from silent connection loss (#354)

Upstream v1.0.x routes every TCP entry through SharedModbusConnection,
whose ensure_connected() trusts pymodbus is_socket_open(). For sync
clients that is just `self.socket is not None`, and pymodbus never
clears the socket on receive timeouts (connection_lost() is a no-op
without an asyncio transport). After a silent drop (gateway reboot,
Wi-Fi dropout, idle NAT timeout) every poll reused the dead socket
forever; only an HA restart recovered.

- SharedModbusConnection.reset(): force-close so the next
  ensure_connected() performs a real reconnect (with buffer flush)
- _fetch_data_shared(): on a failed poll, reset + reconnect + retry
  once in-poll; reset again if the retry also fails, and on exceptions
- hub write_register/write_registers: drop the socket on transport
  level exceptions so service writes self-heal via ensure_connected()

Restores the self-healing the pre-v1.0 per-poll reconnect path had.

Co-authored-by: jekmanis <jekmanis@users.noreply.github.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: jekmanis

custom_components/growatt_modbus/coordinator.py

@@ -951,6 +951,24 @@ def _fetch_data_shared(self) -> GrowattData | None:
                 self._client.min_read_interval = delay_s
 
             data = self._client.read_all_data()
+            if data is None:
+                # The connection may be silently dead: pymodbus sync clients never
+                # clear their socket on receive timeouts, so is_socket_open() stays
+                # True and ensure_connected() would reuse the dead socket on every
+                # poll until HA restarts. Force a real reconnect and retry once.
+                hub.reset("poll returned no data")
+                if hub.ensure_connected():
+                    _LOGGER.info(
+                        "Reconnected to %s:%s — retrying poll for slave %s",
+                        self.config.get(CONF_HOST), self.config.get(CONF_PORT),
+                        self.config.get(CONF_SLAVE_ID),
+                    )
+                    data = self._client.read_all_data()
+                    if data is None:
+                        # Still failing — drop the socket so the next scheduled poll
+                        # starts from a clean connect instead of a stale session.
+                        hub.reset("retry poll returned no data")
+
             if data is not None and not self._serial_number:
                 self._read_device_identification()
 
@@ -960,6 +978,7 @@ def _fetch_data_shared(self) -> GrowattData | None:
         except Exception as err:
             _LOGGER.warning("Error during shared data fetch for slave %s: %s",
                             self.config.get(CONF_SLAVE_ID), err)
+            hub.reset("exception during poll")
             return None
 
         finally:

custom_components/growatt_modbus/growatt_modbus.py

@@ -454,6 +454,21 @@ def disconnect(self) -> None:
                 pass
             self._connected = False
 
+    def reset(self, reason: str = "") -> None:
+        """Force-close the socket so the next ensure_connected() does a real reconnect.
+
+        pymodbus sync clients never clear their socket after a silent connection loss
+        (receive timeouts don't trigger close(), and connection_lost() is a no-op for
+        sync clients), so is_socket_open() keeps returning True and ensure_connected()
+        would reuse the dead socket forever. Without this, only an HA restart recovers
+        a wedged connection.
+        """
+        logger.warning(
+            "[SharedConn %s:%s] Resetting connection%s",
+            self.host, self.port, f": {reason}" if reason else "",
+        )
+        self.disconnect()
+
     def _flush_receive_buffer(self) -> None:
         """Drain stale Modbus responses left in the adapter's TCP buffer after reconnect."""
         sock = getattr(self._client, 'socket', None)
@@ -550,6 +565,9 @@ def write_register(self, register: int, value: int, slave_id: int) -> bool:
         except Exception as exc:
             logger.debug("[SharedConn %s:%s] write_register(%d, %d, slave=%d) error: %s",
                          self.host, self.port, register, value, slave_id, exc)
+            # An exception here is transport-level (register-level refusals come back
+            # as isError() responses) — drop the socket so the next call reconnects.
+            self.disconnect()
             return False
 
     def write_registers(self, register: int, values: list, slave_id: int) -> bool:
@@ -567,6 +585,9 @@ def write_registers(self, register: int, values: list, slave_id: int) -> bool:
         except Exception as exc:
             logger.debug("[SharedConn %s:%s] write_registers(%d, slave=%d) error: %s",
                          self.host, self.port, register, slave_id, exc)
+            # An exception here is transport-level (register-level refusals come back
+            # as isError() responses) — drop the socket so the next call reconnects.
+            self.disconnect()
             return False