Refactor mqtt client

frigate/app.py

@@ -20,7 +20,7 @@ from frigate.events import EventCleanup, EventProcessor
 from frigate.http import create_app
 from frigate.log import log_process, root_configurer
 from frigate.models import Event, Recordings
-from frigate.mqtt import MqttSocketRelay, create_mqtt_client
+from frigate.mqtt import FrigateMqttClient, MqttSocketRelay
 from frigate.object_processing import TrackedObjectProcessor
 from frigate.output import output_frames
 from frigate.plus import PlusApi
@@ -169,7 +169,7 @@ class FrigateApp:
         self.restream.add_cameras()
 
     def init_mqtt(self) -> None:
-        self.mqtt_client = create_mqtt_client(self.config, self.camera_metrics)
+        self.mqtt_client = FrigateMqttClient(self.config, self.camera_metrics)
 
     def start_mqtt_relay(self) -> None:
         self.mqtt_relay = MqttSocketRelay(

frigate/mqtt.py

@@ -13,21 +13,78 @@ from ws4py.server.wsgiutils import WebSocketWSGIApplication
 from ws4py.websocket import WebSocket
 
 from frigate.config import FrigateConfig
+from frigate.types import CameraMetricsTypes
 from frigate.util import restart_frigate
 
 logger = logging.getLogger(__name__)
 
 
-def create_mqtt_client(config: FrigateConfig, camera_metrics):
+class FrigateMqttClient:
-    mqtt_config = config.mqtt
+    """Frigate wrapper for mqtt client."""
 
-    def on_recordings_command(client, userdata, message):
+    def __init__(
+        self, config: FrigateConfig, camera_metrics: dict[str, CameraMetricsTypes]
+    ) -> None:
+        self.config: FrigateConfig = config
+        self.mqtt_config = config.mqtt
+        self.camera_metrics: dict[str, CameraMetricsTypes] = camera_metrics
+        self.client: mqtt.Client = None
+        self.__start()
+
+    def set_initial_topics(self) -> None:
+        """Set initial state topics."""
+        for camera_name, camera in self.config.cameras.items():
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/recordings/state",
+                "ON" if camera.record.enabled else "OFF",
+                retain=True,
+            )
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/snapshots/state",
+                "ON" if camera.snapshots.enabled else "OFF",
+                retain=True,
+            )
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/detect/state",
+                "ON" if camera.detect.enabled else "OFF",
+                retain=True,
+            )
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/motion/state",
+                "ON",
+                retain=True,
+            )
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/improve_contrast/state",
+                "ON" if camera.motion.improve_contrast else "OFF",
+                retain=True,
+            )
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/motion_threshold/state",
+                camera.motion.threshold,
+                retain=True,
+            )
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/motion_contour_area/state",
+                camera.motion.contour_area,
+                retain=True,
+            )
+            self.publish(
+                f"{self.mqtt_config.topic_prefix}/{camera_name}/motion",
+                "OFF",
+                retain=False,
+            )
+
+    def on_recordings_command(
+        self, client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback for recordings topic."""
         payload = message.payload.decode()
         logger.debug(f"on_recordings_toggle: {message.topic} {payload}")
 
         camera_name = message.topic.split("/")[-3]
 
-        record_settings = config.cameras[camera_name].record
+        record_settings = self.config.cameras[camera_name].record
 
         if payload == "ON":
             if not record_settings.enabled:
@@ -41,15 +98,18 @@ def create_mqtt_client(config: FrigateConfig, camera_metrics):
             logger.warning(f"Received unsupported value at {message.topic}: {payload}")
 
         state_topic = f"{message.topic[:-4]}/state"
-        client.publish(state_topic, payload, retain=True)
+        self.publish(state_topic, payload, retain=True)
 
-    def on_snapshots_command(client, userdata, message):
+    def on_snapshots_command(
+        self, client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback for snapshots topic."""
         payload = message.payload.decode()
         logger.debug(f"on_snapshots_toggle: {message.topic} {payload}")
 
         camera_name = message.topic.split("/")[-3]
 
-        snapshots_settings = config.cameras[camera_name].snapshots
+        snapshots_settings = self.config.cameras[camera_name].snapshots
 
         if payload == "ON":
             if not snapshots_settings.enabled:
@@ -63,91 +123,107 @@ def create_mqtt_client(config: FrigateConfig, camera_metrics):
             logger.warning(f"Received unsupported value at {message.topic}: {payload}")
 
         state_topic = f"{message.topic[:-4]}/state"
-        client.publish(state_topic, payload, retain=True)
+        self.publish(state_topic, payload, retain=True)
 
-    def on_detect_command(client, userdata, message):
+    def on_detect_command(
+        self, client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback for detect topic."""
         payload = message.payload.decode()
         logger.debug(f"on_detect_toggle: {message.topic} {payload}")
 
         camera_name = message.topic.split("/")[-3]
 
-        detect_settings = config.cameras[camera_name].detect
+        detect_settings = self.config.cameras[camera_name].detect
 
         if payload == "ON":
-            if not camera_metrics[camera_name]["detection_enabled"].value:
+            if not self.camera_metrics[camera_name]["detection_enabled"].value:
                 logger.info(f"Turning on detection for {camera_name} via mqtt")
-                camera_metrics[camera_name]["detection_enabled"].value = True
+                self.camera_metrics[camera_name]["detection_enabled"].value = True
                 detect_settings.enabled = True
 
-                if not camera_metrics[camera_name]["motion_enabled"].value:
+                if not self.camera_metrics[camera_name]["motion_enabled"].value:
                     logger.info(
                         f"Turning on motion for {camera_name} due to detection being enabled."
                     )
-                    camera_metrics[camera_name]["motion_enabled"].value = True
+                    self.camera_metrics[camera_name]["motion_enabled"].value = True
                     state_topic = f"{message.topic[:-11]}/motion/state"
-                    client.publish(state_topic, payload, retain=True)
+                    self.publish(state_topic, payload, retain=True)
         elif payload == "OFF":
-            if camera_metrics[camera_name]["detection_enabled"].value:
+            if self.camera_metrics[camera_name]["detection_enabled"].value:
                 logger.info(f"Turning off detection for {camera_name} via mqtt")
-                camera_metrics[camera_name]["detection_enabled"].value = False
+                self.camera_metrics[camera_name]["detection_enabled"].value = False
                 detect_settings.enabled = False
         else:
             logger.warning(f"Received unsupported value at {message.topic}: {payload}")
 
         state_topic = f"{message.topic[:-4]}/state"
-        client.publish(state_topic, payload, retain=True)
+        self.publish(state_topic, payload, retain=True)
 
-    def on_motion_command(client, userdata, message):
+    def on_motion_command(
+        self, client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback for motion topic."""
         payload = message.payload.decode()
         logger.debug(f"on_motion_toggle: {message.topic} {payload}")
 
         camera_name = message.topic.split("/")[-3]
 
         if payload == "ON":
-            if not camera_metrics[camera_name]["motion_enabled"].value:
+            if not self.camera_metrics[camera_name]["motion_enabled"].value:
                 logger.info(f"Turning on motion for {camera_name} via mqtt")
-                camera_metrics[camera_name]["motion_enabled"].value = True
+                self.camera_metrics[camera_name]["motion_enabled"].value = True
         elif payload == "OFF":
-            if camera_metrics[camera_name]["detection_enabled"].value:
+            if self.camera_metrics[camera_name]["detection_enabled"].value:
                 logger.error(
                     f"Turning off motion is not allowed when detection is enabled."
                 )
                 return
 
-            if camera_metrics[camera_name]["motion_enabled"].value:
+            if self.camera_metrics[camera_name]["motion_enabled"].value:
                 logger.info(f"Turning off motion for {camera_name} via mqtt")
-                camera_metrics[camera_name]["motion_enabled"].value = False
+                self.camera_metrics[camera_name]["motion_enabled"].value = False
         else:
             logger.warning(f"Received unsupported value at {message.topic}: {payload}")
 
         state_topic = f"{message.topic[:-4]}/state"
-        client.publish(state_topic, payload, retain=True)
+        self.publish(state_topic, payload, retain=True)
 
-    def on_improve_contrast_command(client, userdata, message):
+    def on_improve_contrast_command(
+        self, client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback for improve_contrast topic."""
         payload = message.payload.decode()
         logger.debug(f"on_improve_contrast_toggle: {message.topic} {payload}")
 
         camera_name = message.topic.split("/")[-3]
 
-        motion_settings = config.cameras[camera_name].motion
+        motion_settings = self.config.cameras[camera_name].motion
 
         if payload == "ON":
-            if not camera_metrics[camera_name]["improve_contrast_enabled"].value:
+            if not self.camera_metrics[camera_name]["improve_contrast_enabled"].value:
                 logger.info(f"Turning on improve contrast for {camera_name} via mqtt")
-                camera_metrics[camera_name]["improve_contrast_enabled"].value = True
+                self.camera_metrics[camera_name][
+                    "improve_contrast_enabled"
+                ].value = True
                 motion_settings.improve_contrast = True
         elif payload == "OFF":
-            if camera_metrics[camera_name]["improve_contrast_enabled"].value:
+            if self.camera_metrics[camera_name]["improve_contrast_enabled"].value:
                 logger.info(f"Turning off improve contrast for {camera_name} via mqtt")
-                camera_metrics[camera_name]["improve_contrast_enabled"].value = False
+                self.camera_metrics[camera_name][
+                    "improve_contrast_enabled"
+                ].value = False
                 motion_settings.improve_contrast = False
         else:
             logger.warning(f"Received unsupported value at {message.topic}: {payload}")
 
         state_topic = f"{message.topic[:-4]}/state"
-        client.publish(state_topic, payload, retain=True)
+        self.publish(state_topic, payload, retain=True)
 
-    def on_motion_threshold_command(client, userdata, message):
+    def on_motion_threshold_command(
+        self, client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback for motion threshold topic."""
         try:
             payload = int(message.payload.decode())
         except ValueError:
@@ -160,16 +236,19 @@ def create_mqtt_client(config: FrigateConfig, camera_metrics):
 
         camera_name = message.topic.split("/")[-3]
 
-        motion_settings = config.cameras[camera_name].motion
+        motion_settings = self.config.cameras[camera_name].motion
 
         logger.info(f"Setting motion threshold for {camera_name} via mqtt: {payload}")
-        camera_metrics[camera_name]["motion_threshold"].value = payload
+        self.camera_metrics[camera_name]["motion_threshold"].value = payload
         motion_settings.threshold = payload
 
         state_topic = f"{message.topic[:-4]}/state"
-        client.publish(state_topic, payload, retain=True)
+        self.publish(state_topic, payload, retain=True)
 
-    def on_motion_contour_area_command(client, userdata, message):
+    def on_motion_contour_area_command(
+        self, client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback for motion contour topic."""
         try:
             payload = int(message.payload.decode())
         except ValueError:
@@ -182,21 +261,25 @@ def create_mqtt_client(config: FrigateConfig, camera_metrics):
 
         camera_name = message.topic.split("/")[-3]
 
-        motion_settings = config.cameras[camera_name].motion
+        motion_settings = self.config.cameras[camera_name].motion
 
         logger.info(
             f"Setting motion contour area for {camera_name} via mqtt: {payload}"
         )
-        camera_metrics[camera_name]["motion_contour_area"].value = payload
+        self.camera_metrics[camera_name]["motion_contour_area"].value = payload
         motion_settings.contour_area = payload
 
         state_topic = f"{message.topic[:-4]}/state"
-        client.publish(state_topic, payload, retain=True)
+        self.publish(state_topic, payload, retain=True)
 
-    def on_restart_command(client, userdata, message):
+    def on_restart_command(
+        client: mqtt.Client, userdata, message: mqtt.MQTTMessage
+    ) -> None:
+        """Callback to restart frigate."""
         restart_frigate()
 
-    def on_connect(client, userdata, flags, rc):
+    def on_connect(self, client: mqtt.Client, userdata, flags, rc) -> None:
+        """Mqtt connection callback."""
         threading.current_thread().name = "mqtt"
         if rc != 0:
             if rc == 3:
@@ -216,117 +299,94 @@ def create_mqtt_client(config: FrigateConfig, camera_metrics):
                 )
 
         logger.debug("MQTT connected")
-        client.subscribe(f"{mqtt_config.topic_prefix}/#")
+        client.subscribe(f"{self.mqtt_config.topic_prefix}/#")
-        client.publish(mqtt_config.topic_prefix + "/available", "online", retain=True)
+        self.publish(
-
+            self.mqtt_config.topic_prefix + "/available", "online", retain=True
-    client = mqtt.Client(client_id=mqtt_config.client_id)
-    client.on_connect = on_connect
-    client.will_set(
-        mqtt_config.topic_prefix + "/available", payload="offline", qos=1, retain=True
-    )
-
-    # register callbacks
-    for name in config.cameras.keys():
-        client.message_callback_add(
-            f"{mqtt_config.topic_prefix}/{name}/recordings/set", on_recordings_command
-        )
-        client.message_callback_add(
-            f"{mqtt_config.topic_prefix}/{name}/snapshots/set", on_snapshots_command
-        )
-        client.message_callback_add(
-            f"{mqtt_config.topic_prefix}/{name}/detect/set", on_detect_command
-        )
-        client.message_callback_add(
-            f"{mqtt_config.topic_prefix}/{name}/motion/set", on_motion_command
-        )
-        client.message_callback_add(
-            f"{mqtt_config.topic_prefix}/{name}/improve_contrast/set",
-            on_improve_contrast_command,
-        )
-        client.message_callback_add(
-            f"{mqtt_config.topic_prefix}/{name}/motion_threshold/set",
-            on_motion_threshold_command,
-        )
-        client.message_callback_add(
-            f"{mqtt_config.topic_prefix}/{name}/motion_contour_area/set",
-            on_motion_contour_area_command,
         )
 
-    client.message_callback_add(
+    def __start(self) -> None:
-        f"{mqtt_config.topic_prefix}/restart", on_restart_command
+        """Start mqtt client."""
-    )
+        self.client = mqtt.Client(client_id=self.mqtt_config.client_id)
+        self.client.on_connect = self.on_connect
+        self.client.will_set(
+            self.mqtt_config.topic_prefix + "/available",
+            payload="offline",
+            qos=1,
+            retain=True,
+        )
 
-    if not mqtt_config.tls_ca_certs is None:
+        # register callbacks
-        if (
+        for name in self.config.cameras.keys():
-            not mqtt_config.tls_client_cert is None
+            self.client.message_callback_add(
-            and not mqtt_config.tls_client_key is None
+                f"{self.mqtt_config.topic_prefix}/{name}/recordings/set",
-        ):
+                self.on_recordings_command,
-            client.tls_set(
+            )
-                mqtt_config.tls_ca_certs,
+            self.client.message_callback_add(
-                mqtt_config.tls_client_cert,
+                f"{self.mqtt_config.topic_prefix}/{name}/snapshots/set",
-                mqtt_config.tls_client_key,
+                self.on_snapshots_command,
+            )
+            self.client.message_callback_add(
+                f"{self.mqtt_config.topic_prefix}/{name}/detect/set",
+                self.on_detect_command,
+            )
+            self.client.message_callback_add(
+                f"{self.mqtt_config.topic_prefix}/{name}/motion/set",
+                self.on_motion_command,
+            )
+            self.client.message_callback_add(
+                f"{self.mqtt_config.topic_prefix}/{name}/improve_contrast/set",
+                self.on_improve_contrast_command,
+            )
+            self.client.message_callback_add(
+                f"{self.mqtt_config.topic_prefix}/{name}/motion_threshold/set",
+                self.on_motion_threshold_command,
+            )
+            self.client.message_callback_add(
+                f"{self.mqtt_config.topic_prefix}/{name}/motion_contour_area/set",
+                self.on_motion_contour_area_command,
             )
-        else:
-            client.tls_set(mqtt_config.tls_ca_certs)
-    if not mqtt_config.tls_insecure is None:
-        client.tls_insecure_set(mqtt_config.tls_insecure)
-    if not mqtt_config.user is None:
-        client.username_pw_set(mqtt_config.user, password=mqtt_config.password)
-    try:
-        client.connect(mqtt_config.host, mqtt_config.port, 60)
-    except Exception as e:
-        logger.error(f"Unable to connect to MQTT server: {e}")
-        raise
 
-    client.loop_start()
+        self.client.message_callback_add(
-
+            f"{self.mqtt_config.topic_prefix}/restart", self.on_restart_command
-    for name in config.cameras.keys():
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/recordings/state",
-            "ON" if config.cameras[name].record.enabled else "OFF",
-            retain=True,
-        )
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/snapshots/state",
-            "ON" if config.cameras[name].snapshots.enabled else "OFF",
-            retain=True,
-        )
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/detect/state",
-            "ON" if config.cameras[name].detect.enabled else "OFF",
-            retain=True,
-        )
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/motion/state",
-            "ON",
-            retain=True,
-        )
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/improve_contrast/state",
-            "ON" if config.cameras[name].motion.improve_contrast else "OFF",
-            retain=True,
-        )
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/motion_threshold/state",
-            config.cameras[name].motion.threshold,
-            retain=True,
-        )
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/motion_contour_area/state",
-            config.cameras[name].motion.contour_area,
-            retain=True,
-        )
-        client.publish(
-            f"{mqtt_config.topic_prefix}/{name}/motion",
-            "OFF",
-            retain=False,
         )
 
-    return client
+        if not self.mqtt_config.tls_ca_certs is None:
+            if (
+                not self.mqtt_config.tls_client_cert is None
+                and not self.mqtt_config.tls_client_key is None
+            ):
+                self.client.tls_set(
+                    self.mqtt_config.tls_ca_certs,
+                    self.mqtt_config.tls_client_cert,
+                    self.mqtt_config.tls_client_key,
+                )
+            else:
+                self.client.tls_set(self.mqtt_config.tls_ca_certs)
+        if not self.mqtt_config.tls_insecure is None:
+            self.client.tls_insecure_set(self.mqtt_config.tls_insecure)
+        if not self.mqtt_config.user is None:
+            self.client.username_pw_set(
+                self.mqtt_config.user, password=self.mqtt_config.password
+            )
+        try:
+            self.client.connect(self.mqtt_config.host, self.mqtt_config.port, 60)
+        except Exception as e:
+            logger.error(f"Unable to connect to MQTT server: {e}")
+            raise
+
+        self.client.loop_start()
+        self.set_initial_topics()
+
+    def publish(self, topic: str, payload, retain: bool = False) -> None:
+        if not self.client:
+            logger.error(f"Unable to publish to {topic}: client is not connected")
+            return
+
+        self.client.publish(topic, payload, retain=retain)
 
 
 class MqttSocketRelay:
-    def __init__(self, mqtt_client, topic_prefix):
+    def __init__(self, mqtt_client: FrigateMqttClient, topic_prefix: str):
         self.mqtt_client = mqtt_client
         self.topic_prefix = topic_prefix
 
@@ -389,7 +449,7 @@ class MqttSocketRelay:
 
             self.websocket_server.manager.broadcast(ws_message)
 
-        self.mqtt_client.message_callback_add(f"{self.topic_prefix}/#", send)
+        self.mqtt_client.client.message_callback_add(f"{self.topic_prefix}/#", send)
 
         self.websocket_thread.start()