Merge pull request #59 from vcf/topic/okurth/custom-checks

add plugin support

Author: oliverkurth

examples/plugins/example_checks.py

@@ -0,0 +1,75 @@
+import os
+
+
+def pre_install(installer):
+    installer.logger.info("Executing pre_install hook from poi_plugins...")
+
+
+def pre_pkgs_install(installer):
+    installer.logger.info("Executing pre_pkgs_install hook from poi_plugins...")
+
+
+def post_install(installer):
+    installer.logger.info("Executing post_install hook from poi_plugins...")
+
+
+def final_check(installer):
+    """
+    Run custom validation checks on the installed system.
+
+    :param installer: The Installer instance, providing access to:
+                      - installer.photon_root (path to the chroot)
+                      - installer.cmd (CommandUtils for running commands)
+                      - installer.logger (for logging output)
+                      - installer.install_config (the parsed ks config)
+    """
+    installer.logger.info("Starting custom validation checks...")
+
+    # ---------------------------------------------------------
+    # Example 1: Run a command INSIDE the chroot
+    # ---------------------------------------------------------
+    installer.logger.info("Checking if SSH is enabled...")
+
+    # run_in_chroot executes the command inside the new system and returns the exit code
+    retval = installer.cmd.run_in_chroot(
+        installer.photon_root,
+        "systemctl is-enabled sshd"
+    )
+
+    if retval == 0:
+        installer.logger.info("Check passed: SSH is enabled.")
+    else:
+        # You can log a warning, or raise an exception to fail the installation
+        installer.logger.warn("Check failed: SSH is NOT enabled.")
+        # raise Exception("SSH must be enabled!")
+
+    # ---------------------------------------------------------
+    # Example 2: Run a command to check a package
+    # ---------------------------------------------------------
+    installer.logger.info("Checking if 'vim' is installed...")
+    retval = installer.cmd.run_in_chroot(
+        installer.photon_root,
+        "rpm -q vim"
+    )
+    if retval == 0:
+        installer.logger.info("Check passed: vim is installed.")
+    else:
+        installer.logger.warn("Check failed: vim is not installed.")
+
+    # ---------------------------------------------------------
+    # Example 3: Check a file directly from the host side
+    # ---------------------------------------------------------
+    installer.logger.info("Checking GRUB configuration...")
+    grub_cfg_path = os.path.join(installer.photon_root, "boot/grub2/grub.cfg")
+
+    if os.path.exists(grub_cfg_path):
+        with open(grub_cfg_path, 'r') as f:
+            content = f.read()
+            if 'password' in content:
+                installer.logger.info("Check passed: GRUB password is set.")
+            else:
+                installer.logger.warn("Check failed: GRUB password is NOT set.")
+    else:
+        installer.logger.warn(f"GRUB config not found at {grub_cfg_path}")
+
+    installer.logger.info("Custom validation checks completed.")

photon_installer/installer.py

@@ -11,6 +11,7 @@
 import curses
 import datetime
 import glob
+import importlib
 import json
 import os
 import platform
@@ -108,6 +109,7 @@ class Installer(object):
         'prepkgsinstallscripts',
         'public_key',
         'photon_docker_image',
+        'plugins',
         'repos',
         'search_path',
         'setup_grub_script',
