feat(dbus): Add dphys-swapfile configuration functionality

Implemented `configure_dphys_swapfile` to manage the dphys-swapfile
service, including automatic swapfile removal when the service is
disabled. Updated feature registry to support dphys-swapfile
configuration.

src/revpi_middleware/cli_commands/cli_base.py

@@ -5,12 +5,11 @@
 This module provides the foundation for the RevPi middleware CLI commands
 and argument parsing setup.
 """
-from argparse import ArgumentParser
 from logging import getLogger
 
-from revpi_middleware.cli_commands import cli_picontrol
-from revpi_middleware.proginit import StdLogOutput
+from . import cli_config, cli_picontrol
 from .. import proginit as pi
+from ..proginit import StdLogOutput
 
 log = getLogger(__name__)
 

src/revpi_middleware/dbus_middleware1/dbus_helper.py

@@ -41,3 +41,38 @@ def extend_interface(*args) -> str:
             the provided segments.
     """
     return ".".join([REVPI_DBUS_NAME, *args])
+
+
+def grep(pattern, filename):
+    """
+    Searches for lines in a file that contain a given pattern and returns them as a list.
+
+    The function reads lines from the specified file and checks whether each line
+    contains the provided pattern. It returns a list of lines that match the
+    pattern. If the file is not found, an empty list is returned. Any other
+    exceptions during the file reading process are caught and logged.
+
+    Args:
+        pattern (str): The substring to search for within the file's lines.
+        filename (str): The path to the file that will be searched.
+
+    Returns:
+        list[str]: A list containing lines that include the provided pattern, with
+        leading and trailing spaces removed.
+
+    Raises:
+        FileNotFoundError: This error is caught if the file specified is not
+        found.
+        Exception: Any unforeseen exception during file operations is caught and
+        logged.
+    """
+    try:
+        with open(filename, "r") as file:
+            # Gibt alle Zeilen zurück, die das Muster enthalten
+            matching_lines = [line.strip() for line in file if pattern in line]
+            return matching_lines
+    except FileNotFoundError:
+        return []
+    except Exception as e:
+        log.error(f"Error reading file: {e}")
+        return []

src/revpi_middleware/dbus_middleware1/system_config/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# SPDX-FileCopyrightText: 2025 KUNBUS GmbH
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""D-Bus interfaces for system configuration."""
+from .interface_config import InterfaceRevpiConfig

src/revpi_middleware/dbus_middleware1/system_config/interface_config.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+# SPDX-FileCopyrightText: 2025 KUNBUS GmbH
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""D-Bus interfaces for hardware configuration."""
+from collections import namedtuple
+from logging import getLogger
+
+from .revpi_config import (
+    ConfigActions,
+    configure_avahi_daemon,
+    configure_dphys_swapfile,
+    configure_gui,
+    simple_systemd,
+)
+from ..dbus_helper import DbusInterface
+
+log = getLogger(__name__)
+
+FeatureFunction = namedtuple("FeatureFunction", ["function", "args"])
+
+
+class InterfaceRevpiConfig(DbusInterface):
+    """
+    <node>
+        <interface name="com.revolutionpi.middleware1.RevpiConfig">
+            <method name="Disable">
+                <arg name="feature" type="s" direction="in"/>
+            </method>
+            <method name="Enable">
+                <arg name="feature" type="s" direction="in"/>
+            </method>
+            <method name="GetStatus">
+                <arg name="feature" type="s" direction="in"/>
+                <arg name="status" type="b" direction="out"/>
+            </method>
+            <method name="GetAvailability">
+                <arg name="feature" type="s" direction="in"/>
+                <arg name="available" type="b" direction="out"/>
+            </method>
+            <property name="available_features" type="as" access="read"/>
+        </interface>
+    </node>
+    """
+
+    def Disable(self, feature: str) -> None:
+        """Disable the feature."""
+        feature_function = get_feature(feature)
+        feature_function.function(ConfigActions.DISABLE, *feature_function.args)
+
+    def Enable(self, feature: str) -> None:
+        """Enable the feature."""
+        feature_function = get_feature(feature)
+        feature_function.function(ConfigActions.ENABLE, *feature_function.args)
+
+    def GetStatus(self, feature: str) -> bool:
+        """Get feature status."""
+        feature_function = get_feature(feature)
+        return feature_function.function(ConfigActions.STATUS, *feature_function.args)
+
+    def GetAvailability(self, feature: str) -> bool:
+        """Get feature availability on the RevPi."""
+        feature_function = get_feature(feature)
+        return feature_function.function(ConfigActions.AVAILABLE, *feature_function.args)
+
+    @property
+    def available_features(self) -> list[str]:
+        return list(AVAILABLE_FEATURES.keys())
+
+
+def get_feature(feature: str) -> FeatureFunction:
+    if feature not in AVAILABLE_FEATURES:
+        raise ValueError(f"feature {feature} does not exist")
+    feature_function = AVAILABLE_FEATURES[feature]
+    if not feature_function:
+        raise NotImplementedError(f"feature {feature} is not implemented")
+    return feature_function
+
+
+AVAILABLE_FEATURES = {
+    "gui": FeatureFunction(configure_gui, []),
+    "revpi-con-can": False,
+    "dphys-swapfile": FeatureFunction(configure_dphys_swapfile, []),
+    "pimodbus-master": FeatureFunction(simple_systemd, ["pimodbus-master.service"]),
+    "pimodbus-slave": FeatureFunction(simple_systemd, ["pimodbus-slave.service"]),
+    "systemd-timesyncd": FeatureFunction(simple_systemd, ["systemd-timesyncd.service"]),
+    "ssh": FeatureFunction(simple_systemd, ["ssh.service"]),
+    "nodered": FeatureFunction(simple_systemd, ["nodered.service"]),
+    "noderedrevpinodes-server": FeatureFunction(
+        simple_systemd, ["noderedrevpinodes-server.service"]
+    ),
+    "revpipyload": FeatureFunction(simple_systemd, ["revpipyload.service"]),
+    "bluetooth": False,
+    "ieee80211": False,
+    "avahi": FeatureFunction(configure_avahi_daemon, []),
+    "external-antenna": False,
+}

