fix: hot-swap modem driver when modem_type changes in settings (#164)

The polling loop now detects modem config changes (type, URL, credentials)
and re-instantiates the driver without requiring a container restart. Also
makes the polling loop exit faster by using non-blocking executor shutdown
and checking stop_event inside the as_completed loop.

Author: itsDNNS

app/main.py

@@ -46,6 +46,16 @@ def run_web(port):
     serve(web.app, host="0.0.0.0", port=port, threads=4, _quiet=True)
 
 
+def _get_modem_config_key(config_mgr):
+    """Return modem config tuple for driver hot-swap change detection."""
+    return (
+        config_mgr.get("modem_type", "fritzbox"),
+        config_mgr.get("modem_url", ""),
+        config_mgr.get("modem_user", ""),
+        config_mgr.get("modem_password", ""),
+    )
+
+
 def polling_loop(config_mgr, storage, stop_event):
     """Flat orchestrator: tick every second, let each collector decide when to poll."""
     config = config_mgr.get_all()
@@ -110,6 +120,13 @@ def polling_loop(config_mgr, storage, stop_event):
         web.init_collector(modem_collector)
     web.init_collectors(collectors)
 
+    # Track modem config for driver hot-swap detection
+    modem_config_key = (
+        _get_modem_config_key(config_mgr)
+        if modem_collector and modem_collector.name == "modem"
+        else None
+    )
+
     log.info(
         "Collectors: %s",
         ", ".join(
@@ -129,10 +146,43 @@ def _run_collector(collector):
         finally:
             collector._collect_lock.release()
 
-    with ThreadPoolExecutor(
+    executor = ThreadPoolExecutor(
         max_workers=len(collectors), thread_name_prefix="collector"
-    ) as executor:
+    )
+    try:
         while not stop_event.is_set():
+            # ── Driver hot-swap: detect modem config change ──
+            if modem_config_key is not None and modem_collector:
+                new_key = _get_modem_config_key(config_mgr)
+                if new_key != modem_config_key:
+                    log.info(
+                        "Modem config changed (%s -> %s), hot-swapping driver",
+                        modem_config_key[0], new_key[0],
+                    )
+                    from .collectors.modem import ModemCollector
+                    from .drivers import driver_registry
+                    new_driver = driver_registry.load_driver(*new_key)
+                    new_modem = ModemCollector(
+                        driver=new_driver,
+                        analyzer_fn=analyzer.analyze,
+                        event_detector=event_detector,
+                        storage=storage,
+                        mqtt_pub=mqtt_pub,
+                        web=web,
+                        poll_interval=config_mgr.get("poll_interval", 900),
+                        notifier=notifier,
+                    )
+                    collectors = [
+                        new_modem if c is modem_collector else c
+                        for c in collectors
+                    ]
+                    modem_collector = new_modem
+                    web.init_collector(new_modem)
+                    web.init_collectors(collectors)
+                    web.reset_modem_state()
+                    modem_config_key = new_key
+                    log.info("Driver hot-swapped to %s", new_key[0])
+
             futures = {}
             for collector in collectors:
                 if stop_event.is_set():
@@ -146,6 +196,8 @@ def _run_collector(collector):
 
             try:
                 for future in as_completed(futures, timeout=120):
+                    if stop_event.is_set():
+                        break
                     collector = futures[future]
                     try:
                         _, result = future.result()
@@ -168,6 +220,8 @@ def _run_collector(collector):
                         future.cancel()
 
             stop_event.wait(1)
+    finally:
+        executor.shutdown(wait=False, cancel_futures=True)
 
     # Cleanup MQTT
     if mqtt_pub:

tests/test_collectors.py

@@ -1158,3 +1158,137 @@ def test_orchestrator_stops_on_event(self, mock_web, mock_load):
 
         polling_loop(config_mgr, storage, stop)
         # If we get here without hanging, the test passes
+
+    @patch("app.drivers.driver_registry.load_driver")
+    @patch("app.main.web")
+    def test_driver_hot_swap_on_modem_type_change(self, mock_web, mock_load):
+        """Polling loop should hot-swap the modem driver when modem_type changes."""
+        import threading
+        from app.main import polling_loop
+
+        mock_driver = MagicMock()
+        mock_driver.get_device_info.return_value = {"model": "Test", "sw_version": "1.0"}
+        mock_driver.get_connection_info.return_value = {}
+        mock_driver.get_docsis_data.return_value = {}
+        mock_load.return_value = mock_driver
+
+        config_mgr = self._make_config_mgr()
+        storage = MagicMock()
+        stop = threading.Event()
+
+        call_count = [0]
+        original_wait = stop.wait
+
+        def change_modem_after_first_tick(timeout=None):
+            call_count[0] += 1
+            if call_count[0] == 1:
+                # After first tick, change modem_type in config
+                config_mgr.get_all.return_value["modem_type"] = "tc4400"
+                config_mgr.get.side_effect = lambda k, d=None: {
+                    "modem_type": "tc4400",
+                    "modem_url": "http://fritz.box",
+                    "modem_user": "admin",
+                    "modem_password": "pass",
+                    "poll_interval": 900,
+                }.get(k, d)
+                return original_wait(0)
+            elif call_count[0] >= 3:
+                stop.set()
+                return True
+            return original_wait(0)
+
+        stop.wait = change_modem_after_first_tick
+
+        polling_loop(config_mgr, storage, stop)
+
+        # load_driver should have been called at least twice:
+        # once for initial setup, once for hot-swap
+        assert mock_load.call_count >= 2
+        # Second call should use the new modem type
+        second_call = mock_load.call_args_list[1]
+        assert second_call[0][0] == "tc4400"
+        # Web state should have been reset for the swap
+        mock_web.reset_modem_state.assert_called()
+        mock_web.init_collector.assert_called()
+
+    @patch("app.drivers.driver_registry.load_driver")
+    @patch("app.main.web")
+    def test_driver_hot_swap_on_url_change(self, mock_web, mock_load):
+        """Hot-swap should trigger when modem URL changes, not just type."""
+        import threading
+        from app.main import polling_loop
+
+        mock_driver = MagicMock()
+        mock_driver.get_device_info.return_value = {"model": "Test", "sw_version": "1.0"}
+        mock_driver.get_connection_info.return_value = {}
+        mock_driver.get_docsis_data.return_value = {}
+        mock_load.return_value = mock_driver
+
+        config_mgr = self._make_config_mgr()
+        storage = MagicMock()
+        stop = threading.Event()
+
+        call_count = [0]
+        original_wait = stop.wait
+
+        def change_url_after_first_tick(timeout=None):
+            call_count[0] += 1
+            if call_count[0] == 1:
+                # Change URL but keep same modem_type
+                config_mgr.get.side_effect = lambda k, d=None: {
+                    "modem_type": "fritzbox",
+                    "modem_url": "http://192.168.100.1",
+                    "modem_user": "admin",
+                    "modem_password": "pass",
+                    "poll_interval": 900,
+                }.get(k, d)
+                return original_wait(0)
+            elif call_count[0] >= 3:
+                stop.set()
+                return True
+            return original_wait(0)
+
+        stop.wait = change_url_after_first_tick
+
+        polling_loop(config_mgr, storage, stop)
+
+        # load_driver called twice: initial + hot-swap for URL change
+        assert mock_load.call_count >= 2
+        second_call = mock_load.call_args_list[1]
+        assert second_call[0][1] == "http://192.168.100.1"
+
+    @patch("app.drivers.driver_registry.load_driver")
+    @patch("app.main.web")
+    def test_no_hot_swap_when_config_unchanged(self, mock_web, mock_load):
+        """No hot-swap should occur when modem config hasn't changed."""
+        import threading
+        from app.main import polling_loop
+
+        mock_driver = MagicMock()
+        mock_driver.get_device_info.return_value = {"model": "Test", "sw_version": "1.0"}
+        mock_driver.get_connection_info.return_value = {}
+        mock_driver.get_docsis_data.return_value = {}
+        mock_load.return_value = mock_driver
+
+        config_mgr = self._make_config_mgr()
+        storage = MagicMock()
+        stop = threading.Event()
+
+        call_count = [0]
+        original_wait = stop.wait
+
+        def stop_after_ticks(timeout=None):
+            call_count[0] += 1
+            if call_count[0] >= 3:
+                stop.set()
+                return True
+            return original_wait(0)
+
+        stop.wait = stop_after_ticks
+
+        polling_loop(config_mgr, storage, stop)
+
+        # load_driver should only be called once (initial setup)
+        assert mock_load.call_count == 1
+        # reset_modem_state should NOT have been called (no swap)
+        mock_web.reset_modem_state.assert_not_called()