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

This reverts commit f381028.

Author: itsDNNS

app/main.py

@@ -46,16 +46,6 @@ 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()
@@ -120,13 +110,6 @@ 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(
@@ -146,43 +129,10 @@ def _run_collector(collector):
         finally:
             collector._collect_lock.release()
 
-    executor = ThreadPoolExecutor(
+    with ThreadPoolExecutor(
         max_workers=len(collectors), thread_name_prefix="collector"
-    )
-    try:
+    ) as executor:
         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():
@@ -196,8 +146,6 @@ 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()
@@ -220,8 +168,6 @@ 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

@@ -1175,137 +1175,3 @@ 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()