improved logging, fixed mount path dependency addition

Signed-off-by: Zen <[email protected]>

Author: desultory

ugrd/base/core.py

@@ -1,5 +1,5 @@
 __author__ = 'desultory'
-__version__ = '1.1.1'
+__version__ = '1.1.2'
 
 from pathlib import Path
 
@@ -109,6 +109,11 @@ def _process_paths_multi(self, path):
     if not isinstance(path, Path):
         path = Path(path)
 
+    # Make sure the path is relative
+    if path.is_absolute():
+        path = path.relative_to(path.anchor)
+        self.logger.debug("Path was absolute, converted to relative: %s" % path)
+
     self.logger.debug("Adding path: %s" % path)
     self['paths'].append(path)
 

ugrd/base/cpio.py

@@ -1,5 +1,5 @@
 __author__ = 'desultory'
-__version__ = '1.1.0'
+__version__ = '1.1.1'
 
 
 from subprocess import run
@@ -128,4 +128,8 @@ def make_cpio_list(self):
 
     packing_list = directory_list + file_list + symlink_list + node_list
 
-    self._write(self.out_dir / self.config_dict['cpio_list_name'], packing_list, in_build_dir=False)
+    cpio_list_path = self.out_dir / self.config_dict['cpio_list_name']
+    if cpio_list_path.exists():
+        self._rotate_old(cpio_list_path)
+
+    self._write(cpio_list_path, packing_list, in_build_dir=False)

ugrd/crypto/cryptsetup.py

@@ -1,9 +1,7 @@
 __author__ = 'desultory'
-
 __version__ = '0.9.1'
 
-__module_name__ = 'ugrd.crypto.cryptsetup'
-
+_module_name = 'ugrd.crypto.cryptsetup'
 
 CRYPTSETUP_PARAMETERS = ['key_type', 'partuuid', 'uuid', 'key_file', 'header_file', 'retries', 'key_command', 'reset_command', 'try_nokey']
 
@@ -52,7 +50,7 @@ def _process_cryptsetup_multi(self, mapped_name, config):
                 config[parameter] = value.format(**config)
 
     if not config.get('retries'):
-        self.logger.info("[%s] No retries specified, using default: %s" % (__module_name__, self['cryptsetup_retries']))
+        self.logger.info("[%s] No retries specified, using default: %s" % (_module_name, self['cryptsetup_retries']))
         config['retries'] = self['cryptsetup_retries']
 
     self['cryptsetup'][mapped_name] = config

ugrd/fs/mounts.py

@@ -41,7 +41,7 @@ def _process_mounts_multi(self, mount_name, mount_config):
 
     self.logger.debug("[%s] Added mount: %s" % (mount_name, mount_config))
 
-    self['paths'].append(mount_config['destination'])
+    self['paths'] = mount_config['destination']
 
 
 def _get_mount_source(self, mount, pad=False):

ugrd/initramfs_dict.py

@@ -1,6 +1,6 @@
 
 __author__ = "desultory"
-__version__ = "0.8.3"
+__version__ = "0.8.5"
 
 from tomllib import load
 from pathlib import Path
@@ -45,19 +45,18 @@ def __setitem__(self, key, value):
         if expected_type := self.builtin_parameters.get(key, self['custom_parameters'].get(key)):
             self.logger.log(5, "[%s] Expected type: %s" % (key, expected_type))
             if hasattr(self, f"_process_{key}"):
-                self.logger.debug("Using builtin setitem for: %s" % key)
+                self.logger.debug("[%s] Using builtin setitem: %s" % (key, f"_process_{key}"))
                 getattr(self, f"_process_{key}")(value)
             elif func := self['custom_processing'].get(f"_process_{key}"):
-                self.logger.debug("Using custom setitem for: %s" % key)
+                self.logger.debug("[%s] Using custom setitem: %s" % (key, func.__name__))
                 func(self, value)
             elif func := self['custom_processing'].get(f"_process_{key}_multi"):
-                self.logger.debug("Using custom plural setitem for: %s" % key)
+                self.logger.debug("[%s] Using custom plural setitem: %s" % (key, func.__name__))
                 handle_plural(func)(self, value)
             elif expected_type in (list, NoDupFlatList):
-                self.logger.debug("Using list setitem for: %s" % key)
+                self.logger.log(5, "Using list setitem for: %s" % key)
                 self[key].append(value)
             elif expected_type == dict:
-                self.logger.debug("Using dict setitem for: %s" % key)
                 if key not in self:
                     self.logger.debug("Setting dict '%s' to: %s" % (key, value))
                     super().__setitem__(key, value)
@@ -74,22 +73,11 @@ def __setitem__(self, key, value):
             else:
                 raise ValueError("Detected undefined parameter type '%s' with value: %s" % (key, value))
 
