Merge e421a12daf into a374ac8fac

Signed-off-by: Dominik Willner <th33xitus@gmail.com>

kiauh/components/klipper/klipper_utils.py

@@ -201,7 +201,7 @@ def klipper_to_multi_conversion(new_name: str) -> None:
 
 def check_user_groups():
     user_groups = [grp.getgrgid(gid).gr_name for gid in os.getgroups()]
-    missing_groups = [g for g in user_groups if g == "tty" or g == "dialout"]
+    missing_groups = [g for g in ["tty", "dialout"] if g not in user_groups]
 
     if not missing_groups:
         return

kiauh/components/moonraker/moonraker.py

@@ -25,7 +25,7 @@ from utils.logger import Logger
 class Moonraker(BaseInstance):
     @classmethod
     def blacklist(cls) -> List[str]:
-        return ["None", "mcu"]
+        return ["None", "mcu", "obico"]
 
     def __init__(self, suffix: str = ""):
         super().__init__(instance_type=self, suffix=suffix)

kiauh/core/instance_manager/instance_manager.py

@@ -172,14 +172,18 @@ class InstanceManager:
         ]
 
         instance_list = [
-            self.instance_type(suffix=self._get_instance_suffix(service))
+            self.instance_type(suffix=self._get_instance_suffix(name, service))
             for service in service_list
         ]
 
         return sorted(instance_list, key=lambda x: self._sort_instance_list(x.suffix))
 
-    def _get_instance_suffix(self, file_path: Path) -> str:
-        return file_path.stem.split("-")[-1] if "-" in file_path.stem else ""
+    def _get_instance_suffix(self, name: str, file_path: Path) -> str:
+        # to get the suffix of the instance, we remove the name of the instance from
+        # the file name, if the remaining part an empty string we return it
+        # otherwise there is and hyphen left, and we return the part after the hyphen
+        suffix = file_path.stem[len(name) :]
+        return suffix[1:] if suffix else ""
 
     def _sort_instance_list(self, s: Union[int, str, None]):
         if s is None:

kiauh/core/settings/kiauh_settings.py

@@ -123,7 +123,7 @@ class KiauhSettings:
         self._load_config()
 
     def _load_config(self) -> None:
-        if not CUSTOM_CFG.exists() or not DEFAULT_CFG.exists():
+        if not CUSTOM_CFG.exists() and not DEFAULT_CFG.exists():
             self._kill()
 
         cfg = CUSTOM_CFG if CUSTOM_CFG.exists() else DEFAULT_CFG

kiauh/core/submodules/simple_config_parser/src/simple_config_parser/simple_config_parser.py

@@ -85,7 +85,7 @@ class DuplicateOptionError(Exception):
 class SimpleConfigParser:
     """A customized config parser targeted at handling Klipper style config files"""
 
-    _SECTION_RE = re.compile(r"\s*\[(\w+ ?\w+)]\s*([#;].*)?$")
+    _SECTION_RE = re.compile(r"\s*\[(\w+\s?.+)]\s*([#;].*)?$")
     _OPTION_RE = re.compile(r"^\s*(\w+)\s*[:=]\s*([^=:].*)\s*([#;].*)?$")
     _MLOPTION_RE = re.compile(r"^\s*(\w+)\s*[:=]\s*([#;].*)?$")
     _COMMENT_RE = re.compile(r"^\s*([#;].*)?$")
@@ -192,9 +192,9 @@ class SimpleConfigParser:
         if section not in self._all_sections:
             raise NoSectionError(section)
 
-        del self._all_sections[self._all_sections.index(section)]
-        del self._all_options[section]
-        del self._config[section]
+        self._all_sections.pop(self._all_sections.index(section))
+        self._all_options.pop(section)
+        self._config.pop(section)
 
     def options(self, section) -> List[str]:
         """Return a list of option names for the given section name"""
@@ -453,6 +453,7 @@ class SimpleConfigParser:
 
         self.section_name = section
         self._all_sections.append(section)
+        self._all_options[section] = {}
         self._config[section]: Section = {"_raw": raw_value, "body": []}
 
     def _parse_option(self, line: str) -> None:

kiauh/core/submodules/simple_config_parser/tests/features/internal_state/test_internal_state_changes.py

@@ -34,6 +34,7 @@ class TestInternalStateChanges:
         parser._store_internal_state_section(given, given)
 
         assert parser._all_sections == [given]