src/revpi_middleware/dbus_middleware1/system_config/revpi_config.py

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+# SPDX-FileCopyrightText: 2025 KUNBUS GmbH
+# SPDX-License-Identifier: GPL-2.0-or-later
+import subprocess
+from enum import Enum, IntEnum
+from logging import getLogger
+from os import X_OK, access
+
+from pydbus import SystemBus
+
+from ..dbus_helper import grep
+
+log = getLogger(__name__)
+
+
+class ComputeModuleTypes(IntEnum):
+    UNKNOWN = 0
+    CM1 = 6
+    CM3 = 10
+    CM4 = 20
+    CM4S = 21
+    CM5 = 24
+
+
+class ConfigActions(Enum):
+    ENABLE = "enable"
+    DISABLE = "disable"
+    STATUS = "status"
+    AVAILABLE = "available"
+
+
+class RevPiConfig:
+
+    def __init__(self):
+        self._cm_type = ComputeModuleTypes.UNKNOWN
+        self._cm_with_wifi = False
+
+        self._revpi_with_con_bridge = False
+
+        self.serial = ""
+        self.model = ""
+
+        self._init_device_info()
+
+    def _init_device_info(self):
+        dc_cpuinfo = {}
+
+        # Extract CPU information
+        with open("/proc/cpuinfo", "r") as f:
+            line = "\n"
+            while line:
+                line = f.readline()
+                if line.startswith(("Revision", "Serial", "Model")):
+                    key, value = line.split(":", 1)
+                    key = key.strip().lower()
+                    value = value.strip()
+                    dc_cpuinfo[key] = value
+
+        self.model = dc_cpuinfo.get("model", "")
+        self.serial = dc_cpuinfo.get("serial", "")
+
+        # Detect Compute Module type
+        revision = dc_cpuinfo.get("revision", "")
+        if revision:
+            revision = int(revision, 16)
+            mask = 4080  # 0xFF0 in dezimal
+            try:
+                self._cm_type = ComputeModuleTypes((revision & mask) >> 4)
+            except ValueError:
+                pass
+
+        # Detect WiFi
+        could_have_wifi = self._cm_type in (ComputeModuleTypes.CM4, ComputeModuleTypes.CM5)
+        if could_have_wifi:
+            lst_grep = grep("DRIVER=brcmfmac", "/sys/class/ieee80211/phy0/device/uevent")
+            self._cm_with_wifi = len(lst_grep) > 0 and self._cm_type in (ComputeModuleTypes)
+
+        # Detect ConBridge
+        could_have_con_bridge = self._cm_type in (ComputeModuleTypes.CM3, ComputeModuleTypes.CM4S)
+        if could_have_con_bridge:
+            lst_grep = grep("kunbus,revpi-connect", "/proc/device-tree/compatible")
+            self._revpi_with_con_bridge = len(lst_grep) > 0
+
+    @property
+    def cm_type(self) -> ComputeModuleTypes:
+        return self._cm_type
+
+    @property
+    def with_con_bridge(self) -> bool:
+        return self._revpi_with_con_bridge
+
+    @property
+    def with_wifi(self) -> bool:
+        return self._cm_with_wifi
+
+
+def configure_avahi_daemon(action: ConfigActions):
+    return_value = simple_systemd(action, "avahi-daemon.service")
+
+    # Post actions for avahi-daemon
+    if action in (ConfigActions.ENABLE, ConfigActions.DISABLE):
+        # Apply the enable/disable action to the avahi socket AFTER the service
+        # unit, because a connected socket could interrupt stop
+        simple_systemd(action, "avahi-daemon.socket")
+
+    return return_value
+
+
+def configure_dphys_swapfile(action: ConfigActions):
+    return_value = simple_systemd(action, "dphys-swapfile.service")
+
+    # Post actions for dphys-swapfile
+    if action is ConfigActions.DISABLE:
+        # Remove swapfile afer disabling the service unit
+        subprocess.call(
+            ["/sbin/dphys-swapfile", "uninstall"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    return return_value
+
+
+def configure_gui(action: ConfigActions):
+    gui_available = access("/usr/bin/startx", X_OK)
+
+    if action is ConfigActions.AVAILABLE:
+        return gui_available
+
+    bus = SystemBus()
+    systemd_manager = bus.get(".systemd1")
+
+    if action is ConfigActions.ENABLE:
+        systemd_manager.SetDefaultTarget("graphical.target", True)
+
+    elif action is ConfigActions.DISABLE:
+        systemd_manager.SetDefaultTarget("multi-user.target", True)
+
+    elif action is ConfigActions.STATUS:
+        return systemd_manager.GetDefaultTarget() == "graphical.target"
+
+    else:
+        raise ValueError(f"action {action} not supported")
+
+
+def simple_systemd(action: ConfigActions, unit: str):
+    bus = SystemBus()
+    systemd_manager = bus.get(".systemd1")
+
+    if action is ConfigActions.ENABLE:
+        systemd_manager.UnmaskUnitFiles([unit], False)
+        systemd_manager.EnableUnitFiles([unit], False, False)
+        systemd_manager.StartUnit(unit, "replace")
+
+    elif action is ConfigActions.DISABLE:
+        systemd_manager.StopUnit(unit, "replace")
+        systemd_manager.DisableUnitFiles([unit], False)
+
+    elif action is ConfigActions.STATUS:
+        try:
+            unit_path = systemd_manager.LoadUnit(unit)
+            properties = bus.get(".systemd1", unit_path)
+        except Exception:
+            log.warning(f"could not get systemd unit {unit}")
+            return False
+
+        return properties.UnitFileState == "enabled" and properties.ActiveState == "active"
+
+    elif action is ConfigActions.AVAILABLE:
+        try:
+            unit_path = systemd_manager.LoadUnit(unit)
+            properties = bus.get(".systemd1", unit_path)
+        except Exception:
+            log.warning(f"could not get systemd unit {unit}")
+            return False
+
+        return properties.LoadState != "not-found"
+
+    else:
+        raise ValueError(f"action {action} not supported")
+
+
+if __name__ == "__main__":
+    rc = RevPiConfig()
+    print("Model:", rc.model)
+    print("Serial:         ", rc.serial)
+    print("CM Type:        ", rc.cm_type.name)
+    print("With wifi:      ", rc.with_wifi)
+    print("With con-bridge:", rc.with_con_bridge)