update blocking calls and FW comparitor

Author: zakery292

custom_components/monitormysolar/config_flow.py

@@ -10,6 +10,32 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+
+def _raw_entity_ids_in_use(hass, exclude_entry_id=None) -> bool:
+    """Whether an existing entry already owns un-prefixed (raw) entity_ids.
+
+    Raw entity_ids (sensor.soc instead of sensor.<dongle>_soc) are a singleton
+    across the whole HA instance: a second entry using them would compute the
+    same entity_ids, the registry would dedupe its entities to _2 suffixes, and
+    those entities would never receive data. Mirrors the effective-prefix rules
+    in coordinator.get_entity_prefix (explicit entity_prefix wins; legacy
+    entries fall back to the drop_dongle_id flag).
+    """
+    for entry in hass.config_entries.async_entries(DOMAIN):
+        if entry.entry_id == exclude_entry_id:
+            continue
+        dongle_data = entry.data.get("dongle_data") or []
+        for dongle in dongle_data:
+            if "entity_prefix" in dongle:
+                if not (dongle.get("entity_prefix") or "").strip():
+                    return True
+            elif entry.data.get(CONF_DROP_DONGLE_ID) and len(dongle_data) == 1:
+                return True
+        if not dongle_data and entry.data.get(CONF_DROP_DONGLE_ID):
+            return True
+    return False
+
+
 class InverterMQTTFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Inverter MQTT."""
 
@@ -110,17 +136,30 @@ async def async_step_single_inverter(self, user_input=None):
             #             user can drop the dongle id later via the options flow, which
             #             performs a proper history-preserving registry rename.
             install_kind = user_input.pop("install_kind", "fresh")
-            user_input[CONF_DROP_DONGLE_ID] = install_kind == "fresh"
 
             # Merge with initial data
             data = {**self.initial_data, **user_input}
 
-            # Create dongle data structure for single inverter.
-            # Single-dongle installs get NO entity_id prefix (clean names like
-            # sensor.battery_soc) — we never ask. entity_prefix stays empty.
+            # Entity naming. Raw (un-prefixed) entity_ids are a singleton across
+            # the HA instance: if another entry already owns them, this entry's
+            # entities would be _2-deduped by the registry and never get data —
+            # so a second raw install is forced onto the dongle-id prefix.
+            entity_prefix = ""
+            if install_kind == "reconnect":
+                entity_prefix = data["dongle_id"]
+            elif _raw_entity_ids_in_use(self.hass):
+                entity_prefix = data["dongle_id"]
+                _LOGGER.warning(
+                    "Raw entity_ids already owned by another entry; forcing entity "
+                    "prefix %r for dongle %s", entity_prefix, data["dongle_id"],
+                )
+            # Keep the legacy flag consistent with the prefix actually in use
+            # (it drives the entity-registry rename migration).
+            data[CONF_DROP_DONGLE_ID] = entity_prefix == ""
+
             dongle_data = [{
                 "dongle_id": data["dongle_id"],
-                "entity_prefix": "",
+                "entity_prefix": entity_prefix,
                 "is_master": True,
                 "is_slave": False,
                 "is_gridboss": False,
@@ -879,6 +918,7 @@ async def async_step_replace_dongle(self, user_input=None):
 
     async def async_step_update_settings(self, user_input=None):
         """Update general settings."""
+        errors = {}
         if user_input is not None:
             new_data = dict(self.config_entry.data)
 
@@ -902,20 +942,39 @@ async def async_step_update_settings(self, user_input=None):
             # Changing this triggers a history-preserving entity-registry rename on
             # reload (see migration.async_migrate_entity_ids).
             if CONF_DROP_DONGLE_ID in user_input:
-                new_data[CONF_DROP_DONGLE_ID] = user_input[CONF_DROP_DONGLE_ID]
+                want_raw = user_input[CONF_DROP_DONGLE_ID]
+                # Raw entity_ids are a singleton across entries — refuse to
+                # switch to them while another entry owns them (the registry
+                # would _2-dedupe this entry's entities and they'd get no data).
+                if want_raw and _raw_entity_ids_in_use(
+                    self.hass, exclude_entry_id=self.config_entry.entry_id
+                ):
+                    errors["base"] = "raw_ids_taken"
+                else:
+                    new_data[CONF_DROP_DONGLE_ID] = want_raw
+                    # dongle_data.entity_prefix is the runtime source of truth
+                    # (it wins over the legacy flag) — keep it in sync so the
+                    # toggle takes effect on new-style entries too.
+                    dongle_data = [dict(d) for d in new_data.get("dongle_data", [])]
+                    if len(dongle_data) == 1 and "entity_prefix" in dongle_data[0]:
+                        dongle_data[0]["entity_prefix"] = (
+                            "" if want_raw else dongle_data[0]["dongle_id"]
+                        )
+                        new_data["dongle_data"] = dongle_data
 
             # Update firmware track (prod/beta) if provided.
             if CONF_USE_BETA in user_input:
                 new_data[CONF_USE_BETA] = user_input[CONF_USE_BETA]
 
-            self.hass.config_entries.async_update_entry(
-                self.config_entry, data=new_data
-            )
+            if not errors:
+                self.hass.config_entries.async_update_entry(
+                    self.config_entry, data=new_data
+                )
 
-            # Reload the integration so device grouping / naming changes take effect
-            await self.hass.config_entries.async_reload(self.config_entry.entry_id)
+                # Reload the integration so device grouping / naming changes take effect
+                await self.hass.config_entries.async_reload(self.config_entry.entry_id)
 
-            return self.async_create_entry(title="", data={})
+                return self.async_create_entry(title="", data={})
 
         current_update_interval = self.config_entry.data.get("update_interval", 60)
         current_has_gridboss = self.config_entry.data.get("has_gridboss", False)
@@ -951,7 +1010,8 @@ async def async_step_update_settings(self, user_input=None):
 
         return self.async_show_form(
             step_id="update_settings",
-            data_schema=schema
+            data_schema=schema,
+            errors=errors,
         )
 
     async def async_step_check_status(self, user_input=None):

custom_components/monitormysolar/const.py

@@ -106,6 +106,45 @@ def firmware_group(code: str) -> str:
     return "legacy"
 
 
+def version_tuple(version):
+    """Parse a dotted version into an int tuple ('4.3.2.2C6' -> (4, 3, 2, 2)).
+
+    Trailing non-digits per segment (chip suffixes like C6/S3) are stripped.
+    Returns None if any segment has no leading digits or the string is empty.
+    """
+    if not version:
+        return None
+    nums = []
+    for part in str(version).strip().split("."):
+        digits = ""
+        for ch in part:
+            if ch.isdigit():
+                digits += ch
+            else:
+                break
+        if not digits:
+            return None
+        nums.append(int(digits))
+    return tuple(nums) or None
+
+
+def fw_version_is_newer(latest: str, installed: str) -> bool:
+    """Whether `latest` is strictly newer than `installed` (numeric compare).
+
+    Shorter tuples are zero-padded, so 4.3.2 == 4.3.2.0. Unparseable versions
+    fall back to plain inequality (any difference counts as an update) so a
+    malformed server version can hide behind equality but never crash.
+    """
+    latest_t = version_tuple(latest)
+    installed_t = version_tuple(installed)
+    if latest_t is None or installed_t is None:
+        return latest != installed
+    width = max(len(latest_t), len(installed_t))
+    return (latest_t + (0,) * (width - len(latest_t))) > (
+        installed_t + (0,) * (width - len(installed_t))
+    )
+
+
 def fw_code_get(mapping: dict, code: str, default=None):
     """Case-insensitive lookup of a firmware code in a code-keyed table.
 

