jolt 0.9.390__tar.gz → 0.9.395__tar.gz

{jolt-0.9.390 → jolt-0.9.395}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jolt
-Version: 0.9.390
+Version: 0.9.395
 Summary: A task executor
 Home-page: https://github.com/srand/jolt
 Author: Robert Andersson

{jolt-0.9.390 → jolt-0.9.395}/jolt/cli.py

@@ -375,7 +375,7 @@ def build(ctx, task, network, keep_going, default, local,
     # If asked to force rebuild, taint all goal tasks
     if force:
         for goal in dag.goals:
-            goal.taint()
+            goal.get_extended_task().taint()
 
     # Collect information about artifact presence before starting prune or build
     acache.precheck(dag.persistent_artifacts, remote=not local)

{jolt-0.9.390 → jolt-0.9.395}/jolt/influence.py

@@ -3,7 +3,7 @@ import hashlib
 import os
 from pathlib import Path, PurePath
 
-from jolt import config
+from jolt import config as jolt_config
 from jolt import inspection
 from jolt import utils
 from jolt import filesystem as fs
@@ -202,6 +202,71 @@ def source(name, obj=None):
     return _decorate
 
 
+class ConfigInfluence(HashInfluenceProvider):
+    name = "Config"
+
+    def __init__(self, section, key):
+        self.section = section
+        self.key = key
+
+    def get_influence(self, task):
+        value = jolt_config.get(self.section, self.key)
+        if value is None:
+            value = "<unset>"
+        return "{}.{}: {}".format(self.section, self.key, value)
+
+
+def config(section, key):
+    """ Add configuration value as hash influence.
+
+    Note that the configuration value is read at the time
+    when the task is prepared, not when it is executed.
+    This means that if the configuration value changes after
+    influence has been calculated, the task will not be re-executed.
+    This is true also in distributed mode, where the task
+    is prepared locally and executed remotely on a worker
+    where the configuration value may be different.
+
+    Args:
+        section (str): Name of the configuration section.
+        key (str): Name of the configuration key.
+
+    Example:
+    .. code-block:: python
+
+        from jolt import influence
+
+        @influence.config("jolt", "task_timeout")
+        class Example(Task):
+
+    """
+    def _decorate(cls):
+        _old_influence = cls._influence
+
+        def _influence(self, *args, **kwargs):
+            influence = _old_influence(self, *args, **kwargs)
+            influence.append(ConfigInfluence(section, key))
+            return influence
+
+        cls._influence = _influence
+        return cls
+
+    return _decorate
+
+
+def global_config(section, key):
+    """ Register a configuration influence globally.
+
+    See :py:func:`config` for more information.
+
+    Args:
+        section (str): Name of the configuration section.
+        key (str): Name of the configuration key.
+    """
+
+    HashInfluenceRegistry.get().register(ConfigInfluence(section, key))
+
+
 class TaskClassSourceInfluence(HashInfluenceProvider):
     name = "Source"
 
@@ -250,7 +315,7 @@ class CacheLocationInfluence(HashInfluenceProvider):
     name = "Cache"
 
     def get_influence(self, task):
-        return config.get_cachedir()
+        return jolt_config.get_cachedir()
 
 
 @HashInfluenceRegistry.Register

{jolt-0.9.390 → jolt-0.9.395}/jolt/plugins/linux.py

@@ -21,6 +21,7 @@ def linux_arch_to_container_platform(arch):
     Returns:
         - linux/amd64
         - linux/arm
+        - linux/arm/v5
         - linux/arm64
         - linux/mips
         - linux/ppc64
@@ -30,6 +31,7 @@ def linux_arch_to_container_platform(arch):
     platforms = {
         "arm": "linux/arm",
         "arm64": "linux/arm64",
+        "armv5": "linux/arm/v5",
         "mips": "linux/mips64le",
         "powerpc": "linux/ppc64le",
         "riscv": "linux/riscv64",
@@ -63,6 +65,7 @@ def linux_arch_to_debian_arch(arch):
         "amd64": "amd64",
         "arm": "armhf",
         "arm64": "arm64",
+        "armv5": "armel",
         "mips": "mips",
         "powerpc": "ppc64el",
         "riscv": "riscv64",
@@ -81,6 +84,7 @@ class ArchParameter(Parameter):
       - amd64
       - arm
       - arm64
+      - armv5
       - mips
       - powerpc
       - riscv
@@ -94,6 +98,7 @@ class ArchParameter(Parameter):
             "amd64",
             "arm",
             "arm64",
+            "armv5",
             "mips",
             "powerpc",
             "riscv",
@@ -111,7 +116,7 @@ class _ContainerImageBase(podman.ContainerImage):
     """ Must be subclassed """
 
     arch = ArchParameter()
-    """ Target architecture [amd64, arm, arm64, mips, powerpc, riscv, s390, x86] """
+    """ Target architecture [amd64, arm, arm64, armv5, mips, powerpc, riscv, s390, x86] """
 
     @property
     def target(self):
@@ -169,13 +174,14 @@ class DebianHostSdk(Task):
     """ Must be subclassed """
 
     arch = ArchParameter()
-    """ Target architecture [amd64, arm, arm64, mips, powerpc, riscv, s390, x86] """
+    """ Target architecture [amd64, arm, arm64, armv5, mips, powerpc, riscv, s390, x86] """
 
     def publish(self, artifact, tools):
         arch_to_cross_compile = {
             "amd64": "x86_64-linux-gnu-",
             "arm": "arm-linux-gnueabihf-",
             "arm64": "aarch64-linux-gnu-",
+            "armv5": "arm-linux-gnueabi-",
             "mips": "mips-linux-gnu-",
             "powerpc": "powerpc64-linux-gnu-",
             "riscv": "riscv64-linux-gnu-",
@@ -264,6 +270,47 @@ class Squashfs(_ContainerImageBase):
         artifact.paths.squashfs = "squashfs/{_imagefile}.squashfs"
 
 
+class Ext4(_ContainerImageBase):
+    """
+    Builds an ext4 image using Podman.
+
+    The task builds a container image using the given Dockerfile and converts
+    the resulting container filesystem to an ext4 image which is published.
+
+    When building images for an architecture other than the host, the
+    binfmt-support package must be installed and configured to support running
+    applications for the target architecture. The package is available in most
+    Linux distributions.
+
+    The location of the resulting squashfs image is stored in the
+    ``artifact.paths.squashfs`` artifact attribute.
+    """
+    abstract = True
+    """ Must be subclassed """
+
+    output = ["ext4"]
+
+    size = None
+    """
+    Size of the ext4 image.
+
+    Typically used to align the image size to a supported SD card size (power of two).
+
+    Supported units are 'K', 'M', 'G', 'T'.
+    """
+
+    def run(self, deps, tools):
+        super().run(deps, tools)
+        if self.size:
+            with tools.cwd(tools.builddir("ext4")):
+                tools.run("fallocate -l {size} image.ext4")
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.strings.arch = str(self.arch)
+        artifact.paths.ext4 = "ext4/{_imagefile}.ext4"
+
+
 class _KernelBase(Task):
     abstract = True
     """ Must be subclassed """

{jolt-0.9.390 → jolt-0.9.395}/jolt/plugins/podman.py

@@ -483,6 +483,7 @@ class ContainerImage(Task):
         - custom
         - directory
         - docker-archive
+        - ext4
         - oci-archive
         - oci-directory
         - squashfs
@@ -516,6 +517,9 @@ 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 """
 
@@ -594,7 +598,7 @@ class ContainerImage(Task):
                         tools.run("podman image save --format={output} {} -o {}", self.tags[0], "image.tar")
                     if output == "oci-directory":
                         tools.run("podman image save --format=oci-dir {} -o {}", self.tags[0], "image.dir")
-                    if output in ["archive", "cpio", "custom", "directory", "squashfs"]:
+                    if output in ["archive", "cpio", "custom", "directory", "ext4", "squashfs"]:
                         ctr = tools.run("podman create {}", self.tags[0])
                         try:
                             with tools.runprefix("podman unshare "):
@@ -606,6 +610,9 @@ class ContainerImage(Task):
                                 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:
@@ -660,6 +667,8 @@ class ContainerImage(Task):
                     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")
 

{jolt-0.9.390 → jolt-0.9.395}/jolt/tools.py

@@ -1546,6 +1546,9 @@ class Tools(object):
                 refuses to terminate, it will be killed after an additional
                 10 seconds have passed. Default: None.
 
+        Returns:
+           str: stdout from command unless output=False
+
         Example:
 
             .. code-block:: python

{jolt-0.9.390 → jolt-0.9.395}/jolt/utils.py

@@ -415,7 +415,16 @@ def delayed_signal(signum):
 
 @contextlib.contextmanager
 def delayed_interrupt():
-    with delayed_signal(signum=signal.SIGINT):
+    if hasattr(signal, 'pthread_sigmask'):
+        try:
+            # Temporarily block the SIGINT signal
+            signal.pthread_sigmask(signal.SIG_BLOCK, {signal.SIGINT})
+            yield
+        finally:
+            # Unblock the SIGINT signal after the code block
+            signal.pthread_sigmask(signal.SIG_UNBLOCK, {signal.SIGINT})
+    else:
+        # Fallback for systems without pthread_sigmask
         yield
 
 

jolt-0.9.395/jolt/version.py

@@ -0,0 +1 @@
+__version__ = "0.9.395"

{jolt-0.9.390 → jolt-0.9.395}/jolt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jolt
-Version: 0.9.390
+Version: 0.9.395
 Summary: A task executor
 Home-page: https://github.com/srand/jolt
 Author: Robert Andersson

jolt-0.9.390/jolt/version.py

@@ -1 +0,0 @@
-__version__ = "0.9.390"