jolt 0.9.123__py3-none-any.whl → 0.9.435__py3-none-any.whl

jolt/plugins/paths.py

@@ -16,6 +16,12 @@ class PathVariable(ArtifactStringAttribute):
     def unapply(self, task, artifact):
         pass
 
+    def __bool__(self):
+        return bool(str(self))
+
+    def __eq__(self, value: str) -> bool:
+        return str(self) == str(value)
+
     def __str__(self):
         if self._value is None:
             return ""
@@ -30,6 +36,10 @@ class PathVariableSet(ArtifactAttributeSet):
     def create(self, name):
         return PathVariable(self._artifact, name)
 
+    def __getattr__(self, name):
+        attributes = self._get_attributes()
+        return attributes.get(name, None)
+
 
 @ArtifactAttributeSetProvider.Register
 class PathVariableSetProvider(ArtifactAttributeSetProvider):
@@ -41,7 +51,7 @@ class PathVariableSetProvider(ArtifactAttributeSetProvider):
             return
 
         for key, value in content["paths"].items():
-            getattr(artifact.paths, key).set_value(value, expand=False)
+            setattr(artifact.paths, key, value)
 
     def format(self, artifact, content):
         if "paths" not in content:

jolt/plugins/pkgconfig.py

@@ -0,0 +1,219 @@
+from jolt import attributes
+from jolt import filesystem as fs
+from jolt import log
+from jolt import utils
+from jolt.error import raise_error_if
+
+
+class PkgConfigHelper(object):
+
+    TEMPLATE_PKGCONFIG = """
+prefix={{ artifact.final_path }}
+
+Name: {{ pkgname }}
+Description: {{ pkgname }} package
+Version: {{ artifact.identity }}
+
+Cflags: {% for flag in cxxflags %}{{ flag }} {% endfor %}{% for inc in incpaths %}-I${prefix}/{{ inc }} {% endfor %}{% for macro in macros %}-D{{ macro }} {% endfor %}
+
+Libs: {% for flag in ldflags %}{{ flag }} {% endfor %}{% for libpath in libpaths %}-L${prefix}/{{ libpath }} {% endfor %}{% for library in libraries %}-l{{ library }} {% endfor %}
+
+"""
+
+    def __init__(self, artifact, tools):
+        self.artifact = artifact
+        self.tools = tools
+
+    def _mkpath(self, path):
+        if fs.path.commonpath([path, self.artifact.path]) != self.artifact.path:
+            return path
+        return fs.path.relpath(path, self.artifact.path)
+
+    def cflags(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --cflags-only-other {}", self.pkgconfig, package, output=False)
+                return output.strip().split()
+        except Exception as e:
+            log.debug("PkgConfig.cflags: {}", str(e))
+            return []
+
+    def incpaths(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --cflags-only-I {}", self.pkgconfig, package, output=False)
+                return [self._mkpath(inc[2:]) for inc in output.strip().split()]
+        except Exception as e:
+            log.debug("PkgConfig.incpaths: {}", str(e))
+            return []
+
+    def linkflags(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --libs-only-other {}", self.pkgconfig, package, output=False)
+                return output.strip().split()
+        except Exception as e:
+            log.debug("PkgConfig.linkflags: {}", str(e))
+            return []
+
+    def libpaths(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --libs-only-L {}", self.pkgconfig, package, output=False)
+                return [self._mkpath(lib[2:]) for lib in output.strip().split()]
+        except Exception as e:
+            log.debug("PkgConfig.libpaths: {}", str(e))
+            return []
+
+    def libraries(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --libs-only-l {}", self.pkgconfig, package, output=False)
+                return [lib[2:] for lib in output.strip().split()]
+        except Exception as e:
+            log.debug("PkgConfig.libraries: {}", str(e))
+            return []
+
+    def write_pc(self, package):
+        with self.tools.tmpdir() as tmpdir, self.tools.cwd(tmpdir):
+            content = self.tools.render(
+                self.TEMPLATE_PKGCONFIG,
+                artifact=self.artifact,
+                pkgname=package,
+                macros=list(self.artifact.cxxinfo.macros),
+                incpaths=list(self.artifact.cxxinfo.incpaths),
+                libpaths=list(self.artifact.cxxinfo.libpaths),
+                libraries=list(self.artifact.cxxinfo.libraries),
+            )
+            print(content)
+            self.tools.write_file(f"{package}.pc", content, expand=False)
+            self.artifact.collect(f"{package}.pc", "lib/pkgconfig/")
+
+    @property
+    def pkgconfig(self):
+        pkgconf = self.tools.which(self.tools.getenv("PKG_CONFIG", "pkg-config"))
+        raise_error_if(not pkgconf, "No pkg-config tool found in PATH")
+        return pkgconf
+
+    @property
+    def environ(self):
+        path = self.artifact.environ.get("PKG_CONFIG_PATH")
+        if path is None:
+            self.tools._task.verbose("No PKG_CONFIG_PATH in artifact environment")
+
+        # Path from the artifact environment
+        path = str(path).split(fs.pathsep)
+        path = fs.pathsep.join(fs.path.join(self.artifact.path, p) for p in path)
+
+        # Append existing PKG_CONFIG_PATH from the tools environment
+        if self.tools.getenv("PKG_CONFIG_PATH"):
+            path = path + fs.pathsep + self.tools.getenv("PKG_CONFIG_PATH")
+
+        return {"PKG_CONFIG_PATH": path}
+
+
+def to_cxxinfo(
+    pkg: list | str,
+    cflags: bool = True,
+    cxxflags: bool = True,
+    incpaths: bool = True,
+    ldflags: bool = True,
+    libpaths: bool = True,
+    libraries: bool = True,
+):
+    """
+    Decorator to add pkg-config information to cxxinfo metadata of an artifact.
+
+    The decorator enables interoperability between libraries built with Jolt's
+    Ninja plugin and external packages that provide pkg-config files.
+
+    It uses the pkg-config tool to query for compiler and linker flags,
+    include paths, library paths, and libraries associated with a given package.
+    If the relevant flags are found, they are appended to the corresponding fields
+    in the artifact's cxxinfo metadata.
+
+    Args:
+        pkg (str): The name of the pkg-config package to be added to cxxinfo.
+        cflags (bool): Whether to add C compiler flags from pkg-config.
+        cxxflags (bool): Whether to add C++ compiler flags from pkg-config.
+        incpaths (bool): Whether to add include paths from pkg-config.
+        ldflags (bool): Whether to add linker flags from pkg-config.
+        libpaths (bool): Whether to add library paths from pkg-config.
+        libraries (bool): Whether to add libraries from pkg-config.
+    """
+
+    def decorate(cls):
+        original_publish = cls.publish
+
+        def publish(self, artifact, tools):
+            original_publish(self, artifact, tools)
+
+            pc = PkgConfigHelper(artifact, tools)
+            if not pc.environ:
+                self.verbose("Skipping pkg-config cxxinfo addition due to missing PKG_CONFIG_PATH.")
+                return
+
+            if cflags:
+                artifact.cxxinfo.cflags.extend(pc.cflags(pkg))
+            if cxxflags:
+                artifact.cxxinfo.cxxflags.extend(pc.cflags(pkg))
+            if incpaths:
+                artifact.cxxinfo.incpaths.extend(pc.incpaths(pkg))
+            if ldflags:
+                artifact.cxxinfo.ldflags.extend(pc.linkflags(pkg))
+            if libpaths:
+                artifact.cxxinfo.libpaths.extend(pc.libpaths(pkg))
+            if libraries:
+                artifact.cxxinfo.libraries.extend(pc.libraries(pkg))
+
+        cls.publish = publish
+        return cls
+
+    return decorate
+
+
+def from_cxxinfo(package):
+    """
+    Decorator to write a pkg-config file for the given package
+    based on the cxxinfo metadata of the artifact.
+    """
+
+    def decorate(cls):
+        original_publish = cls.publish
+        original_unpack = cls.unpack
+
+        def publish(self, artifact, tools):
+            original_publish(self, artifact, tools)
+
+            pc = PkgConfigHelper(artifact, tools)
+            pc.write_pc(package)
+
+        def unpack(self, artifact, tools):
+            original_unpack(self, artifact, tools)
+
+            pc = PkgConfigHelper(artifact, tools)
+            pc.write_pc(package)
+
+        cls.publish = publish
+        cls.unpack = unpack
+        return cls
+
+    return decorate
+
+
+def requires():
+    """ Decorator to add pkg-config requirements to a task. """
+
+    import jolt.pkgs.pkgconfig
+
+    def decorate(cls):
+        cls = attributes.requires("requires_pkgconf")(cls)
+        cls.requires_pkgconf = ["pkgconf"]
+        return cls
+
+    return decorate

jolt/plugins/podman.py

@@ -1,4 +1,4 @@
-from jolt import Download, Parameter, Resource, Task
+from jolt import Parameter, Resource, Task
 from jolt.error import raise_task_error_if
 from jolt.tasks import TaskRegistry
 from jolt import attributes
@@ -15,7 +15,6 @@ from jolt.cache import ArtifactAttributeSetProvider
 import contextlib
 import json
 from os import path
-from platform import system
 import tarfile
 
 
@@ -25,24 +24,20 @@ class PodmanListVariable(ArtifactListAttribute):
 
 class PodmanImportListVariable(PodmanListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for tar in self.items():
             try:
                 tag = artifact.podman.tags[0]
             except IndexError:
-                tag = "{}:{}".format(artifact.get_task().canonical_name, artifact.identity)
+                tag = artifact.tools.expand("{canonical_name}:{identity}")
             task.tools.run(
                 "podman import {} {}",
-                fs.path.join(artifact.path, tar, tag), output_on_error=True)
+                fs.path.join(artifact.path, tar), tag, output_on_error=True)
             for extra_tag in artifact.podman.tags[1:]:
                 task.tools.run("podman tag {} {}", tag, extra_tag, output_on_error=True)
 
 
 class PodmanLoadListVariable(PodmanListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run(
                 "podman load -i {}",
@@ -51,16 +46,12 @@ class PodmanLoadListVariable(PodmanListVariable):
 
 class PodmanPullListVariable(PodmanListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run("podman pull {}", image, output_on_error=True)
 
 
 class PodmanRmiListVariable(PodmanListVariable):
     def unapply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run("podman rmi -f {}", image, output_on_error=True)
 
@@ -108,35 +99,6 @@ class PodmanAttributeProvider(ArtifactAttributeSetProvider):
         artifact.podman.unapply(task, artifact)
 
 
-class PodmanClient(Download):
-    """ Task: Downloads and publishes the Podman command line client.
-
-    The task will be automatically made available after importing
-    ``jolt.plugins.podman``.
-    """
-
-    name = "podman/cli"
-    """ Name of the task """
-
-    arch = Parameter("x86_64", help="Host architecture")
-    """ Host architecture [x86_64] """
-
-    collect = ["podman/podman"]
-
-    host = Parameter(system().lower(), help="Host operating system")
-    """ Host operating system [autodetected] """
-
-    url = "https://download.podman.com/{host}/static/stable/{arch}/podman-{version}.tgz"
-    """ URL of binaries """
-
-    version = Parameter("20.10.13", help="Podman version")
-    """ Podman version [20.10.13] """
-
-    def publish(self, artifact, tools):
-        super().publish(artifact, tools)
-        artifact.environ.PATH.append("podman")
-
-
 @attributes.requires("_image")
 class Container(Resource):
     """
@@ -193,6 +155,18 @@ class Container(Resource):
     Alternatively, assign ``True`` to publish all exposed ports to random ports.
     """
 
+    release_on_error = True
+    """ Stop and remove container on error to avoid resource leaks. """
+
+    stop_timeout = 10
+    """ Timeout in seconds for stopping the container .
+
+    When stopping the container, the task will wait for the container to stop
+    for the specified number of seconds before forcefully killing it.
+
+    Default: 10 seconds.
+    """
+
     volumes = []
     """
     A list of volumes to mount.
@@ -202,8 +176,8 @@ class Container(Resource):
     """
 
     volumes_default = [
-        "{joltdir}:{joltdir}",
-        "{joltcachedir}:{joltcachedir}",
+        "{joltdir}",
+        "{joltcachedir}",
     ]
     """
     A list of default volumes to mount.
@@ -243,7 +217,7 @@ class Container(Resource):
     def _image(self):
         registry = TaskRegistry.get()
         tool = tools.Tools(self)
-        if registry.get_task_class(tool.expand(self.image)):
+        if registry.has_task(tool.expand(self.image)):
             return [self.image]
         return []
 
@@ -280,10 +254,12 @@ class Container(Resource):
 
     @property
     def _volumes(self):
-        return " ".join([utils.option("-v ", self.tools.expand(vol))
+        return " ".join([utils.option("-v ", self.tools.expand_path(vol))
                          for vol in self.volumes_default + self.volumes])
 
     def acquire(self, artifact, deps, tools, owner):
+        self._context_stack = None
+        self.container = None
         self.joltcachedir = config.get_cachedir()
         try:
             image = deps[self.image]
@@ -292,9 +268,10 @@ class Container(Resource):
             image = tools.expand(self.image)
 
         self._info(f"Creating container from image '{image}'")
-        self.container = tools.run(
-            "podman run -i -d {_cap_adds} {_cap_drops} {_entrypoint} {_labels} {_ports} {_privileged} {_user} {_environment} {_volumes} {image} {_arguments}",
-            image=image, output_on_error=True)
+        with utils.delayed_interrupt():
+            self.container = tools.run(
+                "podman run -i -d {_cap_adds} {_cap_drops} {_entrypoint} {_labels} {_ports} {_privileged} {_user} {_environment} {_volumes} {image} {_arguments}",
+                image=image, output_on_error=True)
 
         self._info("Created container '{container}'")
         info = tools.run("podman inspect {container}", output_on_error=True)
@@ -307,14 +284,18 @@ class Container(Resource):
                 owner.tools.runprefix(f"podman exec -i {artifact.container}"))
 
     def release(self, artifact, deps, tools, owner):
-        if self.chroot:
+        if self.chroot and self._context_stack:
             self._context_stack.close()
 
-        self._info("Stopping container '{container}'")
-        tools.run("podman stop {container}", output_on_error=True)
+        if not self.container:
+            return
 
-        self._info("Deleting container '{container}'")
-        tools.run("podman rm {container}", output_on_error=True)
+        try:
+            self._info("Stopping container '{container}'")
+            tools.run("podman stop -t {stop_timeout} {container}", output_on_error=True)
+        finally:
+            self._info("Deleting container '{container}'")
+            tools.run("podman rm -f {container}", output_on_error=True)
 
 
 class PodmanLogin(Resource):
@@ -333,8 +314,6 @@ class PodmanLogin(Resource):
     name = "podman/login"
     """ Name of the resource """
 
-    requires = ["podman/cli"]
-
     user = Parameter("", help="Podman Registry username")
     """
     Podman Registry username.
@@ -374,7 +353,6 @@ class PodmanLogin(Resource):
         tools.run("podman logout {server}")
 
 
-TaskRegistry.get().add_task_class(PodmanClient)
 TaskRegistry.get().add_task_class(PodmanLogin)
 
 
@@ -434,7 +412,6 @@ class ContainerImage(Task):
 
     Optionally add requirements to:
 
-      - ``podman/cli`` to provision the Podman client, if none is available on the host.
       - ``podman/login`` to automatically login to the Podman registry.
 
     This class must be subclassed.
@@ -457,12 +434,14 @@ class ContainerImage(Task):
         class Busybox(ContainerImage):
             \"\"\" Publishes Busybox image as gzip-compressed tarball \"\"\"
             compression = "gz"
-            requires = ["podman/cli"]
             tags = ["busybox:{identity}"]
 
     """
     abstract = True
 
+    annotations = []
+    """ A list of image annotations """
+
     autoload = True
     """
     Automatically load image file into local registry when the artifact is
@@ -492,10 +471,26 @@ class ContainerImage(Task):
     dockerfile = "Dockerfile"
     """ Path to the Dockerfile to build, or the full source code of such a file. """
 
-    output = "oci-archive"
-    """ none, oci-archive, oci-directory, docker-archive, directory, tar, tar.gz, tgz, tar.bz2, tar.xz"""
+    output = ["oci-archive"]
+    """
+    List of output formats.
+
+    If set to None, no output is produced and published.
+
+    Supported formats:
+        - archive
+        - cpio
+        - custom
+        - directory
+        - docker-archive
+        - ext4
+        - oci-archive
+        - oci-directory
+        - squashfs
 
-    imagefile = "{canonical_name}.tar"
+    """
+
+    imagefile = "{canonical_name}"
     """
     Name of the image tarball published by the task.
 
@@ -507,9 +502,6 @@ class ContainerImage(Task):
     labels = []
     """ A list of image metadata labels """
 
-    platform = None
-    """ Target platform, e.g. linux/arm/v7. """
-
     pull = True
     """
     Always pull images when building.
@@ -525,15 +517,25 @@ class ContainerImage(Task):
     The ``podman/login`` Jolt resource can be used for that purpose.
     """
 
+    size = None
+    """ Size of the image, e.g. "64M" (for certain output formats). """
+
     squash = False
     """ Squash image layers """
 
     tags = ["{canonical_name}:{identity}"]
     """ Optional list of image tags. Defaults to task's canonical name. """
 
+    target = None
+    """ Target platform, e.g. linux/arm/v7. """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+    @property
+    def _annotations(self):
+        return " ".join([utils.option("--annotation ", self.tools.expand(an)) for an in self.annotations])
+
     @property
     def _buildargs(self):
         return " ".join([utils.option("--build-arg ", self.tools.expand(ba)) for ba in self.buildargs])
@@ -542,9 +544,13 @@ class ContainerImage(Task):
     def _labels(self):
         return " ".join([utils.option("-l ", self.tools.expand(label)) for label in self.labels])
 
+    @property
+    def _output(self):
+        return utils.as_list(self.output) if self.output else []
+
     @property
     def _platform(self):
-        platform = self.tools.expand(self.platform) if self.platform else None
+        platform = self.tools.expand(self.target) if self.target else None
         return utils.option("--platform ", platform)
 
     @property
@@ -575,7 +581,7 @@ class ContainerImage(Task):
                   tools.expand_relpath(context))
 
         with tools.cwd(context):
-            tools.run("podman build {_platform} . -f {} {_buildargs} {_labels} {_tags} {pull}{squash}",
+            tools.run("podman build {_platform} . -f {} {_annotations} {_buildargs} {_labels} {_tags} {pull}{squash}",
                       utils.quote(dockerfile), pull=pull, squash=squash)
 
         try:
@@ -584,22 +590,34 @@ class ContainerImage(Task):
                 for tag in self.tags:
                     tools.run("podman push {}", tag)
 
-            if self.output:
-                self.info("Saving image")
-                with tools.cwd(tools.builddir()):
-                    if self.output in ["oci-archive", "docker-archive"]:
+            for output in self._output:
+                self.info("Saving image as {}", output)
+                outdir = tools.builddir(output)
+                with tools.cwd(outdir):
+                    if output in ["oci-archive", "docker-archive"]:
                         tools.run("podman image save --format={output} {} -o {}", self.tags[0], "image.tar")
-                    if self.output == "oci-directory":
+                    if output == "oci-directory":
                         tools.run("podman image save --format=oci-dir {} -o {}", self.tags[0], "image.dir")
-                    if self.output in ["archive", "directory"]:
+                    if output in ["archive", "cpio", "custom", "directory", "ext4", "squashfs"]:
                         ctr = tools.run("podman create {}", self.tags[0])
                         try:
-                            mount_path = tools.run("podman unshare podman mount {}", ctr, output_on_error=True)
-                            if self.output == "archive":
-                                tools.run("podman unshare tar -C {} -cf image.tar .", mount_path, output_on_error=True)
-                            else:
-                                tools.mkdir("image.dir")
-                                tools.run("podman unshare tar c -C {} . | tar --no-same-permissions --no-same-owner --no-overwrite-dir -x -C ./image.dir/", mount_path, output_on_error=True)
+                            with tools.runprefix("podman unshare "):
+                                mount_path = tools.run("podman mount {}", ctr, output_on_error=True)
+                                if output == "custom":
+                                    self.run_custom(deps, tools, mount_path)
+                                elif output == "archive":
+                                    tools.run("tar -C {} -cf image.tar .", mount_path, output_on_error=True)
+                                elif output == "cpio":
+                                    with tools.cwd(mount_path):
+                                        tools.run("find | podman unshare cpio -o -F {}/image.cpio -H newc", outdir, output_on_error=True)
+                                elif output == "ext4":
+                                    assert self.size, "Size must be set for ext4 output"
+                                    tools.run("mke2fs -t ext4 -F -L rootfs -d {} image.ext4 {size}", mount_path, output_on_error=True)
+                                elif output == "squashfs":
+                                    tools.run("mksquashfs {} image.squashfs", mount_path, output_on_error=True)
+                                else:
+                                    tools.mkdir("image.dir")
+                                    tools.run("tar c -C {} . | tar --no-same-permissions --no-same-owner --no-overwrite-dir -x -C ./image.dir/", mount_path, output_on_error=True)
                         finally:
                             utils.call_and_catch(tools.run, "podman rm {}", ctr)
         finally:
@@ -608,26 +626,52 @@ class ContainerImage(Task):
                 for tag in self.tags:
                     utils.call_and_catch(tools.run("podman rmi -f {}", tag))
 
+    def run_custom(self, deps, tools, mount_path):
+        """
+        Save image as custom output format.
+
+        The method is called when the output format is set to "custom".
+        The mount_path is the path to the mounted container root filesystem.
+
+        The default implementation does nothing.
+        """
+        pass
+
     def publish(self, artifact, tools):
+        """ Publish the image as different output formats """
+
         artifact.strings.tag = tools.expand(self.tags[0])
 
         for tag in self.tags:
             artifact.podman.tags.append(tag)
 
-        if self.output:
-            with tools.cwd(tools.builddir()):
-                if self.output in ["oci-archive", "docker-archive"] and self._imagefile:
-                    artifact.collect("image.tar", "{_imagefile}")
+        for output in self._output:
+            outdir = tools.builddir(output)
+            with tools.cwd(outdir):
+                if output in ["oci-archive", "docker-archive"] and self._imagefile:
+                    artifact.collect("image.tar", output + "/{_imagefile}.tar")
                     if self._autoload:
-                        artifact.podman.load.append("{_imagefile}")
-                        artifact.podman.rmi.append(artifact.strings.tag.get_value())
-                if self.output in ["archive"] and self._imagefile:
-                    artifact.collect("image.tar", "{_imagefile}")
+                        artifact.podman.load.append(output + "/{_imagefile}.tar")
+                        artifact.podman.rmi.append(artifact.strings.tag)
+                if output in ["archive"] and self._imagefile:
+                    artifact.collect("image.tar", output + "/{_imagefile}.tar")
                     if self._autoload:
-                        artifact.podman.imprt.append("{_imagefile}")
-                        artifact.podman.rmi.append(artifact.strings.tag.get_value())
-                if self.output in ["directory", "oci-directory"]:
+                        artifact.podman.imprt.append(output + "/{_imagefile}.tar")
+                        artifact.podman.rmi.append(artifact.strings.tag)
+                if output in ["directory", "oci-directory"]:
                     with tools.cwd("image.dir"):
-                        artifact.collect("*", symlinks=True)
-                if self.output in ["directory"]:
-                    artifact.paths.rootfs = "."
+                        artifact.collect("*", f"{output}/", symlinks=True)
+                if output in ["cpio"]:
+                    artifact.collect("image.cpio", output + "/{_imagefile}.cpio")
+                if output in ["custom"]:
+                    self.publish_custom(artifact, tools)
+                if output in ["directory"]:
+                    artifact.paths.rootfs = output
+                if output in ["ext4"]:
+                    artifact.collect("image.ext4", output + "/{_imagefile}.ext4")
+                if output in ["squashfs"]:
+                    artifact.collect("image.squashfs", output + "/{_imagefile}.squashfs")
+
+    def publish_custom(self, artifact, tools):
+        """ Publish custom output as produced by run_custom """
+        pass