cs-image-system-packer-plugin 0.1.1__py3-none-any.whl

cs_image_system/packer_plugin/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2026 Mykel Alvis <mykelalvis@infrastructurebuilder.org>
+#
+# SPDX-License-Identifier: Apache-2.0

cs_image_system/packer_plugin/main.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: 2026 Mykel Alvis <mykelalvis@infrastructurebuilder.org>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from cs_image_system.base.basic.abstract_plugin_metadata import AbstractPluginMetadata
+from cs_image_system.base.protocols.plugin_metadata import PluginMetadataProtocol
+from cs_image_system.packer_plugin.packer_ebs_builder import PackerEbsImageBuilder, PackerGceImageBuilder
+from .packer_builder import PACKER, PackerVersionChecker
+from .packer_models import PACKER_EBS, PACKER_GCE, PackerEbsImageBuilderModel, PackerGceImageBuilderModel
+
+log = logging.getLogger(__name__)
+
+class PackerEbsTypes(AbstractPluginMetadata, PluginMetadataProtocol):
+  def __init__(self) -> None:
+    super().__init__( "1", "3.13",
+                     {PACKER_EBS: [
+                       PackerEbsImageBuilderModel,
+                       PackerEbsImageBuilder,
+                     ],
+                      PACKER_GCE: [
+                        PackerGceImageBuilderModel,
+                        PackerGceImageBuilder,
+                      ],
+                      PACKER: [
+                        PackerVersionChecker,
+                      ]},
+                     {PackerEbsImageBuilderModel: PackerEbsImageBuilder,
+                      PackerGceImageBuilderModel: PackerGceImageBuilder}
+                     )
+
+
+def initialize():
+  log.debug("Initializing Packer Provider")
+  return     PackerEbsTypes()
+

cs_image_system/packer_plugin/packer_builder.py

