Procházet zdrojové kódy

MQTT relay: door, extruder, filaments and HMS errors in the printer status, Last Will on the broker (#3401) (#3541)

Keybored před 1 týdnem
rodič
revize
ba1f9606c7

+ 26 - 2
backend/app/services/mqtt_relay.py

@@ -20,6 +20,11 @@ from backend.app.utils.paho_teardown import retire_paho_client
 logger = logging.getLogger(__name__)
 
 
+# Fields the printer status topic takes from the same dict the REST status and the
+# WebSocket send, so a subscriber reads them in the shape it already knows (#3401).
+_STATUS_FIELDS_FROM_STATE = ("door_open", "active_extruder", "tray_now", "ams", "vt_tray", "hms_errors")
+
+
 class MQTTRelayService:
     """Publishes BamBuddy events to an external MQTT broker."""
 
@@ -36,6 +41,7 @@ class MQTTRelayService:
         self._broker = ""
         self._port = 1883
         self._last_printer_status: dict[int, float] = {}  # printer_id -> last publish timestamp
+        self._last_printer_connected: dict[int, bool] = {}  # printer_id -> `connected` in the last publish
         self._smart_plug_service = None  # Lazy import to avoid circular dependency
         self._settings: dict = {}  # Store settings for smart plug service
         self._disconnection_event: threading.Event | None = None
@@ -113,6 +119,11 @@ class MQTTRelayService:
                 protocol=mqtt.MQTTv311,
             )
 
+            # Last Will: the broker publishes this when the connection drops without a
+            # clean disconnect (crash, killed container), which would otherwise leave the
+            # retained "online" in place for good (#3401). It replaces that retained message.
+            self.client.will_set(f"{self.topic_prefix}/status", json.dumps({"status": "offline"}), qos=1, retain=True)
+
             # Set up callbacks
             self.client.on_connect = self._on_connect
             self.client.on_disconnect = self._on_disconnect
@@ -250,16 +261,28 @@ class MQTTRelayService:
         printer_serial: str,
         awaiting_plate_clear: bool = False,
     ):
-        """Publish printer status change (throttled to 1 update/sec per printer)."""
+        """Publish printer status change (throttled to 1 update/sec per printer).
+
+        A change of ``connected`` is never throttled: the update that says a printer
+        dropped is retained, and held back it would leave the previous status
+        standing for as long as the printer stays quiet (#3401).
+        """
         if not self.enabled or not self.connected:
             return
 
         # Throttle status updates to avoid flooding MQTT broker
         now = time.time()
         last_publish = self._last_printer_status.get(printer_id, 0)
-        if now - last_publish < self.STATUS_THROTTLE_SECONDS:
+        last_connected = self._last_printer_connected.get(printer_id)
+        connected_changed = last_connected is not None and last_connected != state.connected
+        if not connected_changed and now - last_publish < self.STATUS_THROTTLE_SECONDS:
             return  # Skip this update, too soon since last publish
         self._last_printer_status[printer_id] = now