@@ -132,6 +134,7 @@ def __init__(self, working_directory=Defaults.WORKING_DIRECTORY, rpm_path=None,
         self.rpm_path = rpm_path
         self.log_path = log_path
         self.logger = None
+        self.loaded_plugins = []
         self.cmd = None
         self.working_directory = working_directory
         self.photon_release_version = photon_release_version
@@ -142,6 +145,7 @@ def __init__(self, working_directory=Defaults.WORKING_DIRECTORY, rpm_path=None,
         self.window = None        # Initialize to prevent AttributeError
 
         # some keys can have arch specific variations
+        self.known_keys = set(Installer.known_keys)
         for key in ['packages', 'linux_flavor']:
             for arch in ['x86_64', 'aarch64']:
                 self.known_keys.add(f'{key}_{arch}')
@@ -201,10 +205,15 @@ def configure(self, install_config, ui_config=None):
             config = IsoConfig()
             install_config = curses.wrapper(config.configure, ui_config)
 
+        self.install_config = install_config
+        self._load_plugins(install_config)
+
         # _check_install_config will raise InstallerConfigError if there's an issue
         self._check_install_config(install_config)
+        self._execute_external_plugins(modules.commons.CHECK_CONFIG)
 
         self._add_defaults(install_config)
+        self._execute_external_plugins(modules.commons.ADD_DEFAULTS)
 
         self.tdnf = tdnf.Tdnf(logger=self.logger,
                               config_file=self.tdnf_conf_path,
@@ -213,8 +222,6 @@ def configure(self, install_config, ui_config=None):
                               releasever=self.photon_release_version,
                               installroot=self.photon_root)
 
-        self.install_config = install_config
-
         self.ab_present = self._is_ab_present()
         self._prepare_devices()
         self._get_disk_sizes()
@@ -557,7 +564,7 @@ def _check_install_config(self, install_config):
         Raises InstallerConfigError if the configuration is invalid.
         """
 
-        unknown_keys = install_config.keys() - Installer.known_keys
+        unknown_keys = install_config.keys() - self.known_keys
         if len(unknown_keys) > 0:
             raise InstallerConfigError("Unknown install_config keys: " + ", ".join(unknown_keys))
 
@@ -1642,6 +1649,54 @@ def _setup_grub(self):
 
         self._setup_grub_password()
 
+    def _load_plugins(self, install_config):
+        """
+        Load external plugins and add their known keys to the installer.
+        """
+
+        plugins_to_load = ['photon_installer.plugins']
+        plugins_to_load.extend(install_config.get('plugins', []))
+
+        for plugin_name in plugins_to_load:
+            try:
+                plugin_mod = importlib.import_module(plugin_name)
+            except ImportError as e:
+                if plugin_name == 'photon_installer.plugins':
+                    continue
+                self.logger.error(f"Error importing plugin {plugin_name}: {e}")
+                raise InstallerError(f"Failed to load plugin {plugin_name}: {e}")
+
+            self.loaded_plugins.append(plugin_mod)
+
+            # Let plugins register their own known keys
+            if hasattr(plugin_mod, 'known_keys'):
+                self.known_keys.update(plugin_mod.known_keys)
+
+            # If the plugin has a get_known_keys function, call it
+            if hasattr(plugin_mod, 'get_known_keys'):
+                try:
+                    self.known_keys.update(plugin_mod.get_known_keys())
+                except Exception as e:
+                    self.logger.warning(f"Failed to get known keys from plugin {plugin_name}: {e}")
+
+    def _execute_external_plugins(self, phase):
+        """
+        Execute phase-specific functions from external plugins.
+        """
+        # Convert phase string (e.g. 'pre-install') to function name (e.g. 'pre_install')
+        func_name = phase.replace('-', '_')
+
+        for plugin_mod in self.loaded_plugins:
+            if hasattr(plugin_mod, func_name):
+                plugin_name = plugin_mod.__name__
+                self.logger.info(f"Executing {func_name} from plugin {plugin_name}")
+                try:
+                    func = getattr(plugin_mod, func_name)
+                    func(self)
+                except Exception as e:
+                    self.logger.error(f"Error executing {func_name} in plugin {plugin_name}: {e}")
+                    raise InstallerError(f"Plugin {plugin_name} failed during {func_name}: {e}")
+
     def _execute_modules(self, phase):
         """
         Execute the scripts in the modules folder
@@ -1675,6 +1730,8 @@ def _execute_modules(self, phase):
 
             mod.execute(self)
 
+        self._execute_external_plugins(phase)
+
     def _adjust_packages_based_on_selected_flavor(self):
         """
         Install slected linux flavor only
@@ -2053,7 +2110,6 @@ def _wait_for_device(device_path, timeout=30, check_interval=0.1):
             Wait for a device node to appear and be accessible.
             Returns True if device appears, False if timeout.
             """
-            import time
             elapsed = 0
             while elapsed < timeout:
                 if os.path.exists(device_path):
@@ -2442,6 +2498,8 @@ def _final_check(self):
                     content = f.read().strip()
                     assert content == "uninitialized" or content == "", f"file {machine_id_file} content is {content}, but should be 'uninitialized' or empty"
 
+        self._execute_external_plugins(modules.commons.FINAL_CHECK)
+
     def getfile(self, filename):
         """
         Returns absolute filepath by filename.

photon_installer/modules/commons.py

@@ -9,6 +9,9 @@
 PRE_INSTALL = "pre-install"
 PRE_PKGS_INSTALL = "pre-pkgs-install"
 POST_INSTALL = "post-install"
+FINAL_CHECK = "final-check"
+CHECK_CONFIG = "check-config"
+ADD_DEFAULTS = "add-defaults"
 
 
 def replace_string_in_file(filename, search_string, replace_string):

photon_installer/plugins/__init__.py

@@ -0,0 +1,81 @@
+import importlib
+import pkgutil
+
+
+def _execute_phase(phase_name, installer):
+    """
+    Iterate through all modules in the plugins package
+    and execute the phase function if it exists.
+    """
+    # __path__ is a special variable available in __init__.py representing the package directory
+    for _, module_name, ispkg in pkgutil.iter_modules(__path__):
+        if ispkg or module_name.startswith('_'):
+            continue  # Skip directories and private files like _my_utils.py
+
+        full_module_name = f"{__name__}.{module_name}"
+        try:
+            # Import the dropped-in module (e.g., plugins.example_checks)
+            mod = importlib.import_module(full_module_name)
+
+            # Check if this specific module implements the current phase
+            if hasattr(mod, phase_name):
+                func = getattr(mod, phase_name)
+                installer.logger.info(f"Executing {phase_name} from {full_module_name}")
+                func(installer)
+
+        except Exception as e:
+            installer.logger.error(f"Error executing {phase_name} in {full_module_name}: {e}")
+            raise
+
+# Explicitly define the phase functions so the installer's
+# hasattr(plugin_mod, 'pre_install') check succeeds on the plugins package.
+
+
+def check_config(installer):
+    _execute_phase('check_config', installer)
+
+
+def add_defaults(installer):
+    _execute_phase('add_defaults', installer)
+
+
+def pre_install(installer):
+    _execute_phase('pre_install', installer)
+
+
+def pre_pkgs_install(installer):
+    _execute_phase('pre_pkgs_install', installer)
+
+
+def post_install(installer):
+    _execute_phase('post_install', installer)
+
+
+def final_check(installer):
+    _execute_phase('final_check', installer)
+
+
+def get_known_keys():
+    """
+    Iterate through all modules in the plugins package
+    and collect their known_keys if they exist.
+    """
+    keys = set()
+    for _, module_name, ispkg in pkgutil.iter_modules(__path__):
+        if ispkg or module_name.startswith('_'):
+            continue
+
+        full_module_name = f"{__name__}.{module_name}"
+        try:
+            mod = importlib.import_module(full_module_name)
+            if hasattr(mod, 'known_keys'):
+                keys.update(mod.known_keys)
+            if hasattr(mod, 'get_known_keys'):
+                try:
+                    keys.update(mod.get_known_keys())
+                except Exception:
+                    pass
+        except Exception:
+            # Ignore errors here, they will be caught during execution
+            pass
+    return keys

setup.cfg

@@ -1,2 +1,3 @@
 [flake8]
 ignore = E501, W503, W504
+exclude = venv

setup.py

@@ -17,7 +17,7 @@
 setup(
     name='photon-installer',
     description='Installer code for photon',
-    packages=find_packages(include=['photon_installer', 'photon_installer.modules']),
+    packages=find_packages(include=['photon_installer', 'photon_installer.modules', 'photon_installer.plugins']),
     install_requires=REQUIRES,
     include_package_data=True,
     zip_safe=False,