+        assert parser._all_options[given] == {}
         assert parser._config[given]["body"] == []
         assert parser._config[given]["_raw"] == given
 

kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_option.py

@@ -8,6 +8,11 @@ testcases = [
     ("option: value\n", "option", "value"),
     ("option: value # inline comment", "option", "value"),
     ("option: value # inline comment\n", "option", "value"),
+    (
+        "description: Helper: park toolhead used in PAUSE and CANCEL_PRINT",
+        "description",
+        "Helper: park toolhead used in PAUSE and CANCEL_PRINT",
+    ),
     ("description: homing!", "description", "homing!"),
     ("description: inline macro :-)", "description", "inline macro :-)"),
     ("path: %GCODES_DIR%", "path", "%GCODES_DIR%"),

kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_section.py

@@ -3,4 +3,6 @@ testcases = [
     ("[test_section two]", "test_section two"),
     ("[section1] # inline comment", "section1"),
     ("[section2] ; second comment", "section2"),
+    ("[include moonraker-obico-update.cfg]", "include moonraker-obico-update.cfg"),
+    ("[include moonraker_obico_macros.cfg]", "include moonraker_obico_macros.cfg"),
 ]

kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_section.py

@@ -1,5 +1,11 @@
 testcases = [
     ("[example_section]", True),
+    ("[gcode_macro CANCEL_PRINT]", True),
+    ("[gcode_macro SET_PAUSE_NEXT_LAYER]", True),
+    ("[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL]", True),
+    ("[update_manager moonraker-obico]", True),
+    ("[include moonraker_obico_macros.cfg]", True),
+    ("[include moonraker-obico-update.cfg]", True),
     ("[example_section two]", True),
     ("not_a_valid_section", False),
     ("section: invalid", False),

kiauh/core/submodules/simple_config_parser/tests/features/public_api/test_public_api.py

@@ -108,7 +108,7 @@ class TestPublicAPI:
         assert parser._config[section]["body"][0]["option"] == option
 
         values = ["value1", "value2", "value3"]
-        raw_values = ["  value1\n", "  value2\n", "  value3\n"]
+        raw_values = ["    value1\n", "    value2\n", "    value3\n"]
         assert parser._config[section]["body"][0]["value"] == values
         assert parser._config[section]["body"][0]["_raw"] == f"{option}:\n"
         assert parser._config[section]["body"][0]["_raw_value"] == raw_values

kiauh/extensions/obico/assets/moonraker-obico.env

@@ -0,0 +1 @@
+OBICO_ARGS="-m moonraker_obico.app -c %CFG%"

kiauh/extensions/obico/assets/moonraker-obico.service

@@ -0,0 +1,16 @@
+#Systemd service file for moonraker-obico
+[Unit]
+Description=Moonraker-Obico
+After=network-online.target moonraker.service
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+Type=simple
+User=%USER%
+WorkingDirectory=%OBICO_DIR%
+EnvironmentFile=%ENV_FILE%
+ExecStart=%ENV%/bin/python3 $OBICO_ARGS
+Restart=always
+RestartSec=5

kiauh/extensions/obico/metadata.json

@@ -0,0 +1,16 @@
+{
+  "metadata": {
+    "index": 6,
+    "module": "moonraker_obico_extension",
+    "maintained_by": "Obico",
+    "display_name": "Obico for Klipper",
+    "description": [
+        "Open source 3D Printing cloud and AI",
+        "- AI-Powered Failure Detection",
+        "- Free Remote Monitoring and Access",
+        "- 25FPS High-Def Webcam Streaming",
+        "- Free 4.9-Star Mobile App"
+    ],
+    "updates": true
+  }
+}

kiauh/extensions/obico/moonraker_obico.py

@@ -0,0 +1,178 @@
+# ======================================================================= #
+#  Copyright (C) 2020 - 2024 Dominik Willner <th33xitus@gmail.com>        #
+#                                                                         #
+#  This file is part of KIAUH - Klipper Installation And Update Helper    #
+#  https://github.com/dw-0/kiauh                                          #
+#                                                                         #
+#  This file may be distributed under the terms of the GNU GPLv3 license  #
+# ======================================================================= #
+
+from pathlib import Path
+from subprocess import DEVNULL, CalledProcessError, run
+from typing import List
+
+from core.instance_manager.base_instance import BaseInstance
+from core.submodules.simple_config_parser.src.simple_config_parser.simple_config_parser import (
+    SimpleConfigParser,
+)
+from utils.constants import SYSTEMD
+from utils.logger import Logger
+
+MODULE_PATH = Path(__file__).resolve().parent
+
+OBICO_DIR = Path.home().joinpath("moonraker-obico")
+OBICO_ENV = Path.home().joinpath("moonraker-obico-env")
+OBICO_REPO = "https://github.com/TheSpaghettiDetective/moonraker-obico.git"
+
+OBICO_CFG = "moonraker-obico.cfg"
+OBICO_CFG_SAMPLE = "moonraker-obico.cfg.sample"
+OBICO_LOG = "moonraker-obico.log"
+OBICO_UPDATE_CFG = "moonraker-obico-update.cfg"
+OBICO_UPDATE_CFG_SAMPLE = "moonraker-obico-update.cfg.sample"
+OBICO_MACROS_CFG = "moonraker_obico_macros.cfg"
+
+
+# noinspection PyMethodMayBeStatic
+class MoonrakerObico(BaseInstance):
+    @classmethod
+    def blacklist(cls) -> List[str]:
+        return ["None", "mcu"]
+
+    def __init__(self, suffix: str = ""):
+        super().__init__(instance_type=self, suffix=suffix)
+        self.dir: Path = OBICO_DIR
+        self.env_dir: Path = OBICO_ENV
+        self._cfg_file = self.cfg_dir.joinpath("moonraker-obico.cfg")
+        self._log = self.log_dir.joinpath("moonraker-obico.log")
+        self._is_linked: bool = self._check_link_status()
+        self._assets_dir = MODULE_PATH.joinpath("assets")
+
+    @property
+    def cfg_file(self) -> Path:
+        return self._cfg_file
+
+    @property
+    def log(self) -> Path:
+        return self._log
+
+    @property
+    def is_linked(self) -> bool:
+        return self._is_linked
+
+    def create(self) -> None:
+        Logger.print_status("Creating new Obico for Klipper Instance ...")
+        service_template_path = MODULE_PATH.joinpath("assets/moonraker-obico.service")
+        service_file_name = self.get_service_file_name(extension=True)
+        service_file_target = SYSTEMD.joinpath(service_file_name)
+        env_template_file_path = MODULE_PATH.joinpath("assets/moonraker-obico.env")
+        env_file_target = self.sysd_dir.joinpath("moonraker-obico.env")
+
+        try:
+            self.create_folders()
+            self.write_service_file(
+                service_template_path, service_file_target, env_file_target
+            )
+            self.write_env_file(env_template_file_path, env_file_target)
+
+        except CalledProcessError as e:
+            Logger.print_error(
+                f"Error creating service file {service_file_target}: {e}"
+            )
+            raise
+        except OSError as e:
+            Logger.print_error(f"Error creating env file {env_file_target}: {e}")
+            raise
+
+    def delete(self) -> None:
+        service_file = self.get_service_file_name(extension=True)
+        service_file_path = self.get_service_file_path()
+
+        Logger.print_status(f"Deleting Obico for Klipper Instance: {service_file}")
+
+        try:
+            command = ["sudo", "rm", "-f", service_file_path]
+            run(command, check=True)
+            Logger.print_ok(f"Service file deleted: {service_file_path}")
+        except CalledProcessError as e:
+            Logger.print_error(f"Error deleting service file: {e}")
+            raise
+
+    def write_service_file(
+        self,
+        service_template_path: Path,
+        service_file_target: Path,
+        env_file_target: Path,
+    ) -> None:
+        service_content = self._prep_service_file(
+            service_template_path, env_file_target
+        )
+        command = ["sudo", "tee", service_file_target]
+        run(
+            command,
+            input=service_content.encode(),
+            stdout=DEVNULL,
+            check=True,
+        )
+        Logger.print_ok(f"Service file created: {service_file_target}")
+
+    def write_env_file(
+        self, env_template_file_path: Path, env_file_target: Path
+    ) -> None:
+        env_file_content = self._prep_env_file(env_template_file_path)
+        with open(env_file_target, "w") as env_file:
+            env_file.write(env_file_content)
+        Logger.print_ok(f"Env file created: {env_file_target}")
+
+    def link(self) -> None:
+        Logger.print_status(
+            f"Linking instance for printer {self.data_dir_name} to the Obico server ..."
+        )
+        try:
+            script = OBICO_DIR.joinpath("scripts/link.sh")
+            cmd = [f"{script} -q -c {self.cfg_file}"]
+            if self.suffix:
+                cmd.append(f"-n {self.suffix}")
+            run(cmd, check=True, shell=True)
+        except CalledProcessError as e:
+            Logger.print_error(f"Error during Obico linking: {e}")
+            raise
+
+    def _prep_service_file(
+        self, service_template_path: Path, env_file_path: Path
+    ) -> str:
+        try:
+            with open(service_template_path, "r") as template_file:
+                template_content = template_file.read()
+        except FileNotFoundError:
+            Logger.print_error(
+                f"Unable to open {service_template_path} - File not found"
+            )
+            raise
+        service_content = template_content.replace("%USER%", self.user)
+        service_content = service_content.replace("%OBICO_DIR%", str(self.dir))
+        service_content = service_content.replace("%ENV%", str(self.env_dir))
+        service_content = service_content.replace("%ENV_FILE%", str(env_file_path))
+        return service_content
+
+    def _prep_env_file(self, env_template_file_path: Path) -> str:
+        try:
+            with open(env_template_file_path, "r") as env_file:
+                env_template_file_content = env_file.read()
+        except FileNotFoundError:
+            Logger.print_error(
+                f"Unable to open {env_template_file_path} - File not found"
+            )
+            raise
+        env_file_content = env_template_file_content.replace(
+            "%CFG%",
+            f"{self.cfg_dir}/{self.cfg_file}",
+        )
+        return env_file_content
+
+    def _check_link_status(self) -> bool:
+        if not self.cfg_file.exists():
+            return False
+
+        scp = SimpleConfigParser()
+        scp.read(self.cfg_file)
+        return scp.get("server", "auth_token", None) is not None

kiauh/extensions/obico/moonraker_obico_extension.py

@@ -0,0 +1,386 @@
+# ======================================================================= #
+#  Copyright (C) 2020 - 2024 Dominik Willner <th33xitus@gmail.com>        #
+#                                                                         #
+#  This file is part of KIAUH - Klipper Installation And Update Helper    #
+#  https://github.com/dw-0/kiauh                                          #
+#                                                                         #
+#  This file may be distributed under the terms of the GNU GPLv3 license  #
+# ======================================================================= #
+import shutil
+from typing import List
+
+from components.klipper.klipper import Klipper
+from components.moonraker.moonraker import Moonraker
+from core.instance_manager.instance_manager import InstanceManager
+from core.submodules.simple_config_parser.src.simple_config_parser.simple_config_parser import (
+    SimpleConfigParser,
+)
+from extensions.base_extension import BaseExtension
+from extensions.obico.moonraker_obico import (
+    OBICO_CFG_SAMPLE,
+    OBICO_DIR,
+    OBICO_ENV,
+    OBICO_LOG,
+    OBICO_MACROS_CFG,
+    OBICO_REPO,
+    OBICO_UPDATE_CFG,
+    OBICO_UPDATE_CFG_SAMPLE,
+    MoonrakerObico,
+)
+from utils.common import check_install_dependencies, moonraker_exists
+from utils.config_utils import (
+    add_config_section,
+    remove_config_section,
+)
+from utils.fs_utils import remove_file
+from utils.git_utils import git_clone_wrapper, git_pull_wrapper
+from utils.input_utils import get_confirm, get_selection_input, get_string_input
+from utils.logger import DialogType, Logger
+from utils.sys_utils import (
+    cmd_sysctl_manage,
+    create_python_venv,
+    install_python_requirements,
+    parse_packages_from_file,
+)
+
+
+# noinspection PyMethodMayBeStatic
+class ObicoExtension(BaseExtension):
+    server_url: str
+
+    def install_extension(self, **kwargs) -> None:
+        Logger.print_status("Installing Obico for Klipper ...")
+
+        # check if moonraker is installed. if not, notify the user and exit
+        if not moonraker_exists():
+            return
+
+        # if obico is already installed, ask if the user wants to repair an
+        # incomplete installation or link to the obico server
+        obico_im = InstanceManager(MoonrakerObico)
+        obico_instances: List[MoonrakerObico] = obico_im.instances
+        if obico_instances:
+            self._print_is_already_installed()
+            options = ["l", "L", "r", "R", "b", "B"]
+            action = get_selection_input("Perform action", option_list=options)
+            if action.lower() == "b":
+                Logger.print_info("Exiting Obico for Klipper installation ...")
+                return
+            elif action.lower() == "l":
+                unlinked_instances: List[MoonrakerObico] = [
+                    obico for obico in obico_instances if not obico.is_linked
+                ]
+                self._link_obico_instances(unlinked_instances)
+                return
+            else:
+                Logger.print_status("Re-Installing Obico for Klipper ...")
+
+        # let the user confirm installation
+        kl_im = InstanceManager(Klipper)
+        kl_instances: List[Klipper] = kl_im.instances
+        mr_im = InstanceManager(Moonraker)
+        mr_instances: List[Moonraker] = mr_im.instances
+        self._print_moonraker_instances(mr_instances)
+        if not get_confirm(
+            "Continue Obico for Klipper installation?",
+            default_choice=True,
+            allow_go_back=True,
+        ):
+            return
+
+        try:
+            git_clone_wrapper(OBICO_REPO, OBICO_DIR)
+            self._install_dependencies()
+
+            # ask the user for the obico server url
+            self._get_server_url()
+
+            # create obico instances
+            for moonraker in mr_instances:
+                current_instance = MoonrakerObico(suffix=moonraker.suffix)
+
+                obico_im.current_instance = current_instance
+                obico_im.create_instance()
+                obico_im.enable_instance()
+
+                # create obico config
+                self._create_obico_cfg(current_instance, moonraker)
+
+                # create obico macros
+                self._create_obico_macros_cfg(moonraker)
+
+                # create obico update manager
+                self._create_obico_update_manager_cfg(moonraker)
+
+                obico_im.start_instance()
+
+            cmd_sysctl_manage("daemon-reload")
+
+            # add to klippers config
+            self._patch_printer_cfg(kl_instances)
+            kl_im.restart_all_instance()
+
+            # add to moonraker update manager
+            self._patch_moonraker_conf(mr_instances)
+            mr_im.restart_all_instance()
+
+            # check linking of / ask for linking instances
+            self._check_and_opt_link_instances()
+
+            Logger.print_dialog(
+                DialogType.SUCCESS,
+                ["Obico for Klipper successfully installed!"],
+                center_content=True,
+            )
+
+        except Exception as e:
+            Logger.print_error(f"Error during Obico for Klipper installation:\n{e}")
+
+    def update_extension(self, **kwargs) -> None:
+        Logger.print_status("Updating Obico for Klipper ...")
+        try:
+            tb_im = InstanceManager(MoonrakerObico)
+            tb_im.stop_all_instance()
+
+            git_pull_wrapper(OBICO_REPO, OBICO_DIR)
+            self._install_dependencies()
+
+            tb_im.start_all_instance()
+            Logger.print_ok("Obico for Klipper successfully updated!")
+
+        except Exception as e:
+            Logger.print_error(f"Error during Obico for Klipper update:\n{e}")
+
+    def remove_extension(self, **kwargs) -> None:
+        Logger.print_status("Removing Obico for Klipper ...")
+        kl_im = InstanceManager(Klipper)
+        kl_instances: List[Klipper] = kl_im.instances
+        mr_im = InstanceManager(Moonraker)
+        mr_instances: List[Moonraker] = mr_im.instances
+        ob_im = InstanceManager(MoonrakerObico)
+        ob_instances: List[MoonrakerObico] = ob_im.instances
+
+        try:
+            self._remove_obico_instances(ob_im, ob_instances)
+            self._remove_obico_dir()
+            self._remove_obico_env()
+            remove_config_section(f"include {OBICO_MACROS_CFG}", kl_instances)
+            remove_config_section(f"include {OBICO_UPDATE_CFG}", mr_instances)
+            self._delete_obico_logs(ob_instances)
+            Logger.print_dialog(
+                DialogType.SUCCESS,
+                ["Obico for Klipper successfully removed!"],
+                center_content=True,
+            )
+
+        except Exception as e:
+            Logger.print_error(f"Error during Obico for Klipper removal:\n{e}")
+
+    def _obico_server_url_prompt(self) -> None:
+        Logger.print_dialog(
+            DialogType.CUSTOM,
+            custom_title="Obico Server URL",
+            content=[
+                "You can use a self-hosted Obico Server or the Obico Cloud. "
+                "For more information, please visit:",
+                "https://obico.io.",
+                "\n\n",
+                "For the Obico Cloud, leave it as the default:",
+                "https://app.obico.io.",
+                "\n\n",
+                "For self-hosted server, specify:",
+                "http://server_ip:port",
+                "For instance, 'http://192.168.0.5:3334'.",
+            ],
+            end="",
+        )
+
+    def _print_moonraker_instances(self, mr_instances) -> None:
+        mr_names = [f"● {moonraker.data_dir_name}" for moonraker in mr_instances]
+        if len(mr_names) > 1:
+            Logger.print_dialog(
+                DialogType.INFO,
+                [
+                    "The following Moonraker instances were found:",
+                    *mr_names,
+                    "\n\n",
+                    "The setup will apply the same names to Obico!",
+                ],
+                end="",
+            )
+
+    def _print_is_already_installed(self) -> None:
+        Logger.print_dialog(
+            DialogType.INFO,
+            [
+                "Obico is already installed!",
+                "It is save to run the installer again to link your "
+                "printer or repair any issues.",
+                "\n\n",
+                "You can perform the following actions:",
+                "L) Link printer to the Obico server",
+                "R) Repair installation",
+            ],
+            end="",
+        )
+
+    def _get_server_url(self) -> None:
+        self._obico_server_url_prompt()
+        pattern = r"^(http|https)://[a-zA-Z0-9./?=_%:-]*$"
+        self.server_url = get_string_input(
+            "Obico Server URL",
+            regex=pattern,
+            default="https://app.obico.io",
+        )
+
+    def _install_dependencies(self) -> None:
+        # install dependencies
+        script = OBICO_DIR.joinpath("install.sh")
+        package_list = parse_packages_from_file(script)
+        check_install_dependencies(package_list)
+
+        # create virtualenv
+        create_python_venv(OBICO_ENV)
+        requirements = OBICO_DIR.joinpath("requirements.txt")
+        install_python_requirements(OBICO_ENV, requirements)
+
+    def _create_obico_macros_cfg(self, moonraker) -> None:
+        macros_cfg = OBICO_DIR.joinpath(f"include_cfgs/{OBICO_MACROS_CFG}")
+        macros_target = moonraker.cfg_dir.joinpath(OBICO_MACROS_CFG)
+        if not macros_target.exists():
+            shutil.copy(macros_cfg, macros_target)
+        else:
+            Logger.print_info(
+                f"Obico's '{OBICO_MACROS_CFG}' in {moonraker.cfg_dir} already exists! Skipped ..."
+            )
+
+    def _create_obico_update_manager_cfg(self, moonraker) -> None:
+        update_cfg = OBICO_DIR.joinpath(OBICO_UPDATE_CFG_SAMPLE)
+        update_cfg_target = moonraker.cfg_dir.joinpath(OBICO_UPDATE_CFG)
+        if not update_cfg_target.exists():
+            shutil.copy(update_cfg, update_cfg_target)
+        else:
+            Logger.print_info(
+                f"Obico's '{OBICO_UPDATE_CFG}' in {moonraker.cfg_dir} already exists! Skipped ..."
+            )
+
+    def _create_obico_cfg(
+        self, current_instance: MoonrakerObico, moonraker: Moonraker
+    ) -> None:
+        cfg_template = OBICO_DIR.joinpath(OBICO_CFG_SAMPLE)
+        cfg_target_file = current_instance.cfg_file
+
+        if not cfg_template.exists():
+            Logger.print_error(
+                f"Obico config template file {cfg_target_file} does not exist!"
+            )
+            return
+
+        if not cfg_target_file.exists():
+            shutil.copy(cfg_template, cfg_target_file)
+            self._patch_obico_cfg(moonraker, current_instance)
+        else:
+            Logger.print_info(
+                f"Obico config in {current_instance.cfg_dir} already exists! Skipped ..."
+            )
+
+    def _patch_obico_cfg(self, moonraker: Moonraker, obico: MoonrakerObico) -> None:
+        scp = SimpleConfigParser()
+        scp.read(obico.cfg_file)
+        scp.set("server", "url", self.server_url)
+        scp.set("moonraker", "port", str(moonraker.port))
+        scp.set("logging", "path", str(obico.log))
+        scp.write(obico.cfg_file)
+
+    def _patch_printer_cfg(self, klipper: List[Klipper]) -> None:
+        add_config_section(section=f"include {OBICO_MACROS_CFG}", instances=klipper)
+
+    def _patch_moonraker_conf(self, instances: List[Moonraker]) -> None:
+        add_config_section(section=f"include {OBICO_UPDATE_CFG}", instances=instances)
+
+    def _link_obico_instances(self, unlinked_instances):
+        for obico in unlinked_instances:
+            obico.link()
+
+    def _check_and_opt_link_instances(self):
+        Logger.print_status("Checking link status of Obico instances ...")
+        ob_im = InstanceManager(MoonrakerObico)
+        ob_instances: List[MoonrakerObico] = ob_im.instances
+        unlinked_instances: List[MoonrakerObico] = [
+            obico for obico in ob_instances if not obico.is_linked
+        ]
+        if unlinked_instances:
+            Logger.print_dialog(
+                DialogType.INFO,
+                [
+                    "The Obico instances for the following printers are not "
+                    "linked to the server:",
+                    *[f"● {obico.data_dir_name}" for obico in unlinked_instances],
+                    "\n\n",
+                    "It will take only 10 seconds to link the printer to the Obico server.",
+                    "For more information visit:",
+                    "https://www.obico.io/docs/user-guides/klipper-setup/",
+                    "\n\n",
+                    "If you don't want to link the printer now, you can restart the "
+                    "linking process later by running this installer again.",
+                ],
+                end="",
+            )
+            if not get_confirm("Do you want to link the printers now?"):
+                Logger.print_info("Linking to Obico server skipped ...")
+                return
+
+            self._link_obico_instances(unlinked_instances)
+
+    def _remove_obico_instances(
+        self,
+        instance_manager: InstanceManager,
+        instance_list: List[MoonrakerObico],
+    ) -> None:
+        if not instance_list:
+            Logger.print_info("No Obico instances found. Skipped ...")
+            return
+
+        for instance in instance_list:
+            Logger.print_status(
+                f"Removing instance {instance.get_service_file_name()} ..."
+            )
+            instance_manager.current_instance = instance
+            instance_manager.stop_instance()
+            instance_manager.disable_instance()
+            instance_manager.delete_instance()
+
+        cmd_sysctl_manage("daemon-reload")
+
+    def _remove_obico_dir(self) -> None:
+        if not OBICO_DIR.exists():
+            Logger.print_info(f"'{OBICO_DIR}' does not exist. Skipped ...")
+            return
+
+        try:
+            shutil.rmtree(OBICO_DIR)
+        except OSError as e:
+            Logger.print_error(f"Unable to delete '{OBICO_DIR}':\n{e}")
+
+    def _remove_obico_env(self) -> None:
+        if not OBICO_ENV.exists():
+            Logger.print_info(f"'{OBICO_ENV}' does not exist. Skipped ...")
+            return
+
+        try:
+            shutil.rmtree(OBICO_ENV)
+        except OSError as e:
+            Logger.print_error(f"Unable to delete '{OBICO_ENV}':\n{e}")
+
+    def _delete_obico_logs(self, instances: List[MoonrakerObico]) -> None:
+        Logger.print_status("Removing Obico logs ...")
+        all_logfiles = []
+        for instance in instances:
+            all_logfiles = list(instance.log_dir.glob(f"{OBICO_LOG}*"))
+        if not all_logfiles:
+            Logger.print_info("No Obico logs found. Skipped ...")
+            return
+
+        for log in all_logfiles:
+            Logger.print_status(f"Remove '{log}'")
+            remove_file(log)

kiauh/utils/config_utils.py

@@ -43,7 +43,7 @@ def add_config_section(
         scp.add_section(section)
 
         if options is not None:
-            for option in options:
+            for option in reversed(options):
                 scp.set(section, option[0], option[1])
 
         scp.write(cfg_file)

scripts/fluidd.sh

@@ -37,7 +37,7 @@ function install_fluidd() {
   fi
 
   ### checking dependencies
-  local dep=(wget nginx)
+  local dep=(wget nginx unzip)
   dependency_check "${dep[@]}"
   ### detect conflicting Haproxy and Apache2 installations
   detect_conflicting_packages

scripts/mainsail.sh

@@ -37,7 +37,7 @@ function install_mainsail() {
   fi
 
   ### checking dependencies
-  local dep=(wget nginx)
+  local dep=(wget nginx unzip)
   dependency_check "${dep[@]}"
   ### detect conflicting Haproxy and Apache2 installations
   detect_conflicting_packages