+        self._last_printer_connected[printer_id] = state.connected
+
+        from backend.app.services.printer_manager import printer_state_to_dict
+
+        snapshot = printer_state_to_dict(state, printer_id)
 
         # Build status payload from PrinterState
         payload = {
@@ -286,6 +309,7 @@ class MQTTRelayService:
             "heatbreak_fan_speed": state.heatbreak_fan_speed,
             "left_aux_fan_speed": state.left_aux_fan_speed,
             "exhaust_fan_present": state.exhaust_fan_present,
+            **{field: snapshot[field] for field in _STATUS_FIELDS_FROM_STATE},
             # Bambuddy-side gate, not printer telemetry (#2525). Mirrors what the
             # Web UI already receives via printer_state_to_dict, so an external
             # automation can tell "finished" from "finished and still waiting for

+ 149 - 0
backend/tests/unit/test_mqtt_relay_status_3401.py

@@ -0,0 +1,149 @@
+"""The relay's printer status topic carries what the REST status does (#3401).
+
+Door, active extruder, tray, AMS, external spool and HMS errors were only
+available by polling REST. The broker also gets a Last Will, so a crash does
+not leave the retained "online" standing, and a printer dropping is published
+even straight after a regular update.
+"""
+
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from backend.app.services.bambu_mqtt import HMSError, PrinterState
+from backend.app.services.mqtt_relay import MQTTRelayService
+
+
+@pytest.fixture
+def relay():
+    service = MQTTRelayService()
+    service.enabled = True
+    service.connected = True
+    service.topic_prefix = "bambuddy"
+    service._publish = MagicMock()
+    return service
+
+
+def _state(**kwargs) -> PrinterState:
+    return PrinterState(connected=True, state="RUNNING", **kwargs)
+
+
+def _published(relay) -> dict:
+    topic, payload = relay._publish.call_args.args[:2]
+    assert topic == "bambuddy/printers/SERIAL1/status"
+    return payload
+
+
+async def _send(relay, state, printer_id=1):
+    await relay.on_printer_status(printer_id, state, "H2D", "SERIAL1")
+
+
+class TestStatusPayload:
+    async def test_door_extruder_and_tray_are_published(self, relay):
+        await _send(relay, _state(door_open=True, active_extruder=1, tray_now=5))
+
+        payload = _published(relay)
+        assert payload["door_open"] is True
+        assert payload["active_extruder"] == 1
+        assert payload["tray_now"] == 5
+
+    async def test_hms_errors_are_published_like_the_rest_status(self, relay):
+        error = HMSError(code="0x0700_8010", attr=117473280, module=7, severity=2)
+        await _send(relay, _state(hms_errors=[error]))
+
+        errors = _published(relay)["hms_errors"]
+        assert [e["code"] for e in errors] == ["0x0700_8010"]
+        assert errors[0]["severity"] == 2
+        assert "description" in errors[0]
+
+    async def test_ams_and_external_spool_are_published(self, relay):
+        raw = {
+            "ams": [
+                {
+                    "id": 0,
+                    "humidity": 4,
+                    "temp": 25.0,
+                    "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "FF0000FF", "tray_sub_brands": "PLA Basic"}],
+                }
+            ],
+            "vt_tray": [{"id": 254, "tray_type": "ABS", "tray_color": "000000FF"}],
+        }
+        await _send(relay, _state(raw_data=raw))
+
+        payload = _published(relay)
+        assert payload["ams"][0]["tray"][0]["tray_type"] == "PLA"
+        assert payload["vt_tray"][0]["tray_type"] == "ABS"
+
+    async def test_a_printer_without_an_ams_publishes_null_and_empty_lists(self, relay):
+        await _send(relay, _state())
+
+        payload = _published(relay)
+        assert payload["ams"] is None
+        assert payload["vt_tray"] == []
+        assert payload["hms_errors"] == []
+
+    async def test_the_payload_stays_json_serialisable(self, relay):
+        error = HMSError(code="0x0700_8010", attr=1, module=7, severity=2)
+        await _send(relay, _state(hms_errors=[error], door_open=False, active_extruder=0, tray_now=255))
+
+        json.dumps(_published(relay), default=str)
+
+    async def test_existing_fields_are_unchanged(self, relay):
+        await _send(relay, _state(progress=42.0))
+
+        payload = _published(relay)
+        assert payload["state"] == "RUNNING"
+        assert payload["progress"] == 42.0
+        assert payload["awaiting_plate_clear"] is False
+
+
+class TestThrottle:
+    async def test_a_second_update_within_a_second_is_dropped(self, relay):
+        await _send(relay, _state())
+        await _send(relay, _state(progress=50.0))
+
+        assert relay._publish.call_count == 1
+
+    async def test_a_printer_dropping_is_published_straight_after_an_update(self, relay):
+        await _send(relay, _state())
+        await _send(relay, PrinterState(connected=False, state="unknown"))
+
+        assert relay._publish.call_count == 2
+        assert _published(relay)["connected"] is False
+
+    async def test_a_printer_coming_back_is_published_straight_after(self, relay):
+        await _send(relay, PrinterState(connected=False))
+        await _send(relay, _state())
+
+        assert relay._publish.call_count == 2
+        assert _published(relay)["connected"] is True
+
+    async def test_each_printer_is_throttled_on_its_own(self, relay):
+        await _send(relay, _state(), printer_id=1)
+        await _send(relay, _state(), printer_id=2)
+
+        assert relay._publish.call_count == 2
+
+
+class TestLastWill:
+    async def test_connect_sets_a_retained_offline_will_before_connecting(self):
+        service = MQTTRelayService()
+        service.topic_prefix = "home/bb"
+        client = MagicMock()
+        order = []
+        client.will_set.side_effect = lambda *a, **k: order.append("will")
+        client.connect_async.side_effect = lambda *a, **k: order.append("connect")
+
+        with (
+            patch("backend.app.services.mqtt_relay.mqtt.Client", return_value=client),
+            patch("backend.app.services.mqtt_relay.asyncio.sleep", new=AsyncMock()),
+        ):
+            await service._connect("broker.local", 1883, "", "", False)
+
+        client.will_set.assert_called_once()
+        args, kwargs = client.will_set.call_args
+        assert args[0] == "home/bb/status"
+        assert json.loads(args[1]) == {"status": "offline"}
+        assert kwargs == {"qos": 1, "retain": True}
+        assert order == ["will", "connect"]

+ 3 - 2
backend/tests/unit/test_plate_clear_mqtt_notification.py

@@ -13,6 +13,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
+from backend.app.services.bambu_mqtt import PrinterState
 from backend.app.services.mqtt_relay import MQTTRelayService
 from backend.app.services.printer_manager import PrinterManager
 
@@ -25,8 +26,8 @@ def _relay() -> MQTTRelayService:
     return relay
 
 
-def _state() -> SimpleNamespace:
-    return SimpleNamespace(
+def _state() -> PrinterState:
+    return PrinterState(
         connected=True,
         state="FINISH",
         progress=100,