custom_components/monitormysolar/coordinator.py

@@ -102,6 +102,12 @@ def __init__(
         self._gridboss_dongle = entry.data.get("gridboss_dongle", "")  # Track which dongle is GridBoss
         self._last_fault_warning_data = {}  # Track last fault/warning data to prevent duplicate processing
         self._hass_startup_complete = False  # Track if Home Assistant has finished starting up
+        # Failsafe for the startup gate: if the 30s mark_startup_complete timer
+        # never fires, force the gate open at this monotonic deadline instead of
+        # silently dropping data messages forever. 60s > the 30s timer so the
+        # timer always wins when it works.
+        self._gate_opened_deadline = time.monotonic() + 60.0
+        self._startup_dropped_count = 0  # Data messages dropped while gated (diagnostics)
         self._smart_soc_volt_bits = {}  # Track SmartSOCVoltBits for each dongle
         self._smartload_bits = {}  # Track SmartLoad Bits for each dongle
         self._port_modes = {}  # Track Port Mode settings for each dongle
@@ -1281,8 +1287,24 @@ async def _async_handle_mqtt_message(self, msg) -> None:
                 self.async_set_updated_data(self.entities)
             # Skip other message processing during startup to prevent excessive updates
             elif not self._hass_startup_complete:
-                # Just store the message for later processing if needed
-                pass
+                # Failsafe: the gate is opened by a 30s timer in async_setup. If
+                # that timer ever fails to fire, every data message would be
+                # silently dropped forever (entities populate once from the
+                # snapshot, then flatline). Never trust the timer alone: force
+                # the gate open once we're clearly past the startup window.
+                # getattr: test coordinators are built via __new__ and skip __init__.
+                deadline = getattr(self, "_gate_opened_deadline", None)
+                if deadline is not None and time.monotonic() >= deadline:
+                    LOGGER.warning(
+                        "Startup gate still closed past its deadline (%d data "
+                        "messages dropped so far) - forcing it open",
+                        getattr(self, "_startup_dropped_count", 0),
+                    )
+                    self._hass_startup_complete = True
+                    await self.process_message(dongle_id, topic, msg.payload)
+                    self.async_set_updated_data(self.entities)
+                else:
+                    self._startup_dropped_count = getattr(self, "_startup_dropped_count", 0) + 1
             else:
                 # Process messages normally after startup is complete
                 if topic.endswith("/response"):
@@ -1542,7 +1564,11 @@ async def async_setup(self):
         # Schedule startup completion after a delay to allow Home Assistant to finish starting up
         async def mark_startup_complete(_):
             self._hass_startup_complete = True
-            LOGGER.info("Home Assistant startup complete - MQTT message processing enabled")
+            LOGGER.info(
+                "Home Assistant startup complete - MQTT message processing enabled "
+                "(%d data messages were dropped during the startup window)",
+                getattr(self, "_startup_dropped_count", 0),
+            )
 
             # Trigger entity availability updates for all dongles now that startup is complete
             for dongle_id in self._dongle_ids:

custom_components/monitormysolar/manifest.json

@@ -10,6 +10,6 @@
   "issue_tracker": "https://github.com/Monitor-My-Solar/monitormysolar",
   "loggers": [],
   "requirements": [],    
-  "version": "4.0.2"
+  "version": "4.0.3.1"
 }
 