-    @handle_plural
-    def update_dict(self, name: str, key: str, value: dict):
-        """
-        Updates a dict in the internal dictionary
-        """
-        if key not in self[name]:
-            self[name][key] = value
-            self.logger.info("Set %s[%s] to: %s" % (name, key, value))
-        else:
-            self[name][key] = value
-            self.logger.warning("%s[%s] already set" % (name, key))
-
     @handle_plural
     def _process_custom_parameters(self, parameter_name, parameter_type):
         """
-        Updates the custom_parameters attribute
+        Updates the custom_parameters attribute.
+        Sets the initial value of the parameter based on the type.
         """
         self['custom_parameters'][parameter_name] = eval(parameter_type)
         self.logger.debug("Registered custom parameter '%s' with type: %s" % (parameter_name, parameter_type))
@@ -108,19 +96,26 @@ def _process_imports(self, import_type: str, import_value: dict):
         """
         Processes imports in a module, importing the functions and adding them to the appropriate list
         """
+        from importlib import import_module
+
         self.logger.debug("Processing imports of type: %s" % import_type)
 
-        from importlib import import_module
         for module_name, function_names in import_value.items():
             self.logger.debug("Importing module: %s" % module_name)
-            function_list = [getattr(import_module(f"{module_name}"), function_name) for function_name in function_names]
+
+            module = import_module(module_name)
+            self.logger.debug("[%s] Imported module contents: %s" % (module_name, dir(module)))
+            if '_module_name' in dir(module) and module._module_name != module_name:
+                self.logger.warning("Module name mismatch: %s != %s" % (module._module_name, module_name))
+
+            function_list = [getattr(module, function_name) for function_name in function_names]
 
             if import_type not in self['imports']:
-                self.logger.debug("Creating import type: %s" % import_type)
+                self.logger.log(5, "Creating import type: %s" % import_type)
                 self['imports'][import_type] = NoDupFlatList(log_bump=10, logger=self.logger, _log_init=False)
 
             self['imports'][import_type] += function_list
-            self.logger.debug("Updated import '%s': %s" % (import_type, function_list))
+            self.logger.debug("[%s] Updated import functions: %s" % (import_type, function_list))
 
             if import_type == 'config_processing':
                 for function in function_list:
@@ -138,25 +133,6 @@ def _process_mod_depends(self, module):
 
         self['mod_depends'].append(module)
 
-    def verify_deps(self):
-        """ Verifies that all module dependencies are met """
-        for module in self['mod_depends']:
-            if module not in self['modules']:
-                raise KeyError(f"Required module '{module}' not found in config")
-
-        self.logger.info("Verified module depndencies: %s" % self['mod_depends'])
-
-    def verify_mask(self):
-        """
-        Processes masked imports
-        """
-        for mask_hook, mask_items in self['mask'].items():
-            if self['imports'].get(mask_hook):
-                for function in self['imports'][mask_hook]:
-                    if function.__name__ in mask_items:
-                        self.logger.warning("Masking import: %s" % function.__name__)
-                        self['imports'][mask_hook].remove(function)
-
     @handle_plural
     def _process_modules(self, module):
         """
@@ -196,5 +172,24 @@ def _process_modules(self, module):
 
         self['modules'].append(module)
 
+    def verify_deps(self):
+        """ Verifies that all module dependencies are met """
+        for module in self['mod_depends']:
+            if module not in self['modules']:
+                raise KeyError(f"Required module '{module}' not found in config")
+
+        self.logger.info("Verified module depndencies: %s" % self['mod_depends'])
+
+    def verify_mask(self):
+        """
+        Processes masked imports
+        """
+        for mask_hook, mask_items in self['mask'].items():
+            if self['imports'].get(mask_hook):
+                for function in self['imports'][mask_hook]:
+                    if function.__name__ in mask_items:
+                        self.logger.warning("Masking import: %s" % function.__name__)
+                        self['imports'][mask_hook].remove(function)
+
     def __str__(self):
         return pretty_print(self)

ugrd/initramfs_generator.py

@@ -1,6 +1,6 @@
 
 __author__ = "desultory"
-__version__ = "0.8.1"
+__version__ = "0.8.2"
 
 from tomllib import load
 from pathlib import Path
@@ -55,9 +55,11 @@ def clean_build_dir(self):
         """
         from shutil import rmtree
 
+        # Disallow cleaning unless clean is set
         if not self.clean:
             raise ValueError("Clean is not set, not cleaning build dir: %s" % self.build_dir)
 
+        # Clean if the directory exists
         if self.build_dir.is_dir():
             self.logger.warning("Cleaning build dir: %s" % self.build_dir)
             rmtree(self.build_dir)
@@ -72,8 +74,6 @@ def build_structure(self):
         # If clean is set, clear the target build dir
         if self.clean:
             self.clean_build_dir()
-        else:
-            self.logger.debug("Not cleaning build dir: %s" % self.build_dir)
 
         self._run_hook('build_pre', return_output=False)
         self._run_hook('build_tasks', return_output=False)
@@ -99,7 +99,7 @@ def _run_func(self, function, external=False, return_output=True):
                 self.logger.debug("[%s] Function returned output: %s" % (function.__name__, function_output))
                 return function_output
         else:
