Merge pull request #195 from desultory/dev

resolve source symlinks too

Author: desultory

pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
 
 dependencies = [
     "zenlib >= 3.0.2",
-    "pycpio >= 1.4.0"
+    "pycpio >= 1.4.2"
 ]
 
 [options]

src/ugrd/base/core.py

@@ -1,5 +1,5 @@
 __author__ = "desultory"
-__version__ = "4.0.1"
+__version__ = "4.1.0"
 
 from pathlib import Path
 from shutil import rmtree, which
@@ -112,17 +112,22 @@ def calculate_dependencies(self, binary: str) -> list[Path]:
 
 @contains("merge_usr", "Skipping /usr merge", log_level=30)
 def handle_usr_symlinks(self) -> None:
-    """Adds symlinks for /usr/bin and /usr/sbin to /bin and /sbin."""
+    """Adds symlinks for /usr/bin and /usr/sbin to /bin and /sbin.
+    Warns if the symlink path is a directory on the host system.
+    """
     build_dir = self._get_build_path("/")
-    bin_dir = build_dir / "bin"
-    sbin_dir = build_dir / "sbin"
-    usr_sbin_dir = build_dir / "usr" / "sbin"
+    bin_dir = Path("bin")
+    sbin_dir = Path("sbin")
+    usr_sbin_dir = Path("usr/sbin")
 
     for d in [bin_dir, sbin_dir, usr_sbin_dir]:
-        if not d.is_dir() and not d.is_symlink():
-            target = d.relative_to(build_dir)
-            self.logger.debug("Creating merged-usr symlink to /usr/bin: %s" % target)
-            self._symlink("/usr/bin", target)
+        if d.is_dir() and not d.is_symlink():
+            self.logger.warning("Merged-usr symlink target is a directory: %s" % d)
+            self.logger.warning("Set `merge_usr = false` to disable /usr merge.")
+        build_d = build_dir / d
+        if not build_d.is_dir() and not build_d.is_symlink():
+            self.logger.log(5, "Creating merged-usr symlink to /usr/bin: %s" % build_d)
+            self._symlink("/usr/bin", d)
 
 
 def deploy_dependencies(self) -> None:

src/ugrd/generator_helpers.py

@@ -4,7 +4,7 @@
 
 from zenlib.util import pretty_print, colorize
 
-__version__ = "1.5.0"
+__version__ = "1.5.3"
 __author__ = "desultory"
 
 
@@ -39,9 +39,6 @@ def _mkdir(self, path: Path, resolve_build=True) -> None:
         If resolve_build is True, the path is resolved to the build directory.
         If not, the provided path is used as-is.
         """
-        from os import mkdir
-        from os.path import isdir
-
         if resolve_build:
             path = self._get_build_path(path)
 
@@ -52,12 +49,15 @@ def _mkdir(self, path: Path, resolve_build=True) -> None:
         else:
             path_dir = path
 
-        if not isdir(path_dir.parent):
+        if path_dir.is_symlink():
+            return self.logger.debug("Skipping symlink directory: %s" % path_dir)
+
+        if not path_dir.parent.is_dir():
             self.logger.debug("Parent directory does not exist: %s" % path_dir.parent)
             self._mkdir(path_dir.parent, resolve_build=False)
 
-        if not isdir(path_dir):
-            mkdir(path)
+        if not path_dir.is_dir():
+            path_dir.mkdir()
             self.logger.log(self["_build_log_level"], "Created directory: %s" % path)
         else:
             self.logger.debug("Directory already exists: %s" % path_dir)
@@ -100,7 +100,14 @@ def _write(self, file_name: Union[Path, str], contents: list[str], chmod_mask=0o
         self.logger.debug("[%s] Set file permissions: %s" % (file_path, chmod_mask))
 
     def _copy(self, source: Union[Path, str], dest=None) -> None:
-        """Copies a file into the initramfs build directory."""
+        """Copies a file into the initramfs build directory.
+        If a destination is not provided, the source is used, under the build directory.
+
+        If the destination parent is a symlink, the symlink is resolved.
+        Crates parent directories if they do not exist
+
+        Raises a RuntimeError if the destination path is not within the build directory.
+        """
         from shutil import copy2
 
         if not isinstance(source, Path):
@@ -111,10 +118,12 @@ def _copy(self, source: Union[Path, str], dest=None) -> None:
             dest = source
 
         dest_path = self._get_build_path(dest)
+        build_base = self._get_build_path("/")
 
         while dest_path.parent.is_symlink():
-            self.logger.debug("Resolving symlink: %s" % dest_path.parent)
-            dest_path = self._get_build_path(dest_path.parent.resolve() / dest_path.name)
+            resolved_path = dest_path.parent.resolve() / dest_path.name
+            self.logger.debug("Resolved symlink: %s -> %s" % (dest_path.parent, resolved_path))
+            dest_path = self._get_build_path(resolved_path)
 
         if not dest_path.parent.is_dir():
             self.logger.debug("Parent directory for '%s' does not exist: %s" % (dest_path.name, dest_path.parent))
@@ -126,23 +135,41 @@ def _copy(self, source: Union[Path, str], dest=None) -> None:
             self.logger.debug("Destination is a directory, adding source filename: %s" % source.name)
             dest_path = dest_path / source.name
 
+        try:  # Ensure the target is in the build directory
+            dest_path.relative_to(build_base)
+        except ValueError as e:
+            raise RuntimeError("Destination path is not within the build directory: %s" % dest_path) from e
+
         self.logger.log(self["_build_log_level"], "Copying '%s' to '%s'" % (source, dest_path))
         copy2(source, dest_path)
 
     def _symlink(self, source: Union[Path, str], target: Union[Path, str]) -> None:
-        """Creates a symlink"""
+        """Creates a symlink in the build directory.
+        If the target is a directory, the source filename is appended to the target path.
+
+        Creates parent directories if they do not exist.
+        If the symlink path is under a symlink, resolve to the actual path.
+
+        If the symlink source is under a symlink in the build directory, resolve to the actual path.
+        """
         if not isinstance(source, Path):
             source = Path(source)
 
         target = self._get_build_path(target)
 
+        while target.parent.is_symlink():
+            self.logger.debug("Resolving target parent symlink: %s" % target.parent)
+            target = self._get_build_path(target.parent.resolve() / target.name)
+
         if not target.parent.is_dir():
             self.logger.debug("Parent directory for '%s' does not exist: %s" % (target.name, target.parent))
             self._mkdir(target.parent, resolve_build=False)
 
-        while target.parent.is_symlink():
-            self.logger.debug("Resolving symlink: %s" % target.parent)
-            target = self._get_build_path(target.parent.resolve() / target.name)
+        build_source = self._get_build_path(source)
+        while build_source.parent.is_symlink():
+            self.logger.debug("Resolving source parent symlink: %s" % build_source.parent)
+            build_source = self._get_build_path(build_source.parent.resolve() / build_source.name)
+            source = build_source.relative_to(self._get_build_path("/"))
 
         if target.is_symlink():
             if target.resolve() == source:
@@ -153,6 +180,9 @@ def _symlink(self, source: Union[Path, str], target: Union[Path, str]) -> None:
             else:
                 raise RuntimeError("Symlink already exists: %s -> %s" % (target, target.resolve()))
 
+        if target.relative_to(self._get_build_path("/")) == source:
+            return self.logger.debug("Cannot symlink to self: %s -> %s" % (target, source))
+
         self.logger.debug("Creating symlink: %s -> %s" % (target, source))
         target.symlink_to(source)