custom_components/monitormysolar/migration.py

@@ -12,7 +12,8 @@
 from __future__ import annotations
 
 import logging
-from logging.handlers import RotatingFileHandler
+import queue
+from logging.handlers import QueueHandler, QueueListener, RotatingFileHandler
 
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -29,29 +30,40 @@
 # audited after the fact — which the main HA log couldn't give us.
 _AUDIT_LOGGER_NAME = "monitormysolar.migration_audit"
 _audit_logger: logging.Logger | None = None
+_audit_listener: QueueListener | None = None  # keep a ref so it isn't GC'd
 
 
 def _get_audit_logger(hass: HomeAssistant) -> logging.Logger:
-    """Lazily build a file-backed audit logger in the HA config directory."""
-    global _audit_logger
+    """Lazily build a file-backed audit logger in the HA config directory.
+
+    audit() is called from the event loop, so no file I/O may happen there:
+    the logger emits into a queue (non-blocking) and a QueueListener thread
+    does the actual file writes. delay=True on the file handler defers even
+    the open() to the first write — which runs on the listener thread.
+    """
+    global _audit_logger, _audit_listener
     if _audit_logger is not None:
         return _audit_logger
 
     logger = logging.getLogger(_AUDIT_LOGGER_NAME)
     logger.setLevel(logging.INFO)
     logger.propagate = False  # don't spam the main HA log
 
-    # Only attach the file handler once.
+    # Only attach the queue handler once.
     if not logger.handlers:
         try:
             path = hass.config.path("monitormysolar_migration.log")