-            self.logger.warning("[%s] Function returned no output" % function.__name__)
+            self.logger.debug("[%s] Function returned no output" % function.__name__)
             return []
 
     def _run_funcs(self, functions, external=False, return_output=True):
@@ -155,7 +155,7 @@ def generate_init_main(self):
             if len(hook) > 1:
                 out.extend(hook)
             else:
-                self.logger.warning("No output from init hook: %s" % init_type)
+                self.logger.debug("No output from init hook: %s" % init_type)
         return out
 
     def generate_init(self):
@@ -165,7 +165,6 @@ def generate_init(self):
         self.logger.info("Running init generator functions")
 
         init = [self.config_dict['shebang']]
-
         init += ["# Generated by initramfs_generator.py v%s" % __version__]
 
         init.extend(self._run_init_hook('init_pre'))
@@ -177,11 +176,9 @@ def generate_init(self):
             init.extend(self.generate_init_main())
 
         init.extend(self._run_init_hook('init_final'))
-
         init += ["\n\n# END INIT"]
 
         self._write('init', init, 0o755)
-
         self.logger.debug("Final config:\n%s" % pretty_print(self.config_dict))
 
     def generate_structure(self):
@@ -192,6 +189,7 @@ def generate_structure(self):
             self._mkdir(self.build_dir)
 
         for subdir in set(self.config_dict['paths']):
+            # Get the relative path of each path, create the directory in the build dir
             subdir_relative_path = subdir.relative_to(subdir.anchor)
             target_dir = self.build_dir / subdir_relative_path
 
@@ -213,8 +211,7 @@ def _mkdir(self, path):
         from os.path import isdir
         from os import mkdir
 
-        self.logger.debug("Creating directory for: %s" % path)
-
+        self.logger.log(5, "Creating directory: %s" % path)
         if path.is_dir():
             path_dir = path.parent
             self.logger.debug("Directory path: %s" % path_dir)

ugrd/kmod/kmod.py

@@ -1,6 +1,8 @@
 __author__ = 'desultory'
 
-__version__ = '0.4.7'
+__version__ = '0.5.0'
+
+__module_name__ = 'ugrd.kmod.kmod'
 
 from pathlib import Path
 
@@ -53,7 +55,7 @@ def resolve_kmod_path(self, module_name):
     if module_path == '(builtin)':
         raise BuiltinKernelModule(module_name)
 
-    self.logger.debug(f'Kernel module {module_name} is located at {module_path}')
+    self.logger.debug("[%s] Kernel module is located at: %s" % (module_name, module_path))
 
     return Path(module_path)
 
@@ -99,7 +101,7 @@ def resolve_kmod_harddeps(self, module_name):
     dependencies = cmd.stdout.decode().strip().split(',')
 
     if dependencies[0]:
-        self.logger.debug("Kernel module '%s' has hard dependencies: %s" % (module_name, dependencies))
+        self.logger.debug("[%s] Kernel module has hard dependencies: %s" % (module_name, dependencies))
         return dependencies
 
 
@@ -137,20 +139,20 @@ def resolve_kmod(self, module_name):
                 dependency_paths.append(resolve_kmod_path(self, dependency))
                 self.config_dict['kernel_modules'] = dependency
             except BuiltinKernelModule:
-                self.logger.warning("[%s] Kernel module dependency is built-in: %s" % (module_name, dependency))
+                self.logger.debug("[%s] Kernel module dependency is built-in: %s" % (module_name, dependency))
                 self.config_dict['kmod_ignore'] = module_name
 
     try:
         dependency_paths.append(resolve_kmod_path(self, module_name))
         self.logger.debug("[%s] Calculated kernel module dependencies: %s" % (module_name, dependency_paths))
     except BuiltinKernelModule:
-        self.logger.warning("[%s] Kernel module is built-in." % module_name)
+        self.logger.debug("[%s] Kernel module is built-in." % module_name)
         self.config_dict['kmod_ignore'] = module_name
 
     if dependency_paths:
         return dependency_paths
     else:
-        self.logger.warning("[%s] Kernel module has no dependencies." % module_name)
+        self.logger.debug("[%s] Kernel module has no dependencies." % module_name)
 
 
 def get_lspci_modules(self):
@@ -263,7 +265,11 @@ def calculate_modules(self):
                 self.config_dict['dependencies'] = module_paths
                 self.logger.debug("Resolved dependency paths for kernel module '%s': %s" % (module, module_paths))
             else:
-                self.logger.warning("Failed to resolve dependency paths for kernel module '%s'" % module)
+                # Make internal dependencies quieter
+                if module in self.config_dict['_kmod_depend']:
+                    self.logger.debug("Failed to resolve dependency paths for internal dependency: %s" % module)
+                else:
+                    self.logger.warning("Failed to resolve dependency paths for kernel module: %s" % module)
         except IgnoredKernelModule:
             self.logger.warning("Ignoring kernel module: %s" % module)
             self.config_dict['kernel_modules'].remove(module)