@@ -0,0 +1,253 @@
+# SPDX-FileCopyrightText: 2026 Mykel Alvis <mykelalvis@infrastructurebuilder.org>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import re
+import subprocess
+from pathlib import Path
+from typing import Any, TypeVar
+from warnings import deprecated
+
+from cs_image_system.base import utils
+from cs_image_system.base.basic.abstract_version_checker import AbstractVersionChecker
+from cs_image_system.base.basic.asset import AssetSet
+from cs_image_system.base.basic.builder_base_image import ImageBuilderBase
+from cs_image_system.base.basic.builder_base_runtime import RuntimeBuilderBase
+from cs_image_system.base.constants import IMAGES
+from cs_image_system.base.lifecycle import ExecutionLifecyclePhase
+from cs_image_system.base.models.executable import ExecutableModel
+from cs_image_system.base.models.executable_adds import CFExecutables
+from cs_image_system.base.models.base_image import BaseImage
+from cs_image_system.base.models.image import Image
+from cs_image_system.base.basic.builder_base_os import OsBuilderBase
+
+from cs_image_system.hashicorp_utils.collector import PackerCollector, PackerVariableDecl
+
+from .packer_models import PACKER, PackerImageBuilderModel
+
+log = logging.getLogger(__name__)
+
+
+T = TypeVar("T", bound=PackerImageBuilderModel)
+
+class PackerImageBuilder(ImageBuilderBase[T]):
+    """Packer image builder implementation."""
+
+    @classmethod
+    def csis_name(cls) -> str:
+        return PACKER
+
+    @property
+    def model(self) -> PackerImageBuilderModel:
+        return self._model # type: ignore # FIXME: Type check on aisle 4!
+
+    def get_packer_source_type(self) -> str:
+        """The packer source type: the runtime plugin's say (EXPLORE GCP
+        increment 1); ``amazon-ebs`` only for a runtime with no opinion."""
+        from cs_image_system.base.global_context import GlobalTypeContext
+        rtb = GlobalTypeContext().runtime_builders.get(self.model.get_runtime_provider())
+        if rtb is not None:
+            try:
+                return rtb.packer_source_type()
+            except NotImplementedError:
+                log.debug(f"Runtime {rtb.get_name()} declares no packer source type; assuming amazon-ebs")
+        return "amazon-ebs"
+
+    def build_target_label(self, image: Image | BaseImage) -> str:
+        return f"{self.get_packer_source_type()}.{image.get_name()}"
+
+    def generate_items_before(
+        self, phase: ExecutionLifecyclePhase
+    ) -> AssetSet: # list[tuple[Path, str]]:
+        """Generate a list of items to create before a specific execution lifecycle
+        event."""
+        items: AssetSet = AssetSet()
+        if phase == ExecutionLifecyclePhase.IMAGE_GENERATION:
+            col = PackerCollector()
+            ws = self.get_discriminator()
+            for plugin in self.model.required_plugins:
+                col.require_plugin(ws, plugin.name,
+                                   source=getattr(plugin, "source", None),
+                                   version=getattr(plugin, "version", None))
+            col.declare_variable(ws, PackerVariableDecl(
+                name="release", type="bool", default=True,
+                description="Determines if the build is meant to be immutable"))
+            col.declare_variable(ws, PackerVariableDecl(
+                name="base_image_version", type="string",
+                env_var="BASE_IMAGE_VERSION",
+                description="The version of the base image to build on top of, used for tagging and versioning the image. Read from the BASE_IMAGE_VERSION environment variable at build time; empty when it is not set."))
+            # stage 63 (decided 2026-09-25): an image's `variables:` become packer
+            # variables of this builder's roots, each with its declared value as
+            # the default (they were read by nothing but a dead generator). The
+            # collector refuses one name declared twice with different values.
+            for image in self.get_images(os_builder=True) + self.get_images():
+                for key, value in sorted((getattr(image, "variables", None) or {}).items()):
+                    col.declare_variable(ws, image_packer_variable(image.get_name(), key, value))
+
+            setup_path = self.get_path_for_phase(phase, suffix="-setup.pkr.hcl")
+            items.add(setup_path,
+                      f"# Packer Image Builders generated by {self.__class__.__name__} "
+                      f"({self.name})")
+            items.add(setup_path, "# This file contains the setup configuration for the Packer image builder    ")
+            items.add(setup_path, "# Packer configuration")
+            items.add(setup_path, f"# Generated by {self.model.__class__.__name__}")
+            items.add_list(setup_path, col.generate_packer_block(ws))
+
+            vpath = self.get_path_for_phase(phase, suffix="-vars.pkr.hcl")
+            items.add(vpath, "# Packer variables configuration")
+            items.add(vpath, f"#  Generated by {ws} ({self.model.__class__.__name__})")
+            items.add_list(vpath, col.generate_variable_blocks(ws))
+        return items
+
+    def generate_items_during(
+        self, phase: ExecutionLifecyclePhase
+    ) -> list[tuple[Path, str]]:
+        """Generate a list of items to create during a specific execution lifecycle
+        event."""
+        items: list[tuple[Path, str]] = []
+        if phase == ExecutionLifecyclePhase.IMAGE_GENERATION:
+            for image in self.get_images(os_builder=True):
+                rpath = self.get_path_for_phase(
+                    phase, f"image-{image.name}", suffix=".pkr.hcl"
+                )
+                items.append(
+                    (
+                        rpath,
+                        f"# Packer configuration for BASE image {image.name} generated by "
+                        f"{self.__class__.__name__} ({self.name})",
+                    )
+                )
+            for image in self.get_images():
+                rpath = self.get_path_for_phase(
+                    phase, f"image-{image.name}", suffix=".pkr.hcl"
+                )
+                items.append(
+                    (
+                        rpath,
+                        f"# Packer configuration for image {image.name} generated by "
+                        f"{self.__class__.__name__} ({self.name})",
+                    )
+                )
+        return items
+
+    def get_commands_to_run_after(
+        self, phase: ExecutionLifecyclePhase
+    ) -> CFExecutables:
+        """Get a list of commands to run after a specific execution lifecycle event."""
+        commands_now: list[ExecutableModel] = []
+        commands_final: list[ExecutableModel] = []
+        if  phase == ExecutionLifecyclePhase.IMAGE_GENERATION:
+            wd = self.get_path_for_phase(phase, suffix=".tf").parent
+            assert wd is not None, (
+                f"Working directory for commands to run after {phase.value} cannot be "
+                f"None for builder {self.__class__.__name__}"
+            )
+            for cmd in [["fmt", "."], ["init", "."], ["validate","."]]:
+                e = self.get_executable_copy()
+                if not e:
+                    raise ValueError(
+                        f"Executable for {self.__class__.__name__} is not available "
+                        f"but is required to run commands after {phase.value}"
+                    )
+                e.args = cmd
+                e.working_directory = wd
+                commands_now.append(e)
+            e = self.get_executable_copy()
+            e.args = [
+                "build",
+                ".",
+            ]  # This is the command that actually does the image building, so we put
+            # it in the "after" list to run after all the setup and validation commands.
+            e.working_directory = wd
+            commands_final.append(e)
+        return CFExecutables(commands_now, commands_final)
+
+    @deprecated("This method is deprecated and will be removed in a future version. Performed in a setup phase")
+    def generate_osbuilder_images(
+        self,
+        phase: ExecutionLifecyclePhase,
+        rbb: RuntimeBuilderBase,
+        images: list[Image]
+    ) -> tuple[list[tuple[Path, str]], list[ExecutableModel]]:
+        from cs_image_system.base.global_context import GlobalTypeContext
+
+        genfiles: list[tuple[Path, str]] = []
+        gencommands: list[ExecutableModel] = []
+        ctx = GlobalTypeContext()
+        log.debug(f"Generating images for runtime provider: {rbb.get_display_name()}")
+        gen_path: Path = ctx.generation_path
+        gen_path.parent.mkdir(parents=True, exist_ok=True)
+        qv = self.generate_items_during(phase)
+        genfiles.extend(qv)
+        qc= self.get_commands_to_run_during(phase)
+        gencommands.extend(qc.build_executables)
+        ctx.extend_finalization_phase(phase, qc.finalize_executables)
+        return (genfiles, gencommands)
+
+    @deprecated("This method is deprecated and will be removed in a future version. Performed in a setup phase")
+    def get_sources(self, images: list[Image]) -> list[dict[str, Any]]:
+        from cs_image_system.base.global_context import GlobalTypeContext
+
+        ctx = GlobalTypeContext()
+        configured_os_builders: dict[str, OsBuilderBase] = ctx.os_builders
+        sources: list[dict[str, Any]] = []
+        for image in images:
+            # osb = configured_os_builders.get(image.os) if image.os else None
+            # assert osb is not None, (
+            #     f"No OS builder configured for image {image.os} in {image.name}."
+            # )
+
+            s = {}
+            s.update(image.__dict__)
+            s["packer_source_type"] = "amazon-ebs"
+            sources.append(s)
+        return sources
+
+    def ib_generated_path_name(self) -> Path:
+        assert self.model.runtime is not None, (
+            "Runtime provider must be specified in the builder configuration to "
+            "determine generated path name."
+        )
+
+        return Path(utils.safe_name(self.model.runtime)) / IMAGES
+
+class PackerVersionChecker(AbstractVersionChecker):
+    """Version checker for Packer."""
+
+    @classmethod
+    def csis_name(cls) -> str:
+        return PACKER
+
+
+    def get_version_params(self) -> list[str]:
+        return ["version", "-machine-readable"]
+
+    def get_extracted_string(self, res: subprocess.CompletedProcess[str]) -> str | None:
+        return res.stdout.strip().splitlines()[0].split(",")[3].strip('"')
+
+
+_VARIABLE_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_-]*$")
+
+
+def image_packer_variable(image: str, key: str, value: Any) -> PackerVariableDecl:
+    """One `variables:` entry of an image as a packer variable (stage 63):
+    a string, number or bool, whose type follows the value; a list, a mapping
+    or a name packer cannot take is refused naming the image and the key."""
+    name = str(key)
+    if not _VARIABLE_NAME.match(name):
+        raise ValueError(f"image '{image}': `variables.{name}` is not a packer variable name "
+                         "(a letter or `_` first, then letters, digits, `_` or `-`)")
+    if isinstance(value, bool):
+        kind = "bool"
+    elif isinstance(value, (int, float)):
+        kind = "number"
+    elif isinstance(value, str):
+        kind = "string"
+    else:
+        raise ValueError(f"image '{image}': `variables.{name}` must be a string, number or bool, "
+                         f"not {type(value).__name__}")
+    # the description names no image, so two images that give one name the SAME
+    # value declare one variable; different values are refused by the collector
+    return PackerVariableDecl(name=name, type=kind, default=value,
+                              description="declared by an image's `variables:`")