-            handler = RotatingFileHandler(
-                path, maxBytes=1_000_000, backupCount=3, encoding="utf-8"
+            file_handler = RotatingFileHandler(
+                path, maxBytes=1_000_000, backupCount=3, encoding="utf-8",
+                delay=True,  # open on first write, on the listener thread
             )
-            handler.setFormatter(
+            file_handler.setFormatter(
                 logging.Formatter("%(asctime)s %(message)s", "%Y-%m-%d %H:%M:%S")
             )
-            logger.addHandler(handler)
+            log_queue: queue.SimpleQueue = queue.SimpleQueue()
+            logger.addHandler(QueueHandler(log_queue))
+            _audit_listener = QueueListener(log_queue, file_handler)
+            _audit_listener.start()  # daemon thread; won't block HA shutdown
         except Exception as err:  # pragma: no cover - fs edge cases
             LOGGER.warning("Could not open migration audit log: %s", err)
 

custom_components/monitormysolar/sensor.py

@@ -369,7 +369,18 @@ def _handle_coordinator_update(self) -> None:
                     )
                 self.throttled_async_write_ha_state()
         else:
-            LOGGER.warning(f"entity {self.entity_id} data key {self.data_key} not found")
+            # A missing key is normal until this sensor's dongle has reported the
+            # field (change-data firmware may never send static fields outside a
+            # snapshot, and a quiet dongle in a multi-dongle entry has no data at
+            # all). Every coordinator push runs this for every data-less sensor,
+            # so a per-push WARNING floods the log and trips HA's
+            # "logging too frequently" guard. Log once per entity, at DEBUG.
+            if not getattr(self, "_missing_key_logged", False):
+                self._missing_key_logged = True
+                LOGGER.debug(
+                    "entity %s data key %s not found (logged once per entity)",
+                    self.entity_id, self.data_key,
+                )
 
     async def async_added_to_hass(self) -> None:
         """When entity is added to hass."""

custom_components/monitormysolar/translations/en.json

@@ -41,7 +41,8 @@
       "dongle_already_exists": "This dongle ID already exists",
       "dongle_not_responding": "Dongle is not responding. Please check the ID and ensure it's online.",
       "dongle_id_required": "A new dongle ID is required",
-      "dongle_not_found": "The selected dongle was not found in this configuration"
+      "dongle_not_found": "The selected dongle was not found in this configuration",
+      "raw_ids_taken": "Another Monitor My Solar entry already uses the clean (no dongle ID) entity names. Only one entry can use them - keep the dongle ID in entity names for this one."
     },
     "abort": {
       "cannot_remove_last_dongle": "Cannot remove the last dongle",
@@ -111,4 +112,4 @@
       }
     }
   }
-}
+}

custom_components/monitormysolar/translations/es.json

@@ -36,6 +36,9 @@
     },
     "abort": {
       "no_restorable_entities": "No hay entidades eliminadas o deshabilitadas para restaurar."
+    },
+    "error": {
+      "raw_ids_taken": "Otra entrada de Monitor My Solar ya usa los nombres de entidad limpios (sin ID del dongle). Solo una entrada puede usarlos; mantenga el ID del dongle en los nombres de entidad de esta."
     }
   }
-}
+}

custom_components/monitormysolar/translations/strings.json

@@ -135,6 +135,9 @@
     },
     "abort": {
       "no_restorable_entities": "There are no deleted or disabled entities to restore."
+    },
+    "error": {
+      "raw_ids_taken": "Another Monitor My Solar entry already uses the clean (no dongle ID) entity names. Only one entry can use them - keep the dongle ID in entity names for this one."
     }
   }
-}
+}

custom_components/monitormysolar/update.py

@@ -25,7 +25,7 @@
 from homeassistant.components.update import UpdateEntity, UpdateEntityFeature, UpdateDeviceClass
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.event import async_track_time_interval
-from .const import DOMAIN, ENTITIES, LOGGER, CONF_USE_BETA, DEFAULT_USE_BETA
+from .const import DOMAIN, ENTITIES, LOGGER, CONF_USE_BETA, DEFAULT_USE_BETA, fw_version_is_newer
 from .coordinator import MonitorMySolarEntry
 from .entity import MonitorMySolarEntity
 
@@ -183,6 +183,18 @@ def latest_version(self) -> str | None:
     def _use_beta(self) -> bool:
         """Whether this install should track the beta firmware channel."""
         return self.coordinator.entry.data.get(CONF_USE_BETA, DEFAULT_USE_BETA)
+
+    def version_is_newer(self, latest_version: str, installed_version: str) -> bool:
+        """Offer an update only when the server version is strictly newer.
+
+        HA's default comparison is an inequality, so a unit running a build
+        NEWER than the server's published version (dev/beta units) would be
+        offered a 'downgrade'. Numeric tuple compare instead. Deliberate
+        consequence: a server-side rollback to an older version is not shown
+        in HA — rollbacks are pushed via the /admin OTA command, which does
+        not consult this comparison.
+        """
+        return fw_version_is_newer(latest_version, installed_version)
 
     def release_notes(self) -> str | None:
         """Return the release notes."""