feat: Introduce configurable bus_provider for MiddlewareDaemon

Added support for a configurable `bus_provider` via command-line
arguments, enabling either "middleware" or "ios" as valid options.
Refactored `MiddlewareDaemon` to dynamically handle the selected bus
provider and streamline D-Bus management.

Signed-off-by: Sven Sager <s.sager@kunbus.com>

src/revpi_middleware/daemon.py

@@ -3,11 +3,11 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 """Main daemon of revpi-middleware."""
 
+from enum import Enum
 from logging import getLogger
-from os import getuid, environ
+from os import environ
 from threading import Event
 from time import perf_counter
-from typing import List
 
 from gi.repository import Gio
 
@@ -18,10 +18,15 @@ from .dbus_middleware1 import BusProviderMiddleware1
 log = getLogger(__name__)
 
 
+class BusProvider(Enum):
+    middleware = "middleware"
+    ios = "ios"
+
+
 class MiddlewareDaemon:
     """Main program of MiddlewareDaemon class."""
 
-    def __init__(self):
+    def __init__(self, bus_provider: BusProvider):
         """Init MiddlewareDaemon class."""
         log.debug("enter MiddlewareDaemon.__init__")
 
@@ -30,8 +35,8 @@ class MiddlewareDaemon:
         self._reconfigure = False
         self._running = True
 
-        self.bp_middleware1 = None
+        self.bus_provider = None
-        self.bp_ios1 = None
+        self.bus_provider_selected = bus_provider
 
         self._configure()
         log.debug("leave MiddlewareDaemon.__init__")
@@ -57,41 +62,26 @@ class MiddlewareDaemon:
     def dbus_start(self):
         log.debug("enter MiddlewareDaemon.dbus_start")
 
-        dbus_middleware1_running = self.bp_middleware1 and self.bp_middleware1.is_alive()
+        dbus_running = self.bus_provider and self.bus_provider.is_alive()
-        if not dbus_middleware1_running:
+        if not dbus_running:
-            self.bp_middleware1 = BusProviderMiddleware1(self._get_bus_address())
+            if self.bus_provider_selected is BusProvider.middleware:
-            self.bp_middleware1.start()
+                self.bus_provider = BusProviderMiddleware1(self._get_bus_address())
-
+            elif self.bus_provider_selected is BusProvider.ios:
-        dbus_ios1_running = self.bp_ios1 and self.bp_ios1.is_alive()
+                self.bus_provider = BusProviderIos1(self._get_bus_address())
-        if not dbus_ios1_running:
-            if self.bp_middleware1.published.wait(timeout=10.0):
-                self.bp_ios1 = BusProviderIos1(self._get_bus_address())
-                self.bp_ios1.start()
             else:
-                log.error("dbus middleware1 provider thread is not alive - can not start ios1 bus")
+                raise ValueError("Unknown bus provider")
+            self.bus_provider.start()
 
         log.debug("leave MiddlewareDaemon.dbus_start")
 
-    def dbus_stop(self, bus_filter: List[object] = None):
+    def dbus_stop(self):
         log.debug("enter MiddlewareDaemon.dbus_stop")
 
-        if bus_filter is None:
+        if self.bus_provider:
-            bus_filter = [
+            self.bus_provider.stop()
-                self.bp_middleware1,
+            self.bus_provider.join(timeout=10.0)
-                self.bp_ios1,
+            if self.bus_provider.is_alive():
-            ]
+                log.warning(f"dbus {self.bus_provider.name} thread is still alive")
-
-        if self.bp_middleware1 and self.bp_middleware1 in bus_filter:
-            self.bp_middleware1.stop()
-            self.bp_middleware1.join(timeout=10.0)
-            if self.bp_middleware1.is_alive():
-                log.warning("dbus middleware1 provider thread is still alive")
-
-        if self.bp_ios1 and self.bp_ios1 in bus_filter:
-            self.bp_ios1.stop()
-            self.bp_ios1.join(timeout=10.0)
-            if self.bp_ios1.is_alive():
-                log.warning("dbus ios1 provider thread is still alive")
 
         log.debug("leave MiddlewareDaemon.dbus_stop")
 
@@ -122,7 +112,6 @@ class MiddlewareDaemon:
         # Startup tasks
         self.dbus_start()
 
-        pi.startup_complete()
         # Go into mainloop of daemon
         while self._running:
             ot = perf_counter()
@@ -132,19 +121,15 @@ class MiddlewareDaemon:
             if self._reconfigure:
                 self._configure()
                 self._reconfigure = False
-                pi.startup_complete()
 
             # Monitor bus providers for errors and restart them
-            restart = False
+            if not (self.bus_provider and self.bus_provider.is_alive()):
-            if not (self.bp_middleware1 and self.bp_middleware1.is_alive()):
+                log.warning(f"dbus {self.bus_provider.name} thread is not alive - restarting")
-                log.warning("dbus middleware1 provider thread is not alive - restarting")
-                restart = True
-            if not (self.bp_ios1 and self.bp_ios1.is_alive()):
-                log.warning("dbus ios1 provider thread is not alive - restarting")
-                restart = True
-            if restart:
                 self.dbus_start()
 
+            if self.bus_provider and self.bus_provider.published.is_set():
+                pi.startup_complete()
+
             # Cycle time calculation
             dm = divmod(ot - perf_counter(), self._cycle_time)
             # For float the result is (q, a % b), where q is usually math.floor(a / b) but may be 1 less than that.

src/revpi_middleware/main_application.py

@@ -5,7 +5,7 @@
 
 from logging import getLogger
 
-from .daemon import MiddlewareDaemon
+from .daemon import MiddlewareDaemon, BusProvider
 from . import proginit as pi
 
 log = getLogger(__name__)
@@ -27,6 +27,13 @@ pi.parser.add_argument(
     default="/etc/{0}/{0}.conf".format(pi.programname),
     help="application configuration file",
 )
+pi.parser.add_argument(
+    "bus_provider",
+    default="middleware",
+    nargs="?",
+    choices=["middleware", "ios"],
+    help="bus provider to use",
+)
 
 
 def main() -> int:
@@ -35,7 +42,7 @@ def main() -> int:
     # Parse command line arguments
     pi.init_app()
 
-    root = MiddlewareDaemon()
+    root = MiddlewareDaemon(BusProvider(pi.pargs.bus_provider))
 
     # Set signals
     signal.signal(signal.SIGHUP, lambda n, f: root.reload_config())