jolt 0.9.76__py3-none-any.whl → 0.9.429__py3-none-any.whl

jolt/tasks.py

@@ -1,14 +1,19 @@
 import base64
 from collections import OrderedDict
-from contextlib import contextmanager
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextlib import contextmanager, ExitStack
 import copy
 import fnmatch
 import functools
+import hashlib
 import platform
+from threading import RLock
 import subprocess
 from os import environ
+from os import sys as os_sys
 import sys
 import unittest as ut
+from urllib.parse import urlparse
 import uuid
 import re
 import traceback
@@ -19,10 +24,11 @@ from jolt import utils
 from jolt.cache import ArtifactAttributeSetProvider
 from jolt.error import raise_error_if, raise_task_error, raise_task_error_if
 from jolt.error import raise_unreported_task_error_if
-from jolt.error import JoltError, JoltCommandError
+from jolt.error import JoltError, JoltCommandError, LoggedJoltError
 from jolt.expires import Immediately
 from jolt.influence import FileInfluence, TaintInfluenceProvider
 from jolt.influence import TaskClassSourceInfluence
+from jolt.influence import CallbackInfluence
 from jolt.influence import attribute as attribute_influence
 from jolt.influence import environ as environ_influence
 from jolt.influence import source as source_influence
@@ -94,6 +100,23 @@ class EnvironExport(Export):
         self._task.tools.setenv(self._envname, value)
 
 
+class ParameterValueError(JoltError):
+    """ Raised if an illegal value is assigned to a parameter """
+    def __init__(self, param, value, what=None, detail=None):
+        what = what + " " if what is not None else ""
+        detail = ", " + detail if detail is not None else ""
+        if hasattr(param, "name"):
+            super().__init__(f"Illegal {what}value '{value}' assigned to parameter '{param.name}'{detail}")
+        else:
+            super().__init__(f"Illegal {what}value '{value}' assigned to {type(param).__name__}{detail}")
+
+
+class ParameterImmutableError(JoltError):
+    """ Raised if an immutable (const=True) parameter is reassigned """
+    def __init__(self, param):
+        super().__init__(f"Cannot reassign immutable parameter '{param.name}'")
+
+
 class Parameter(object):
     """ Generic task parameter type. """
 
@@ -111,9 +134,10 @@ class Parameter(object):
         if "__param_list" not in owner.__dict__:
             setattr(owner, "__param_list", {})
         getattr(owner, "__param_list")[name] = self
+        self.name = name
 
     def __init__(self, default=None, values=None, required=True,
-                 const=False, influence=True, help=None):
+                 const=False, influence=True, help=None, valuesfn=None):
         """
         Creates a new parameter.
 
@@ -121,6 +145,10 @@ class Parameter(object):
             default (str, optional): An optional default value.
             values (list, optional): A list of accepted values. An
                 assertion is raised if an unlisted value is assigned to the parameter.
+            valuesfn (func, optional); A function that validates the assigned value.
+                If both values and valuesfn are specified, the values list is validated
+                first. The function is passed the assigned value and should return.
+                boolean value. If the function returns False, a ParameterValueError is raised.
             required (boolean, optional): If required, the parameter must be assigned
                 a value before the task can be executed. The default is ``True``.
             const (boolean, optional): If const is True, the parameter is immutable
@@ -135,42 +163,51 @@ class Parameter(object):
                 associated task.
 
         Raises:
-            ValueError: If the parameter is assigned an illegal value.
+            ParameterValueError: If the parameter is assigned an illegal value.
 
         """
 
         self._default = default
         self._value = default
         self._accepted_values = values
+        self._accepted_values_fn = valuesfn
         self._required = required
         self._const = const
         self._influence = influence
         self._help = help
-        if default:
-            self._validate(default)
+        if default is not None:
+            self._validate(default, "default")
 
     @property
     def help(self):
         values = self._help_values()
         if values:
-            return "{} {}".format(self._help, values) if self._help else values
+            return f"{self._help} {values}"if self._help else values
+        elif self._default is not None:
+            return f"{self._help} [default: {self._help_default}]" if self._help else f"[default: {self._help_default}]"
         return self._help or ""
 
+    @property
+    def _help_default(self):
+        return colors.bright(str(self._default))
+
     def _help_values(self, accepted=None):
         accepted = accepted or self._accepted_values or []
 
         def highlight(value):
             return colors.bright(value) if self._is_default(value) else colors.dim(value)
 
-        return "[{}]".format(", ".join([highlight(value) for value in accepted])) if accepted else ""
+        return "[{}]".format(", ".join([highlight(str(value)) for value in accepted])) if accepted else ""
 
     def __str__(self):
         """ Returns the parameter value as a string """
         return str(self._value) if self._value is not None else ''
 
-    def _validate(self, value):
+    def _validate(self, value, what=None):
         if self._accepted_values is not None and value not in self._accepted_values:
-            raise ValueError(value)
+            raise ParameterValueError(self, value, what=what)
+        if self._accepted_values_fn is not None and not self._accepted_values_fn(value):
+            raise ParameterValueError(self, value, what=what)
 
     def get_default(self):
         """ Get the default value of the parameter.
@@ -275,11 +312,11 @@ class Parameter(object):
             value (str): The new parameter value.
 
         Raises:
-            ValueError: If the parameter is assigned an illegal value.
+            ParameterValueError: If the parameter is assigned an illegal value.
         """
         self._validate(value)
         if self._const and value != self._default:
-            raise ValueError("immutable")
+            raise ParameterImmutableError(self)
         self._value = value
 
 
@@ -316,15 +353,15 @@ class BooleanParameter(Parameter):
                 will not influence the identity of the task artifact. The default is
                 True.
             help (str, optional): Documentation for the parameter.
-                This text is displayed when running the ``info`` command on the
+                This text is displayed when running the ``inspect`` command on the
                 associated task.
 
         Raises:
-            ValueError: If the parameter is assigned an illegal value.
+            ParameterValueError: If the parameter is assigned an illegal value.
 
         """
         default = str(default).lower() if default is not None else None
-        super(BooleanParameter, self).__init__(
+        super().__init__(
             default,
             values=["false", "true", "0", "1", "no", "yes"],
             required=required,
@@ -343,10 +380,10 @@ class BooleanParameter(Parameter):
                 False, True, "false, and "true", 0 and 1, "no" and "yes".
 
         Raises:
-            ValueError: If the parameter is assigned an illegal value.
+            ParameterValueError: If the parameter is assigned an illegal value.
         """
         value = str(value).lower()
-        super(BooleanParameter, self).set_value(value)
+        super().set_value(value)
 
     @property
     def is_true(self):
@@ -399,6 +436,198 @@ class BooleanParameter(Parameter):
         return key[0] if self.is_true else key[1]
 
 
+class IntParameter(Parameter):
+    """
+    Integer task parameter.
+
+    Implements all regular unary and binary integer operators.
+
+    """
+
+    def __init__(self, default=None, min=None, max=None, values=None, required=True, const=False,
+                 influence=True, help=None, valuesfn=None):
+        """
+        Creates a new parameter.
+
+        Args:
+            default (int, optional): An optional default integer value.
+            min (int, optional): Minimum allowed value.
+            max (int, optional): Maximum allowed value.
+            values (list, optional): A list of accepted values. An
+                assertion is raised if an unlisted value is assigned to the parameter.
+            required (boolean, optional): If required, the parameter must be assigned
+                a value before the task can be executed. The default is ``True``.
+            const (boolean, optional): If const is True, the parameter is immutable
+                and cannot be assigned a non-default value. This is useful in
+                a class hierarchy where a subclass may want to impose restrictions
+                on a parent class parameter. The default is ``False``.
+            influence (boolean, optional): If influence is False, the parameter value
+                will not influence the identity of the task artifact. The default is
+                True.
+            help (str, optional): Documentation for the parameter.
+                This text is displayed when running the ``inspect`` command on the
+                associated task.
+
+        Raises:
+            ParameterValueError: If the parameter is assigned an illegal value.
+
+        """
+        try:
+            default = int(default) if default is not None else None
+        except ValueError:
+            raise ParameterValueError(self, default, what="default")
+
+        try:
+            self._min = int(min) if min is not None else None
+        except ValueError:
+            raise ParameterValueError(self, min, what="minimum")
+
+        try:
+            self._max = int(max) if max is not None else None
+        except ValueError:
+            raise ParameterValueError(self, max, what="maximum")
+
+        super().__init__(
+            default,
+            values,
+            required=required,
+            const=const,
+            influence=influence,
+            help=help,
+            valuesfn=valuesfn)
+
+    def _validate(self, value, what=None):
+        if self._min is not None and value < self._min:
+            raise ParameterValueError(self, value, what=what, detail=f"less than minimum value '{self._min}'")
+        if self._max is not None and value > self._max:
+            raise ParameterValueError(self, value, what=what, detail=f"greater than maximum value '{self._max}'")
+        super()._validate(value, what)
+
+    def set_value(self, value):
+        """ Set the parameter value.
+
+        Args:
+            value (boolean): The new parameter value. Accepted values are:
+                False, True, "false, and "true", 0 and 1, "no" and "yes".
+
+        Raises:
+            ParameterValueError: If the parameter is assigned an illegal value.
+        """
+        try:
+            value = int(value)
+        except ValueError:
+            raise ParameterValueError(self, value)
+        super().set_value(value)
+
+    def __bool__(self):
+        """ Evaluates to False if the value is 0, True otherwise """
+        return self.get_value() != 0
+
+    def __int__(self):
+        """ Returns the integer parameter value """
+        return int(self.get_value())
+
+    def __lt__(self, other):
+        """ Less-than comparison with another integer value """
+        return int(self.get_value()) < int(other)
+
+    def __le__(self, other):
+        """ Less-or-equal comparison with another integer value """
+        return int(self.get_value()) <= int(other)
+
+    def __gt__(self, other):
+        """ Greater-than comparison with another integer value """
+        return int(self.get_value()) > int(other)
+
+    def __ge__(self, other):
+        """ Greater-or-equal comparison with another integer value """
+        return int(self.get_value()) >= int(other)
+
+    def __add__(self, other):
+        return int(self.get_value()).__add__(other)
+
+    def __sub__(self, other):
+        return int(self.get_value()).__sub__(other)
+
+    def __mul__(self, other):
+        return int(self.get_value()).__mul__(other)
+
+    def __truediv__(self, other):
+        return int(self.get_value()).__truediv__(other)
+
+    def __floordiv__(self, other):
+        return int(self.get_value()).__floordiv__(other)
+
+    def __mod__(self, other):
+        return int(self.get_value()).__mod__(other)
+
+    def __divmod__(self, other):
+        return int(self.get_value()).__divmod__(other)
+
+    def __pow__(self, other, modulo=None):
+        return int(self.get_value()).__pow__(other, modulo)
+
+    def __lshift__(self, other):
+        return int(self.get_value()).__lshift__(other)
+
+    def __rshift__(self, other):
+        return int(self.get_value()).__rshift__(other)
+
+    def __and__(self, other):
+        return int(self.get_value()).__and__(other)
+
+    def __xor__(self, other):
+        return int(self.get_value()).__xor__(other)
+
+    def __or__(self, other):
+        return int(self.get_value()).__or__(other)
+
+    def __radd__(self, other):
+        return int(self.get_value()).__radd__(other)
+
+    def __rsub__(self, other):
+        return int(self.get_value()).__rsub__(other)
+
+    def __rmul__(self, other):
+        return int(self.get_value()).__rmul__(other)
+
+    def __rtruediv__(self, other):
+        return int(self.get_value()).__rtruediv__(other)
+
+    def __rfloordiv__(self, other):
+        return int(self.get_value()).__rfloordiv__(other)
+
+    def __rmod__(self, other):
+        return int(self.get_value()).__rmod__(other)
+
+    def __rlshift__(self, other):
+        return int(self.get_value()).__rlshift__(other)
+
+    def __rrshift__(self, other):
+        return int(self.get_value()).__rrshift__(other)
+
+    def __rand__(self, other):
+        return int(self.get_value()).__rand__(other)
+
+    def __rxor__(self, other):
+        return int(self.get_value()).__rxor__(other)
+
+    def __ror__(self, other):
+        return int(self.get_value()).__ror__(other)
+
+    def __neg__(self):
+        return int(self.get_value()).__neg__()
+
+    def __pos__(self):
+        return int(self.get_value()).__pos__()
+
+    def __abs__(self):
+        return int(self.get_value()).__abs__()
+
+    def __invert__(self):
+        return int(self.get_value()).__invert__()
+
+
 class ListParameter(Parameter):
     """ List parameter type.
 
@@ -442,11 +671,11 @@ class ListParameter(Parameter):
                 will not influence the identity of the task artifact. The default is
                 True.
             help (str, optional): Documentation for the parameter.
-                This text is displayed when running the ``info`` command on the
+                This text is displayed when running the ``inspect`` command on the
                 associated task.
 
         Raises:
-            ValueError: If the parameter is assigned an illegal value.
+            ParameterValueError: If the parameter is assigned an illegal value.
 
         """
         super().__init__(*args, **kwargs)
@@ -458,17 +687,21 @@ class ListParameter(Parameter):
             value (str): A list of accepted values, separated by '+'.
 
         Raises:
-            ValueError: If the parameter is assigned an illegal value.
+            ParameterValueError: If the parameter is assigned an illegal value.
         """
-        value = str(value).split("+") if type(value) == str else value
+        value = str(value).split("+") if type(value) is str else value
         value.sort()
         super().set_value(value)
 
-    def _validate(self, value):
+    def _validate(self, value, what=None):
         if self._accepted_values is not None:
             for item in value:
                 if item not in self._accepted_values:
-                    raise ValueError(item)
+                    raise ParameterValueError(self, item, what=what)
+        if self._accepted_values_fn is not None:
+            for item in value:
+                if not self._accepted_values_fn(item):
+                    raise ParameterValueError(self, item, what=what)
 
     def get_value(self):
         return "+".join(self._value)
@@ -531,7 +764,7 @@ class ListParameter(Parameter):
             [INFO] optimization is disabled (example)
 
         """
-        if type(key) == str:
+        if type(key) is str:
             key = key.split(",")
             if len(key) == 1:
                 true = key[0]
@@ -550,6 +783,7 @@ class TaskRegistry(object):
         self.env = env
         self.tasks = {}
         self.instances = {}
+        self._workspace_resources = []
 
     @staticmethod
     def get(*args, **kwargs):
@@ -558,6 +792,21 @@ class TaskRegistry(object):
         return TaskRegistry._instance
 
     def add_task_class(self, cls):
+        """
+        Add a task class to the registry.
+
+        The class is decorated to require workspace resources.
+        """
+
+        registry = self
+
+        def _workspace_resources(self):
+            return registry._workspace_resources
+
+        if not issubclass(cls, WorkspaceResource):
+            cls = attributes.requires("_workspace_resources")(cls)
+            cls._workspace_resources = property(_workspace_resources)
+
         self.tasks[cls.name] = cls
 
     def add_task(self, task, extra_params):
@@ -566,13 +815,20 @@ class TaskRegistry(object):
         full_name = utils.format_task_name(name, params)
         self.instances[full_name] = task
 
+    def require_workspace_resource(self, taskname):
+        name, _ = utils.parse_task_name(taskname)
+        task = self.get_task_class(name)
+        raise_task_error_if(task is None, name, "Resource not found")
+        raise_task_error_if(not issubclass(task, WorkspaceResource), name, "Not a workspace resource")
+        self._workspace_resources.append(taskname)
+
     def get_task_class(self, name):
         return self.tasks.get(name)
 
     def get_task_classes(self):
         return list(self.tasks.values())
 
-    def get_task(self, name, extra_params=None, manifest=None):
+    def get_task(self, name, extra_params=None, manifest=None, buildenv=None):
         name, params = utils.parse_task_name(name)
         params.update(extra_params or {})
         full_name = utils.format_task_name(name, params)
@@ -583,14 +839,19 @@ class TaskRegistry(object):
 
         cls = self.tasks.get(name)
         if cls:
-            task = cls(parameters=params, manifest=manifest)
+            task = cls(parameters=params, manifest=manifest, buildenv=buildenv)
             task = self.instances.get(task.qualified_name, task)
-            self.instances[task.qualified_name] = task
-            self.instances[full_name] = task
+            if not isinstance(task, Resource) or isinstance(task, WorkspaceResource):
+                self.instances[task.qualified_name] = task
+                self.instances[full_name] = task
             return task
 
         raise_task_error_if(not task, full_name, "No such task")
 
+    def has_task(self, name):
+        name, params = utils.parse_task_name(name)
+        return self.tasks.get(name) is not None
+
     def set_default_parameters(self, task):
         name, params = utils.parse_task_name(task)
 
@@ -663,21 +924,198 @@ class TaskGenerator(object):
 
 class attributes:
     @staticmethod
-    def requires(attrib):
+    def arch(cls):
+        """ Return the architecture name (x86_64, arm64, etc.). """
+
+        cls._arch = Export(lambda t: platform.machine().lower().replace("amd64", "x86_64"))
+        cls.arch = property(lambda t: t._arch.value)
+        return cls
+
+    @staticmethod
+    def artifact(name, session=False):
+        """Decorator adding an additional artifact to a task.
+
+        Jolt calls the new publish method `publish_<name>` with the
+        new artifact as argument. Non-alphanumeric characters in the
+        name are replaced with underscores (_). The new artifact is
+        consumable from another task by using the string format
+        `<artifact-name>@<task-name>` to index dependencies.  The
+        standard artifact is named `main`. See the example below.
+
+        If `session` is `True`, the new artifact will be a session
+        artifact that is only valid during a single Jolt invokation.
+        Session artifacts are published even if the task fails and may
+        be used to save logs and data for post-mortem analysis.
+
+        Args:
+          name (str): Name of artifact. Used as reference from
+              consuming tasks.
+          session (boolean, False): Session artifact.
+
+        Example:
+
+          .. literalinclude:: ../examples/artifacts/build.jolt
+            :language: python
+            :caption: examples/artifacts/build.jolt
+
         """
-        Decorates a task with an alternative ``requires`` attribute.
+        name = utils.canonical(name)
 
-        The new attribute will be concatenated with the regular
-        ``requires`` attribute.
+        def decorate(cls):
+            _old_artifacts = cls._artifacts
+
+            @functools.wraps(cls._artifacts)
+            def _artifacts(self, cache, node):
+                artifacts = _old_artifacts(self, cache, node)
+                artifacts += [cache.get_artifact(node, name, session=session or isinstance(cls, Resource))]
+                return artifacts
+
+            cls._artifacts = _artifacts
+            return cls
+
+        return decorate
+
+    @staticmethod
+    def artifact_upload(uri, name="main", condition=None):
+        """
+        Decorator to add uploading of an artifact to a server.
+
+        Upon successful completion of the task, the resulting
+        artifact uploaded to the specified URI. The URI should
+        be in the format `protocol://user:password@host/path`.
+
+        The following protocols are supported:
+
+          - `http://`
+          - `https://`
+          - `file://`
+
+        Local path are also supported in which case the artifact
+        is copied to the specified location.
+
+        If the path ends with a slash, the artifact is treated as
+        a directory and copied into the root of the directory.
+
+        If the path ends with a supported archive extension, the
+        artifact is archived and optionally compressed before being
+        copied. See :func:`jolt.Tools.archive` for supported archive
+        and compression formats.
+
+        Usernames and passwords are optional. If omitted, the
+        artifact is uploaded anonymously. Environment variables
+        can be used to store sensitive information, such as
+        passwords. Specify the environment variable name in the
+        URI as `protocol://{environ[USER]}:{environ[PASS]}@host/path`.
+
+        The upload can be conditioned on the return value of a
+        function. The function is passed the task instance as
+        an argument and should return a boolean value. If the
+        function returns ``False``, the upload is skipped. The value
+        of the condition influences the hash of the task.
 
         Args:
-            attrib (str): Name of alternative attribute.
-                Keywords are expanded.
+            condition (str): Condition function to evaluate before
+                uploading the artifact. The function is passed the
+                task instance as an argument and should return a
+                boolean value. By default, the artifact is always
+                uploaded.
+            name (str): Name of the artifact to upload.
+            uri (str): Destination URI for the artifact.
+
+        Example:
+
+            .. literalinclude:: ../examples/artifacts/upload.jolt
+                :language: python
+                :caption: examples/artifacts/upload.jolt
         """
-        return utils.concat_attributes("requires", attrib)
+
+        def decorate(cls):
+            if name == "main":
+                old_publish = cls.publish
+            else:
+                old_publish = getattr(cls, "publish_" + name, None)
+
+            raise_error_if(old_publish is None, f"Cannot upload artifact '{name}' from task '{cls.name or cls.__name__.lower()}', it does not exist")
+
+            def upload_file(self, tools, cwd, src, dst):
+                with tools.cwd(cwd):
+                    tools.upload(src, dst + src)
+
+            def copy_file(self, tools, cwd, src, dst):
+                with tools.cwd(cwd):
+                    tools.copy(src, dst + src)
+
+            def list_files(self, artifact, tools):
+                with tools.cwd(artifact.path):
+                    for path in tools.glob("**"):
+                        # Skip directories
+                        if tools.isdir(path):
+                            continue
+                        yield artifact.path, path
+
+            def archive_files(self, artifact, tools, filename):
+                out = tools.builddir(artifact.identity)
+                with tools.cwd(out):
+                    tools.archive(artifact.path, filename)
+                    yield out, filename
+
+            @functools.wraps(cls.publish)
+            def publish(self, artifact, tools):
+                old_publish(self, artifact, tools)
+
+                if condition and not bool(condition(self)):
+                    return
+
+                # Expand keywords
+                uri_exp = tools.expand(uri)
+
+                # Parse URI to determine protocol
+                uri_parsed = urlparse(uri_exp)
+                if uri_parsed.scheme in ["http", "https"]:
+                    action = upload_file
+                elif uri_parsed.scheme in ["", "file"]:
+                    uri_exp = uri_parsed.path
+                    action = copy_file
+                else:
+                    raise_task_error(self, f"Unsupported protocol '{uri_parsed.scheme}' in URI '{uri_exp}'")
+
+                if uri_exp.endswith("/"):
+                    generator = list_files
+                else:
+                    generator = functools.partial(archive_files, filename=fs.path.basename(uri_parsed.path))
+                    uri_exp = fs.path.dirname(uri_exp) + "/"
+
+                if action is copy_file:
+                    uri_exp = tools.expand_path(uri_exp) + "/"
+
+                for cwd, file in generator(self, artifact, tools):
+                    action(self, tools, cwd, file, uri_exp)
+
+            if name == "main":
+                setattr(cls, "publish", publish)
+            else:
+                setattr(cls, "publish_" + name, publish)
+
+            if condition:
+                old_init = cls.__init__
+
+                @functools.wraps(cls.__init__)
+                def new_init(self, *args, **kwargs):
+                    old_init(self, *args, **kwargs)
+
+                    def make_bool(fn, *args, **kwargs):
+                        return bool(fn(*args, **kwargs))
+
+                    self.influence.append(CallbackInfluence(f"Upload {name}", make_bool, condition, self))
+
+                cls.__init__ = new_init
+
+            return cls
+
+        return decorate
 
     @staticmethod
-    def attribute(alias, target, influence=True):
+    def attribute(alias, target, influence=True, default=False):
         """
         Decorates a task with an alias for another attribute.
 
@@ -687,12 +1125,21 @@ class attributes:
                 Keywords are expanded.
             influence (boolean): Add value of target
                 attribute as influence of the task.
+            default (boolean): Return alias attribute if
+                target attribute does not exist. Value is
+                accessed through the alias attribute name
+                with a leading underscore, e.g. '_alias'.
 
         """
         def _decorate(cls):
             def _get(self):
+                if default:
+                    return getattr(self, self.expand(target), getattr(self, self.expand(alias)))
                 return getattr(self, self.expand(target))
-            setattr(cls, alias, property(_get))
+            if default:
+                setattr(cls, "_" + alias, property(_get))
+            else:
+                setattr(cls, alias, property(_get))
             if influence:
                 attribute_influence(target)(cls)
             return cls
@@ -722,6 +1169,127 @@ class attributes:
             return cls
         return _decorate
 
+    @staticmethod
+    def publish_files(attrib):
+        """
+        Decorator adding a list attribute where file publication can be specified.
+
+        Each item in the list is a set of arguments passed directly to
+        :func:`jolt.Artifact.collect`. Tuples, dictionaries and strings are
+        accepted.
+
+        Example:
+
+        .. code-block:: python
+
+          @jolt.attributes.publish_files("collect")
+          class Example(Task):
+              collect = [
+                  # Publish file.txt into artifact root
+                  "file.txt",
+
+                  # Publish file.txt into artifact dir/ directory
+                  ("file.txt", "dir/"),
+
+                  # Publish files from dir/ into artifact root
+                  {"files": "*", "cwd": "dir"},
+              ]
+
+        """
+
+        def decorate(cls):
+            if not hasattr(cls, "__publish_files"):
+                old_pub = cls.publish
+
+                def publish(self, artifact, tools):
+                    old_pub(self, artifact, tools)
+                    for args in getattr(self, "__publish_files")():
+                        if type(args) is tuple:
+                            artifact.collect(*args)
+                        elif type(args) is dict:
+                            artifact.collect(**args)
+                        else:
+                            artifact.collect(args)
+
+                cls.publish = publish
+
+            return utils.concat_attributes("_publish_files", attrib)(cls)
+        return decorate
+
+    @staticmethod
+    def common_metadata(aclocal=True, cmake=True, cxxinfo=True, path=True, pkgconfig=True):
+        """
+        Decorator adding common metadata to published artifacts.
+
+        The decorator adds common environment variables and C/C++ build information
+        to the published artifact:
+
+            - Adds `bin/` to `PATH` environment variable if it exists.
+            - Adds `lib/` and `lib64/` to C++ library paths if they exist.
+            - Adds `include/` to C++ include paths if it exists.
+            - Adds `lib/pkgconfig/`, `lib64/pkgconfig/` and `share/pkgconfig/` to
+              `PKG_CONFIG_PATH` environment variable if `.pc` files are found.
+              The `prefix` variable in `.pc` files is relocated to allow
+              installation in arbitrary locations.
+            - Adds `lib/cmake/`, `lib64/cmake/` and `share/cmake/` to
+              `CMAKE_PREFIX_PATH` environment variable if they exist.
+            - Adds `share/aclocal/` to `ACLOCAL_PATH` environment variable if it exists.
+
+        """
+        def decorate(cls):
+            _old_publish = cls.publish
+
+            @functools.wraps(cls.publish)
+            def publish(self, artifact, tools):
+                _old_publish(self, artifact, tools)
+
+                with tools.cwd(artifact.path):
+                    if path and tools.exists("bin"):
+                        artifact.environ.PATH.append("bin")
+
+                    pcdirs = set()
+
+                    for pcpath in tools.glob("lib/pkgconfig/*.pc") + tools.glob("lib64/pkgconfig/*.pc") + tools.glob("share/pkgconfig/*.pc"):
+                        pcdirs.add(fs.path.dirname(pcpath))
+                        tools.replace_in_file(pcpath, artifact.strings.install_prefix, "${{pcfiledir}}/../..")
+                    for pcpath in tools.glob("lib/*/pkgconfig/*.pc") + tools.glob("lib64/*/pkgconfig/*.pc"):
+                        pcdirs.add(fs.path.dirname(pcpath))
+                        tools.replace_in_file(pcpath, artifact.strings.install_prefix, "${{pcfiledir}}/../../..")
+
+                    for pcdir in pcdirs:
+                        artifact.environ.PKG_CONFIG_PATH.append(pcdir)
+
+                    if cmake and tools.exists("lib/cmake"):
+                        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+                    if cmake and tools.exists("lib64/cmake"):
+                        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+                    if cmake and tools.exists("share/cmake"):
+                        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+
+                    if aclocal and tools.exists("share/aclocal"):
+                        artifact.environ.ACLOCAL_PATH.append("share/aclocal")
+
+            cls.publish = publish
+
+            return cls
+
+        return decorate
+
+    @staticmethod
+    def requires(attrib):
+        """
+        Decorates a task with an alternative ``requires`` attribute.
+
+        The new attribute will be concatenated with the regular
+        ``requires`` attribute.
+
+        Args:
+            attrib (str): Name of alternative attribute.
+                Keywords are expanded.
+        """
+        return utils.concat_attributes("requires", attrib)
+
+    @staticmethod
     def load(filepath):
         """
         Decorator which loads task class attributes from a file.
@@ -762,6 +1330,9 @@ class attributes:
                 old_init(self, *args, **kwargs)
                 for key, val in eval(self.tools.read_file(filepath)).items():
                     setattr(self, key, val)
+                    self.requires = utils.unique_list(
+                        utils.call_or_return_list(self, self.__class__._requires))
+                self.requires = self.expand(self.requires)
 
             cls.__init__ = new_init
             return cls
@@ -789,6 +1360,20 @@ class attributes:
             return cls
         return _decorate
 
+    @staticmethod
+    def platform(attrib):
+        """
+        Decorates a task with an alternative ``platform`` attribute.
+
+        The new attribute will be concatenated with the regular
+        ``platform`` attribute.
+
+        Args:
+            attrib (str): Name of alternative attribute.
+                Keywords are expanded.
+        """
+        return utils.concat_attributes("platform", attrib)
+
     @staticmethod
     def system(cls):
         """
@@ -800,25 +1385,59 @@ class attributes:
         cls.system = property(lambda t: t._system.value)
         return cls
 
+    @staticmethod
+    def timeout(seconds):
+        """
+        Decorator setting a timeout for a task.
 
-class TaskBase(object):
-    """ Task base class. """
+        The timeout applies to the task's run method. A JoltTimeoutError
+        is raised if the task does not complete within the specified time.
 
-    cacheable = True
-    """ Whether the task produces an artifact or not. """
+        Args:
+            seconds (int): Timeout in seconds.
 
-    expires = Immediately()
-    """An expiration strategy, defining when the artifact may be evicted from the cache.
+        Example:
 
-    When the size of the artifact cache exceeds the configured limit
-    an attempt will be made to evict artifacts from the cache. The eviction
-    algorithm processes artifacts in least recently used (LRU) order until
-    an expired artifact is found.
+        .. code-block:: python
 
-    By default, an artifact expires immediately and may be evicted at any time
-    (in LRU order). An exception to this rule is if the artifact is required by
-    a task in the active task set. For example, if a task A requires the output
-    of task B, B will never be evicted by A while A is being executed.
+            @attributes.timeout(5)
+            class Example(Task):
+                def run(self, deps, tools):
+                    time.sleep(10)
+
+        """
+        def decorate(cls):
+            _old_run = cls.run
+
+            @functools.wraps(cls.run)
+            def run(self, deps, tools):
+                with tools.timeout(seconds):
+                    _old_run(self, deps, tools)
+
+            cls.run = run
+            return cls
+
+        return decorate
+
+
+class TaskBase(object):
+    """ Task base class. """
+
+    cacheable = True
+    """ Whether the task produces an artifact or not. """
+
+    expires = Immediately()
+    """An expiration strategy, defining when the artifact may be evicted from the cache.
+
+    When the size of the artifact cache exceeds the configured limit
+    an attempt will be made to evict artifacts from the cache. The eviction
+    algorithm processes artifacts in least recently used (LRU) order until
+    an expired artifact is found.
+
+    By default, an artifact expires immediately and may be evicted at any time
+    (in LRU order). An exception to this rule is if the artifact is required by
+    a task in the active task set. For example, if a task A requires the output
+    of task B, B will never be evicted by A while A is being executed.
 
     There are several expiration strategies to choose from:
 
@@ -883,9 +1502,37 @@ class TaskBase(object):
     joltproject = None
     """ Name of project this task belongs to. """
 
+    local = False
+    """ A local task is only executed on the local node where the build is initiated. """
+
     name = None
     """ Name of the task. Derived from class name if not set. """
 
+    platform = {}
+    """
+    Dictionary of task platform requirements.
+
+    Platform requirements control where tasks are allowed to execute.
+    Multiple requirement key/values may be specified in which case all
+    must be fulfilled in order for the task to be schedulable on a node.
+
+    The following builtin requirement labels exist:
+
+      - node.arch ["arm", "amd64"]
+      - node.os ["linux", "windows"]
+
+    Example:
+
+      .. code-block:: python
+
+        class Hello(Task):
+            # This task must run on Linux.
+            platform = {
+                "node.os": "linux",
+            }
+
+    """
+
     requires = []
     """ List of dependencies to other tasks. """
 
@@ -932,7 +1579,15 @@ class TaskBase(object):
     execution requests, the instance ID won't be.
     """
 
-    def __init__(self, parameters=None, manifest=None, **kwargs):
+    @property
+    def instance(self):
+        return str(self._instance.value)
+
+    @instance.setter
+    def instance(self, value):
+        self._instance.assign(value)
+
+    def __init__(self, parameters=None, manifest=None, buildenv=None, **kwargs):
         self._identity = None
         self._report = _JoltTask()
         self.name = self.__class__.name
@@ -953,6 +1608,7 @@ class TaskBase(object):
         self.selfsustained = utils.call_or_return(self, self.__class__._selfsustained)
         self.tools = Tools(self, self.joltdir)
         self._apply_manifest(manifest)
+        self._apply_protobuf(buildenv)
         self.requires = self.expand(self.requires)
 
     def _apply_manifest(self, manifest):
@@ -969,6 +1625,26 @@ class TaskBase(object):
                     .format(attrib.name, self.qualified_name)
                 export.assign(attrib.value)
 
+    def _apply_protobuf(self, buildenv):
+        if buildenv is None:
+            return
+        task = buildenv.tasks.get(self.exported_name)
+        if not task:
+            return
+        if task.identity:
+            self.identity = task.identity
+        if task.taint:
+            self.taint = task.taint
+        for prop in task.properties:
+            export = utils.getattr_safe(self, prop.key)
+            assert isinstance(export, Export), \
+                "'{0}' is not an exportable attribute of task '{1}'"\
+                .format(prop.key, self.qualified_name)
+            export.assign(prop.value)
+
+    def _artifacts(self, cache, node):
+        return [cache.get_artifact(node, "main")]
+
     def _influence(self):
         return utils.as_list(self.__class__.influence)
 
@@ -1003,11 +1679,8 @@ class TaskBase(object):
             if isinstance(param, Parameter):
                 try:
                     param.set_value(value)
-                except ValueError as e:
-                    raise_task_error(
-                        self,
-                        "Illegal value '{0}' assigned to parameter '{1}'",
-                        str(e), key)
+                except (ParameterValueError, ParameterImmutableError) as e:
+                    raise_task_error(self, str(e))
                 continue
             raise_task_error(self, "No such parameter '{0}'", key)
         self._assert_required_parameters_assigned()
@@ -1048,7 +1721,7 @@ class TaskBase(object):
             return _filter
 
         for _, dep in deps.items():
-            deptask = dep.get_task()
+            deptask = dep.task
             if isinstance(deptask, FileInfluence):
                 # Resource dependencies may cover the influence implicitly
                 deppath = self.tools.expand_path(str(deptask.path))
@@ -1071,201 +1744,976 @@ class TaskBase(object):
             log.warning("Missing influence: {} ({})", source, self.name)
         raise_task_error_if(sources, self, "Task is missing source influence")
 
-    def _get_export_objects(self):
-        return self._exports
+    def _get_export_objects(self):
+        return self._exports
+
+    def _get_parameter_objects(self, unset=False):
+        return self._parameters
+
+    def _get_parameters(self, unset=False):
+        return {
+            key: param.get_value()
+            for key, param in self._get_parameter_objects().items()
+            if unset or not param.is_unset()
+        }
+
+    def _get_explicitly_set_parameters(self):
+        return {
+            key: param.get_value()
+            for key, param in self._get_parameter_objects().items()
+            if param.is_set()
+        }
+
+    def __str__(self):
+        return str(self.name)
+
+    @property
+    def canonical_name(self):
+        return utils.canonical(self.name)
+
+    @property
+    def qualified_name(self):
+        return utils.format_task_name(
+            self.name,
+            self._get_parameters())
+
+    @property
+    def short_qualified_name(self):
+        return utils.format_task_name(
+            self.name,
+            self._get_explicitly_set_parameters())
+
+    @property
+    def exported_name(self):
+        if hasattr(self, "_exported_name"):
+            return self._exported_name
+        return self.short_qualified_name
+
+    @exported_name.setter
+    def exported_name(self, name):
+        self._exported_name = name
+
+    def expand(self, string_or_list, *args, **kwargs):
+        """ Expands keyword arguments/macros in a format string.
+
+        See :func:`jolt.Tools.expand` for details.
+        """
+
+        try:
+            kwargs["_instance"] = self
+            if type(string_or_list) is list:
+                return [utils.expand(string, *args, **kwargs) for string in string_or_list]
+            return utils.expand(string_or_list, *args, **kwargs)
+        except KeyError as e:
+            raise_task_error(self, "Invalid macro '{0}' encountered - forgot to set a parameter?", e)
+
+    @property
+    def identity(self):
+        return self._identity
+
+    @identity.setter
+    def identity(self, identity):
+        self._identity = identity
+
+    def is_cacheable(self):
+        return self.cacheable
+
+    def is_runnable(self):
+        return True
+
+
+class Task(TaskBase):
+    #: Path to the .jolt file where the task was defined.
+
+    abstract = True
+    """ An abstract task class indended to be subclassed.
+
+    Abstract tasks can't be executed and won't be listed.
+    """
+
+    unstable = False
+    """
+    An unstable task is allowed to fail without stopping or failing the entire build.
+
+    The unstable task is still reported as a failure at the end of the build.
+    """
+
+    def __init__(self, parameters=None, **kwargs):
+        super().__init__(parameters, **kwargs)
+
+    def info(self, fmt, *args, **kwargs):
+        """
+        Log information about the task.
+        """
+        fmt = self.tools.expand(fmt, *args, **kwargs)
+        log.info(fmt, *args, **kwargs)
+
+    def warning(self, fmt, *args, **kwargs):
+        """ Log a warning concerning the task """
+        fmt = self.tools.expand(fmt, *args, **kwargs)
+        log.warning(fmt, *args, **kwargs)
+
+    def error(self, fmt, *args, **kwargs):
+        """ Log an error concerning the task """
+        fmt = self.tools.expand(fmt, *args, **kwargs)
+        log.error(fmt, *args, **kwargs)
+
+    def verbose(self, fmt, *args, **kwargs):
+        """
+        Log verbose information about the task.
+        """
+        fmt = self.tools.expand(fmt, *args, **kwargs)
+        log.verbose(fmt, *args, **kwargs)
+
+    def clean(self, tools):
+        """
+        Cleans up resources and intermediate files created by the task.
+
+        The method is invoked in response to the user running clean
+        on the command line. It should restore the environment to its
+        original state. The next execution of the task should behave
+        as if the task is executed for the first time.
+
+        An implementation must not clean any local or remote artifact cache.
+        """
+
+    def run(self, deps, tools):
+        """
+        Performs the work of the task.
+
+        Dependencies specified with "requires" are passed as the
+        deps dictionary. The tools argument provides a set of low
+        level tool functions that may be useful.
+
+        .. code-block:: python
+
+          with tools.cwd("path/to/subdir"):
+              tools.run("make {target}")
+
+        When using methods from the toolbox, task parameters, such
+        as ``target`` above,  are automatically expanded to their values.
+        """
+
+    def nopublish(self, artifact, tools):
+        raise NotImplementedError()
+
+    def publish(self, artifact, tools):
+        """
+        Publishes files produced by :func:`~run`.
+
+        Files can be collected in to the artifact by calling
+        artifact.collect().
+
+        Additional metadata can be provided, such as environment
+        variables that should be set whenever the task artifact is
+        consumed. Example:
+
+        .. code-block:: python
+
+          # Append <artifact-path>/bin to the PATH
+          artifact.environ.PATH.append("bin")
+
+          # Pass an arbitrary string to a consumer
+          artifact.strings.foo = "bar"
+
+        """
+
+    def unpack(self, artifact, tools):
+        """
+        Unpacks files published by publish() .
+
+        The intention of this hook is to make necessary adjustments
+        to artifact files and directories once they have been downloaded
+        into the local cache on a different machine. For example,
+        paths may have to be adjusted or an installer executed.
+
+        This hook is executed in the context of a consuming task.
+        """
+        raise NotImplementedError()
+
+    def debugshell(self, deps, tools):
+        """
+        Invoked to start a debug shell.
+
+        The method prepares the environment with attributes exported by task requirement
+        artifacts. The shell is entered by passing the ``-g`` flag to the build command.
+
+        Task execution resumes normally when exiting the shell.
+        """
+        with tools.environ(PS1="jolt$ ") as env:
+            from jolt import config
+            subprocess.call(config.get_shell().split(), env=env, cwd=tools._cwd)
+
+    @contextmanager
+    def report(self):
+        """
+        Provide error analysis for task.
+
+        Intentionally undocumented. Use at own risk.
+        """
+        yield ReportProxy(self, self._report)
+
+
+class SubTask(object):
+    def __init__(self, task):
+        self._deps = []
+        self._identity = []
+        self._influence = []
+        self._message = None
+        self._outputs = []
+        self._task = task
+        self._tools = copy.copy(task.tools)
+
+    def __str__(self):
+        if self.message:
+            return self.message
+        if self._outputs:
+            return " ".join(self._outputs)
+        return None
+
+    @property
+    def dependencies(self):
+        return self._deps
+
+    @functools.cached_property
+    def identity(self):
+        sha = hashlib.sha1()
+        for ident in self._identity:
+            sha.update(ident.encode())
+        for output in self._outputs:
+            sha.update(output.encode())
+        if self.message:
+            sha.update(self.message.encode())
+        return sha.hexdigest()
+
+    @functools.cached_property
+    def influence(self):
+        sha = hashlib.sha1()
+        for infl in self._influence:
+            if callable(infl):
+                sha.update(infl().encode())
+            else:
+                sha.update(infl.encode())
+        for dep in self._deps:
+            sha.update(dep.influence.encode())
+        return sha.hexdigest()
+
+    @functools.cached_property
+    def is_outdated(self):
+        try:
+            with self._tools.cwd(self._tools.builddir("subtasks", incremental=True)):
+                if self.influence != self._tools.read_file(self.identity):
+                    return True
+                for output in self.outputs:
+                    output = fs.as_canonpath(output)
+                    assert self._tools.read_file(output + ".identity") == self.identity
+
+                # FIXME: Check hash content of output file
+                for output in self.outputs:
+                    if not fs.path.exists(fs.path.join(self._task.joltdir, output)):
+                        return True
+                for dep in self.dependencies:
+                    if dep.is_outdated:
+                        return True
+            return False
+        except Exception:
+            return True
+
+    def set_uptodate(self):
+        try:
+            del self.influence
+            del self.is_outdated
+        except AttributeError:
+            pass
+        with self._tools.cwd(self._tools.builddir("subtasks", incremental=True)):
+            self._tools.write_file(self.identity, self.influence)
+
+            for output in self.outputs:
+                output = fs.as_canonpath(output)
+                self._tools.mkdirname(output)
+                self._tools.write_file(output + ".identity", self.identity)
+
+    def run(self):
+        pass
+
+    def add_dependency(self, dep):
+        deps = utils.as_list(dep)
+        subtasks = [self._task._add_input(dep) for dep in deps]
+        self._deps.extend(subtasks)
+
+    def add_identity(self, infl):
+        self._identity.append(infl)
+
+    def add_influence(self, infl):
+        self._influence.append(infl)
+
+    def add_influence_file(self, path):
+        path = self._tools.expand_path(path)
+        self.add_influence(utils.filesha1(path))
+
+    def add_influence_depfile(self, path):
+        def depfile():
+            result = ""
+            try:
+                deps = self._tools.read_depfile(fs.path.join(self._task.joltdir, path))
+            except OSError:
+                return "N/A"
+            with self._tools.cwd(self._task.joltdir):
+                for output in self.outputs:
+                    for input in deps.get(output, []):
+                        input = self._tools.expand_path(input)
+                        result += utils.filesha1(input)
+            return result
+        self.add_influence(depfile)
+
+    def add_output(self, output):
+        self.add_identity(output)
+        if type(output) is list:
+            self._outputs.extend(output)
+        else:
+            self._outputs.append(output)
+
+    @property
+    def message(self):
+        return self._message
+
+    def set_message(self, message):
+        self._message = message
+
+    @property
+    def outputs(self):
+        return self._outputs
+
+
+class Input(SubTask):
+    def __init__(self, task, input):
+        super().__init__(task)
+        self._outputs = [input]
+        self.add_influence_file(input)
+        self.set_uptodate()
+
+    @property
+    def message(self):
+        return f"[IN] {self._outputs[0]}"
+
+    def run(self):
+        raise_task_error(self._task, "Input file '{}' does not exist", self._outputs[0])
+
+
+class CommandSubtask(SubTask):
+    def __init__(self, task, command):
+        super().__init__(task)
+        self.add_identity(command)
+        self._command = command
+
+    def __str__(self):
+        s = super().__str__()
+        return s if s is not None and not log.is_verbose() else self._tools.expand(self._command)
+
+    def run(self):
+        self._tools.run(self._command)
+
+
+class FunctionSubtask(SubTask):
+    def __init__(self, task, fn):
+        super().__init__(task)
+        self.add_identity(fn.__name__)
+        self.fn = fn
+
+    def run(self):
+        self.fn(self)
+
+
+class RenderSubtask(SubTask):
+    def __init__(self, task, template, **kwargs):
+        super().__init__(task)
+        self._data = self._tools.render(template, **kwargs)
+        self.add_identity(template)
+        self.add_influence(self._data)
+
+    def run(self):
+        for output in self.outputs:
+            self._tools.write_file(output, self._data, expand=False)
+
+
+class FileRenderSubtask(SubTask):
+    def __init__(self, task, path, **kwargs):
+        super().__init__(task)
+        self.add_identity(path)
+        self._path = path
+
+    def run(self):
+        data = self._tools.render_file(self._path)
+        for output in self.outputs:
+            self._tools.write_file(output, data, expand=False)
+
+
+class MultiTask(Task):
+    """
+    A task with subtasks that are executed in parallel with intermediate caching.
+
+    A MultiTask is useful for tasks with many subtasks that benefit from intermediate
+    caching, such as compilation tasks where multiple source files are compiled into
+    object files and then either linked into an executable or archived into a library.
+
+    Subtasks are executed in parallel and their output is cached locally in a build
+    directory. The output is not automatically shared with other Jolt clients, only
+    the files published by the MultiTask is shared. A subtask is only re-executed
+    if the influence one of its dependencies change.
+
+    Subtasks are defined in the MultiTask method generate() and they can be either
+    a shell command or a python function. Helper methods in the class allow
+    implementors to define outputs and inter-subtask dependencies.
+
+    Example:
+
+        .. code-block:: python
+
+          flags = ["-DDEBUG"]
+
+          def generate(self, deps, tools):
+              sources = ["a.cpp", "b.cpp", "c.cpp"]
+              objects = []
+
+              # Create compilation subtasks for each source file
+              for source in sources:
+                  object = self.command(
+                      "g++ {flags} -c {inputs} -o {outputs} ",
+                      inputs=[source],
+                      outputs=[source  +".o"])
+                  objects.append(object)
+
+              # Create linker subtask
+              executable = self.command(
+                  "g++ {inputs} -o {output}",
+                  inputs=objects,
+                  outputs=["executable"])
+
+    """
+
+    abstract = True
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._subtasks = set()
+        self._subtasks_by_output = {}
+
+    def _add_subtask(self, subtask):
+        self._subtasks.add(subtask)
+
+        for output in subtask.outputs:
+            if output in self._subtasks_by_output:
+                othersubtask = self._subtasks_by_output
+                raise_task_error(
+                    self,
+                    "'{}' is generated by both '{}' and '{}'",
+                    output, subtask.command, othersubtask.command)
+            self._subtasks_by_output[output] = subtask
+
+        return subtask
+
+    def _find_subtask(self, output):
+        return self._subtasks_by_output.get(output)
+
+    def _add_input(self, input):
+        raise_task_error_if(not input, self, "Input is None")
+        if not isinstance(input, SubTask):
+            inputsubtask = self._find_subtask(input)
+            if inputsubtask:
+                return inputsubtask
+            inputsubtask = Input(self, input)
+        else:
+            inputsubtask = input
+        self._subtasks.add(inputsubtask)
+        self._subtasks_by_output[input] = inputsubtask
+        return inputsubtask
+
+    def _to_subtask_list(self, inputs):
+        inputs = utils.as_list(inputs)
+        return utils.unique_list([self._add_input(input) for input in inputs])
+
+    def _to_output_files(self, subtasks):
+        subtasks = utils.as_list(subtasks)
+        outputs = []
+        for subtask in subtasks:
+            if isinstance(subtask, SubTask):
+                outputs.extend(subtask.outputs)
+            else:
+                outputs.append(subtask)
+        return outputs
+
+    def _to_input_subtasks(self, inputs, **kwargs):
+        inputs = utils.as_list(inputs)
+        subtasks = []
+        for input in inputs:
+            input = self.expand(input, **kwargs)
+            subtasks.append(self._add_input(input))
+        return subtasks
+
+    def command(self, command, inputs=None, outputs=None, message=None, mkdir=True, **kwargs):
+        """
+        Create shell command subtask.
+
+        The subtask executes the specified command. String format specifiers may be used and
+        are resolved primarily by kwargs and secondarily by task attributes.
 
-    def _get_parameter_objects(self, unset=False):
-        return self._parameters
+        Args:
+            inputs (str, list): files or subtasks that the command depends on.
+            outputs (str, list): list of files that the subtasks produces.
+            message (str): custom message that the subtask will print when executed.
+            mkdir (boolean): automatically create directories for outputs. If False,
+                the caller must ensure that the directories exist before the the subtask
+                is executed.
+            kwargs: additional keyword values used to format the command line string.
 
-    def _get_parameters(self, unset=False):
-        return {
-            key: param.get_value()
-            for key, param in self._get_parameter_objects().items()
-            if unset or not param.is_unset()
-        }
+        Returns:
+            Subtask object.
 
-    def _get_explicitly_set_parameters(self):
-        return {
-            key: param.get_value()
-            for key, param in self._get_parameter_objects().items()
-            if param.is_set()
-        }
+        Example:
 
-    def __str__(self):
-        return str(self.name)
+            .. code-block:: python
 
-    @property
-    def canonical_name(self):
-        return utils.canonical(self.name)
+              executable = self.command(
+                  "g++ {inputs} -o {output}",
+                  inputs=["main.cpp"],
+                  outputs=["executable"])
 
-    @property
-    def qualified_name(self):
-        return utils.format_task_name(
-            self.name,
-            self._get_parameters())
+        """
+        input_jobs = self._to_input_subtasks(inputs, **kwargs)
+        inputfiles = self._to_output_files(inputs)
 
-    @property
-    def short_qualified_name(self):
-        return utils.format_task_name(
-            self.name,
-            self._get_explicitly_set_parameters())
+        outputs = utils.as_list(outputs)
+        outputs = [self.tools.expand_relpath(output, self.joltdir, **kwargs) for output in outputs]
 
-    def expand(self, string_or_list, *args, **kwargs):
-        """ Expands keyword arguments/macros in a format string.
+        dirs = set()
+        if mkdir:
+            for output in outputs:
+                dirs.add(self.mkdirname(output, inputs=inputfiles, outputs=outputs, **kwargs))
 
-        See :func:`jolt.Tools.expand` for details.
-        """
+        command = self.expand(command, inputs=inputfiles, outputs=outputs, **kwargs)
+        subtask = CommandSubtask(self, command)
 
-        try:
-            kwargs["_instance"] = self
-            if type(string_or_list) == list:
-                return [utils.expand(string, *args, **kwargs) for string in string_or_list]
-            return utils.expand(string_or_list, *args, **kwargs)
-        except KeyError as e:
-            raise_task_error(self, "Invalid macro '{0}' encountered - forgot to set a parameter?", e)
+        for dir in dirs:
+            subtask.add_dependency(dir)
+        for input in input_jobs:
+            subtask.add_dependency(input)
+        for output in outputs:
+            output = self.expand(output, inputs=inputfiles, outputs=outputs, **kwargs)
+            subtask.add_output(output)
 
-    @property
-    def identity(self):
-        return self._identity
+        if message:
+            subtask.set_message(self.expand(message, inputs=inputfiles, outputs=outputs, **kwargs))
 
-    @identity.setter
-    def identity(self, identity):
-        self._identity = identity
+        self._add_subtask(subtask)
 
-    def is_cacheable(self):
-        return self.cacheable
+        return subtask
 
-    def is_runnable(self):
-        return True
+    def call(self, fn, outputs, **kwargs):
+        """
+        Create a Python function call subtask.
 
+        The subtask executes the specified Python function, passing the subtask as argument.
 
-class Task(TaskBase):
-    #: Path to the .jolt file where the task was defined.
+        Args:
+            fn (func): Python function to execute.
+            outputs (str, list): list of files that the subtasks produces.
+            kwargs: additional keyword values used to format the output file paths.
 
-    abstract = True
-    """ An abstract task class indended to be subclassed.
+        Returns:
+            Subtask object.
 
-    Abstract tasks can't be executed and won't be listed.
-    """
+        Example:
 
-    def __init__(self, parameters=None, **kwargs):
-        super(Task, self).__init__(parameters, **kwargs)
+            .. code-block:: python
+
+              def mkdir(subtask):
+                  for output in subtask.outputs:
+                      self.tools.mkdir(output)
+
+              dirtask = self.call(mkdir, outputs=["newly/created/directory"])
 
-    def info(self, fmt, *args, **kwargs):
         """
-        Log information about the task.
+        subtask = FunctionSubtask(self, fn)
+        outputs = utils.as_list(outputs)
+        for output in outputs:
+            output = self.tools.expand_relpath(output, self.joltdir, outputs=outputs, **kwargs)
+            subtask.add_output(output)
+        self._add_subtask(subtask)
+        return subtask
+
+    def mkdir(self, path, *args, **kwargs):
         """
-        fmt = self.tools.expand(fmt, *args, **kwargs)
-        log.info(fmt, *args, **kwargs)
+        Create a subtask that creates a directory.
 
-    def warning(self, fmt, *args, **kwargs):
-        """ Log a warning concerning the task """
-        fmt = self.tools.expand(fmt, *args, **kwargs)
-        log.warning(fmt, *args, **kwargs)
+        Args:
+            path (str): Path to directory.
+            kwargs: additional keyword values used to format the directory path string.
 
-    def error(self, fmt, *args, **kwargs):
-        """ Log an error concerning the task """
-        fmt = self.tools.expand(fmt, *args, **kwargs)
-        log.error(fmt, *args, **kwargs)
+        Returns:
+            Subtask object.
 
-    def clean(self, tools):
-        """
-        Cleans up resources and intermediate files created by the task.
+        Example:
 
-        The method is invoked in response to the user running clean
-        on the command line. It should restore the environment to its
-        original state. The next execution of the task should behave
-        as if the task is executed for the first time.
+            .. code-block:: python
 
-        An implementation must not clean any local or remote artifact cache.
+              dirtask = self.mkdir("{outdir}/directory", outdir=tools.builddir())
         """
+        path = self.expand(path, *args, **kwargs)
+        subtask = self._find_subtask(path)
+        if not subtask:
+            subtask = self.call(lambda subtask: self.tools.mkdir(path), [path])
+        return subtask
 
-    def run(self, deps, tools):
+    def mkdirname(self, path, *args, **kwargs):
         """
-        Performs the work of the task.
+        Create a subtask that creates a parent directory.
 
-        Dependencies specified with "requires" are passed as the
-        deps dictionary. The tools argument provides a set of low
-        level tool functions that may be useful.
+        Args:
+            path (str): Path for which the parent directory shall be created.
+            kwargs: additional keyword values used to format the directory path string.
 
-        .. code-block:: python
+        Returns:
+            Subtask object.
 
-          with tools.cwd("path/to/subdir"):
-              tools.run("make {target}")
+        Example:
+
+            .. code-block:: python
+
+              # Creates {outdir}/directory
+              dirtask = self.mkdir("{outdir}/directory/object.o", outdir=tools.builddir())
 
-        When using methods from the toolbox, task parameters, such
-        as ``target`` above,  are automatically expanded to their values.
         """
+        path = self.expand(path, *args, **kwargs)
+        path = fs.path.dirname(path)
+        return self.mkdir(path, *args, **kwargs)
 
-    def publish(self, artifact, tools):
+    def render(self, template, outputs, **kwargs):
         """
-        Publishes files produced by :func:`~run`.
+        Create a subtask that renders a Jinja template string to file.
 
-        Files can be collected in to the artifact by calling
-        artifact.collect().
+        Args:
+            template (str): Jinja template string.
+            outputs (str, list): list of files that the subtasks produces.
+            kwargs: additional keyword values used to render the template and output file paths.
 
-        Additional metadata can be provided, such as environment
-        variables that should be set whenever the task artifact is
-        consumed. Example:
+        Returns:
+            Subtask object.
 
-        .. code-block:: python
+        Example:
 
-          # Append <artifact-path>/bin to the PATH
-          artifact.environ.PATH.append("bin")
+            .. code-block:: python
 
-          # Pass an arbitrary string to a consumer
-          artifact.strings.foo = "bar"
+              # Creates file.list with two lines containing "a.o" and "b.o"
 
-        """
+              template_task = self.render(
+                  "{% for line in lines %}{{ line }}\\n{% endfor %}",
+                  outputs=["file.list"],
+                  lines=["a.o", "b.o"])
 
-    def unpack(self, artifact, tools):
         """
-        Unpacks files published by publish() .
+        outputs = utils.as_list(outputs)
+        subtask = RenderSubtask(self, template, **kwargs)
+        for output in outputs:
+            output = self.tools.expand_relpath(output, self.joltdir, outputs=outputs, **kwargs)
+            subtask.add_output(output)
+        self._add_subtask(subtask)
+        return subtask
+
+    def render_file(self, template, outputs, **kwargs):
+        """
+        Create a subtask that renders a Jinja template file to file.
 
-        The intention of this hook is to make necessary adjustments
-        to artifact files and directories once they have been downloaded
-        into the local cache on a different machine. For example,
-        paths may have to be adjusted or an installer executed.
+        Args:
+            template (str): Jinja template file path.
+            outputs (str, list): list of files that the subtasks produces.
+            kwargs: additional keyword values used to format the output file paths.
 
-        This hook is executed in the context of a consuming task.
-        """
-        raise NotImplementedError()
+        Returns:
+            Subtask object.
+
+        Example:
+
+            .. code-block:: python
+
+              # Render file.list.template into file.list
+              template_task = self.render_file("file.list.template", outputs=["file.list"])
 
-    def shell(self, deps, tools):
         """
-        Invoked to start a debug shell.
+        template = self._to_subtask_list(template)
+        templatefiles = self._to_output_files(template)
+        raise_task_error_if(len(templatefiles) > 1, "Can only render one template at a time")
+
+        outputs = utils.as_list(outputs)
+        subtask = FileRenderSubtask(self, templatefiles[0], **kwargs)
+        for output in outputs:
+            output = self.tools.expand_relpath(output, outputs=outputs, **kwargs)
+            subtask.add_output(output)
+        for input in templatefiles:
+            subtask.add_dependency(input)
+        self._add_subtask(subtask)
+        return subtask
+
+    def generate(self, deps, tools):
+        """
+        Called to generate subtasks.
 
-        The method prepares the environment with attributes exported by task requirement
-        artifacts. The shell is entered by passing the ``-g`` flag to the build command.
+        An implementer can override this method in order to create subtasks
+        that will later be executed during the :func:`~run` stage of the task.
+
+        Subtasks can be defined using either of these helper methods:
+
+          - :func:`~call`
+          - :func:`~command`
+          - :func:`~mkdir`
+          - :func:`~mkdirname`
+          - :func:`~render`
+          - :func:`~render_file`
 
-        Task execution resumes normally when exiting the shell.
         """
-        with tools.environ(PS1="jolt$ ") as env:
-            from jolt import config
-            subprocess.call(config.get_shell().split(), env=env, cwd=tools._cwd)
+        pass
 
-    @contextmanager
-    def report(self):
+    def run(self, deps, tools):
         """
-        Provide error analysis for task.
+        Executes subtasks defined in :func:`~generate`.
 
-        Intentionally undocumented. Use at own risk.
+        This method should typically not be overridden in subclasses.
         """
-        yield ReportProxy(self, self._report)
+        self.generate(deps, tools)
+
+        log.debug("About to start executing these subtasks:")
+        for subtask in self._subtasks:
+            for subtaskout in subtask.outputs:
+                if not subtask.dependencies:
+                    log.debug("  {}", subtaskout)
+                for dep in subtask.dependencies:
+                    for depout in dep.outputs:
+                        log.debug("  {}: {}", subtaskout, depout)
+
+        subtasks = {}
+        deps = {}
+
+        # Build graph of inverse dependencies
+        for subtask in self._subtasks:
+            if subtask not in subtasks:
+                subtasks[subtask] = []
+            if subtask not in deps:
+                deps[subtask] = []
+            for dep in subtask.dependencies:
+                if dep not in deps:
+                    deps[dep] = []
+                deps[dep].append(subtask)
+                subtasks[subtask].append(dep)
+
+        # Prune up-to-date subtasks
+        for subtask in list(filter(lambda subtask: not subtask.is_outdated, subtasks.keys())):
+            log.debug("Pruning {}", subtask)
+            del subtasks[subtask]
+            for dep in deps[subtask]:
+                try:
+                    subtasks[dep].remove(subtask)
+                except KeyError:
+                    pass
+
+        self.subtaskindex = 0
+        self.subtaskcount = len(subtasks)
+
+        lock = RLock()
+
+        with ThreadPoolExecutor(max_workers=tools.cpu_count()) as pool:
+            futures = {}
+
+            while subtasks or futures:
+                completed = []
+                candidates = [subtask for subtask, deps in subtasks.items() if not deps]
+
+                if not candidates and not futures:
+                    break
+
+                for subtask in candidates:
+                    del subtasks[subtask]
+                    if subtask.is_outdated:
+                        def runner(subtask):
+                            with lock:
+                                self.subtaskindex += 1
+                                log.info("[{}/{}] {}", self.subtaskindex, self.subtaskcount, str(subtask))
+                            subtask.run()
+                        futures[pool.submit(functools.partial(runner, subtask))] = subtask
+                    else:
+                        completed.append(subtask)
+
+                for future in as_completed(futures.keys()):
+                    subtask = futures[future]
+                    del futures[future]
+                    completed.append(subtask)
+
+                    try:
+                        future.result()
+                        subtask.set_uptodate()
+                    except Exception as e:
+                        for future in futures:
+                            future.cancel()
+                        raise e
+                    break
+
+                for subtask in completed:
+                    for dep in deps[subtask]:
+                        subtasks[dep].remove(subtask)
+
+            if subtasks:
+                log.debug("These remaining subtasks could not be started due to unresolved dependencies")
+                for subtask in subtasks:
+                    log.debug("  {}", str(subtask))
+                    for dep in subtask.dependencies:
+                        log.debug("   - {}", str(dep))
+
+            raise_task_error_if(subtasks, self, "Subtasks with unresolved dependencies could not be executed")
+
+    def inputs(self, jobs):
+        return self._to_subtask_list(jobs)
+
+    def outputs(self, jobs):
+        jobs = utils.as_list(jobs)
+        return [output for job in jobs for output in job.outputs]
+
+
+class Runner(Task):
+    """
+    A Runner task executes applications packaged by other tasks.
+
+    It is typically used to run test applications compiled and linked
+    by other tasks. The Runner finds the executable through the artifact
+    metadata string ``artifact.strings.executable`` which must be exported
+    by the consumed task artifact.
+
+    Example:
+
+      .. code-block:: python
+
+        from jolt import Runner, Task
+
+        class Exe(Task):
+            \"\"\" Publish a script printing 'Hello world' to stdout \"\"\"
+            def publish(self, artifact, tools):
+                with tools.cwd(tools.builddir()):
+                    # Create Hello world script
+                    tools.write_file("hello.sh", "#!/bin/sh\\necho Hello world")
+
+                    # Make it executable
+                    tools.chmod("hello.sh", 0o555)
+
+                    # Publish script in artifact
+                    artifact.collect("hello.sh")
+
+                    # Inform consuming Runner task about executable's name
+                    artifact.strings.executable = "hello.sh"
+
+        class Run(Runner):
+            \"\"\" Runs the 'Hello world' script \"\"\"
+            requires = ["exe"]
+
+    The Ninja CXXExecutable task class automatically sets the required artifact metadata.
+
+    Example:
+
+      .. code-block:: python
+
+        from jolt import Task
+        from jolt.plugins.ninja import CXXExecutable
+
+        class Exe(CXXExecutable):
+            \"\"\" Compiles and links the test application \"\"\"
+            sources = ["test.cpp"]
+
+        class Run(Runner):
+            \"\"\" Runs the test application \"\"\"
+            requires = ["exe"]
+
+    """
+
+    abstract = True
+
+    args = []
+    """
+    List of arguments to pass to executables.
+
+    The arguments are passed the same way to all executables if there
+    are multiple task requirements.
+    """
+
+    requires = []
+    """ List of tasks packaging executables to run. """
+
+    shell = True
+    """ Launch the executables through a shell. """
+
+    timeout = None
+    """ Time after which the executable will be terminated """
+
+    def run(self, deps, tools):
+        args = tools.expand(self.args)
+        timeout = int(self.timeout) if self.timeout is not None else None
+        found = False
+
+        for task, artifact in deps.items():
+            if not artifact.task.is_cacheable():
+                continue
+            if artifact.strings.executable is None:
+                self.verbose("No executable found in task artifact for '{}'", task)
+                continue
+            with tools.cwd(artifact.path):
+                found = True
+                exe = tools.expand_path(str(artifact.strings.executable))
+                exe = [exe] + args
+                exe = " ".join(exe) if self.shell else exe
+                tools.run(exe, shell=bool(self.shell), timeout=timeout)
+
+        raise_task_error_if(
+            not found, self,
+            "No executable found in any requirement artifact")
 
 
 class ErrorProxy(object):
     def __init__(self, error):
         self._error = error
 
+    @property
+    def type(self):
+        return self._error.type
+
+    @type.setter
+    def type(self, value):
+        self._error.type = value
+
+    @property
+    def details(self):
+        return self._error.details
+
+    @property
+    def location(self):
+        return self._error.location
+
+    @property
+    def message(self):
+        return self._error.message
+
 
 class ReportProxy(object):
     def __init__(self, task, report):
+        from jolt import config
         self._task = task
         self._report = report
+        self._max_errors = config.getint("jolt", "task_max_errors", 100)
 
     def add_error(self, type, location, message, details=""):
         """ Add an error to the build report. """
+        if len(self.errors) >= self._max_errors:
+            if not hasattr(self._report, "truncated"):
+                error = self._report.create_error()
+                error.type = "Error"
+                error.message = "Too many errors, list truncated"
+                self._report.truncated = True
+            return None
+
         error = self._report.create_error()
         error.type = type
         error.location = location
@@ -1284,13 +2732,10 @@ class ReportProxy(object):
          - details  - futher error details
 
         """
-        for match in re.finditer(regex, logbuf):
+        for match in re.finditer(regex, logbuf, re.MULTILINE):
             error = match.groupdict()
-            self.add_error(
-                type,
-                error.get("location", ""),
-                error.get("message", ""),
-                error.get("details", ""))
+            if not self.add_error(type, error.get("location", ""), error.get("message", ""), error.get("details", "")):
+                break
 
     def add_regex_errors_with_file(self, type, regex, logbuf, reldir, filterfn=lambda n: True):
         """
@@ -1306,25 +2751,34 @@ class ReportProxy(object):
         In case file is a relative path, reldir is the working directory.
         """
         errors_by_location = OrderedDict()
-        for match in re.finditer(regex, logbuf):
+        for match in re.finditer(regex, logbuf, re.MULTILINE):
             error = match.groupdict()
             if not filterfn(error):
                 continue
             if error["location"] not in errors_by_location:
-                errors_by_location[error["location"]] = (error, [error["message"]])
+                errors_by_location[error["location"]] = (error, [error["message"]], error.get("details", ""))
             else:
                 errors_by_location[error["location"]][1].append(error["message"])
 
-        for error, msgs in errors_by_location.values():
+        for error, msgs, details in errors_by_location.values():
             message = "\n".join(utils.unique_list(msgs))
-            with self._task.tools.cwd(reldir):
-                try:
-                    details = self._task.tools.read_file(error["file"])
-                    details = details.splitlines()
-                    details = str(error["line"]) + ": " + details[int(error["line"]) - 1]
-                except Exception:
-                    details = ""
-            self.add_error(type, error.get("location", ""), message, details)
+            if not details:
+                with self._task.tools.cwd(self._task.tools.wsroot):
+                    try:
+                        details = self._task.tools.read_file(error["file"])
+                        details = details.splitlines()
+                        details = str(error["line"]) + ": " + details[int(error["line"]) - 1]
+                    except Exception:
+                        details = ""
+
+            location = error.get("location", "")
+            if location:
+                with self._task.tools.cwd(self._task.tools.wsroot):
+                    location = self._task.tools.expand_path(location)
+                location = self._task.tools.expand_relpath(location, self._task.tools.wsroot)
+
+            if not self.add_error(type, location, message, details):
+                break
 
     def add_exception(self, exc, errtype=None, location=None):
         """
@@ -1338,13 +2792,14 @@ class ReportProxy(object):
 
         """
         tb = traceback.format_exception(type(exc), value=exc, tb=exc.__traceback__)
+
         installdir = fs.path.dirname(__file__)
         if any(map(lambda frame: installdir not in frame, tb[1:-1])):
             while len(tb) > 2 and installdir in tb[1]:
                 del tb[1]
-        loc = re.findall("\"(.*?\", line [0-9]+, in .*?)\n", tb[1])
+        loc = re.findall("(\".*?\", line [0-9]+, in .*?)\n", tb[1])
         location = location or (loc[0] if loc and len(loc) > 0 else "")
-        message = str(exc)
+        message = log.format_exception_msg(exc)
         if isinstance(exc, JoltCommandError):
             details = "\n".join(exc.stderr)
         elif isinstance(exc, JoltError):
@@ -1362,10 +2817,26 @@ class ReportProxy(object):
     def errors(self):
         return [ErrorProxy(error) for error in self._report.errors]
 
+    @errors.setter
+    def errors(self, errlist):
+        assert all(isinstance(err, ErrorProxy) for err in errlist), "Invalid error list"
+        self._report.clear_errors()
+        for err in errlist:
+            self.add_error(err.type, err.location, err.message, err.details)
+
     @property
     def manifest(self):
         return self._report
 
+    def raise_for_status(self, log_details=False, log_error=False):
+        for error in self.errors:
+            if log_error:
+                log.error("{}: {}", error.type, error.message, context=self._task.identity[:7])
+            if log_details:
+                for line in error.details.splitlines():
+                    log.transfer(line, context=self._task.identity[:7])
+            raise LoggedJoltError(JoltError(f"{error.type}: {error.message}"))
+
 
 class Resource(Task):
     """
@@ -1379,13 +2850,17 @@ class Resource(Task):
 
     """
 
-    cacheable = False
-
     abstract = True
     """ An abstract resource class indended to be subclassed. """
 
+    release_on_error = False
+    """ Call release if an exception occurs during acquire. """
+
     def __init__(self, *args, **kwargs):
-        super(Resource, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
+
+    def _artifacts(self, cache, node):
+        return [cache.get_artifact(node, "main", session=True)]
 
     def is_runnable(self):
         return False
@@ -1446,17 +2921,25 @@ class WorkspaceResource(Resource):
     """
 
     def __init__(self, *args, **kwargs):
-        super(WorkspaceResource, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         raise_task_error_if(len(self.requires) > 0, self,
                             "Workspace resource is not allowed to have requirements")
 
-    def acquire(self, **kwargs):
+    def acquire(self, *args, **kwargs):
         return self.acquire_ws()
 
-    def release(self, **kwargs):
+    def release(self, *args, **kwargs):
         return self.release_ws()
 
-    def acquire_ws(self):
+    def prepare_ws_for(self, task):
+        """ Called to prepare the workspace for a task.
+
+        An implementor overrides this method in a subclass. The method
+        is called before the task influence is calculated and the workspace
+        resource is acquired.
+        """
+
+    def acquire_ws(self, force=False):
         """ Called to acquire the resource.
 
         An implementor overrides this method in a subclass. The acquired
@@ -1471,6 +2954,61 @@ class WorkspaceResource(Resource):
         """
 
 
+@attributes.requires("_image")
+class Chroot(Resource):
+    """
+    Resource to use task artifact or directory path as chroot in consumers.
+
+    Example:
+
+      .. code-block:: python
+
+        from jolt import Chroot, Task
+        from jolt.plugins.podman import ContainerImage
+
+        class SdkImage(ContainerImage):
+            dockerfile = \"\"\"
+            FROM debian:sid-slim
+            ARG DEBIAN_FRONTEND=noninteractive
+            RUN apt-get update && apt-get install -y --no-install-recommends gcc g++ && apt-get clean
+            \"\"\"
+            output = "directory"
+
+        class Sdk(Chroot):
+            chroot = "sdkimage"
+
+        class Compile(Task):
+            requires = ["sdk"]
+
+            def run(self, deps, tools):
+                tools.run("gcc -v")
+
+    """
+    abstract = True
+
+    chroot = None
+    """ Task name or directory path to use as chroot """
+
+    @property
+    def _image(self):
+        registry = TaskRegistry.get()
+        if registry.get_task_class(self.expand(self.chroot)):
+            return [self.chroot]
+        return []
+
+    def acquire(self, artifact, deps, tools, owner):
+        try:
+            rootfs = deps[self.chroot]
+        except Exception:
+            rootfs = tools.expand(self.image)
+        self._context_stack = ExitStack()
+        self._context_stack.enter_context(
+            owner.tools.chroot(rootfs))
+
+    def release(self, artifact, deps, tools, owner):
+        self._context_stack.close()
+
+
 class Alias(Task):
     """
     An alias task.
@@ -1505,6 +3043,7 @@ class Download(Task):
     Once downloaded, archives are extracted and all of their files are published.
     If the file is not an archive it is published as is. Recognized archive extensions are:
 
+        - .7z
         - .tar
         - .tar.bz2
         - .tar.gz
@@ -1567,7 +3106,7 @@ class Download(Task):
         return fs.posixpath.basename(url.path) or "file"
 
     def run(self, deps, tools):
-        supported_formats = [".tar", ".tar.bz2", ".tar.gz", ".tar.xz", ".tgz", ".zip"]
+        supported_formats = [".7z", ".tar", ".tar.bz2", ".tar.gz", ".tar.xz", ".tgz", ".zip"]
 
         raise_task_error_if(not self.url, self, "No URL(s) specified")
 
@@ -1589,9 +3128,9 @@ class Download(Task):
     def publish(self, artifact, tools):
         with tools.cwd(self._extractdir):
             for files in self.collect:
-                if type(files) == tuple:
+                if type(files) is tuple:
                     artifact.collect(*files, symlinks=self.symlinks)
-                elif type(files) == dict:
+                elif type(files) is dict:
                     artifact.collect(**files, symlinks=self.symlinks)
                 else:
                     artifact.collect(files, symlinks=self.symlinks)
@@ -1664,7 +3203,8 @@ class Script(Task):
         doc = self.__doc__.split("---", 1)
         script = doc[1] if len(doc) > 1 else doc[0]
         script = script.splitlines()
-        script = [line[4:] for line in script]
+        if os_sys.version_info < (3, 13):
+            script = [line[4:] for line in script]
         script = "\n".join(script)
         script = script.lstrip()
         if not script.startswith("#!"):
@@ -1683,9 +3223,9 @@ class Script(Task):
     def publish(self, artifact, tools):
         with tools.cwd(self.builddir):
             for files in self.collect:
-                if type(files) == tuple:
+                if type(files) is tuple:
                     artifact.collect(*files)
-                elif type(files) == dict:
+                elif type(files) is dict:
                     artifact.collect(**files)
                 else:
                     artifact.collect(files)
@@ -1791,7 +3331,7 @@ class Test(Task):
     Abstract test tasks can't be executed and won't be listed.
     """
 
-    pattern = Parameter(required=False, help="Test-case filter wildcard.")
+    filter = Parameter(required=False, help="Test-case filter wildcard.")
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -1818,7 +3358,7 @@ class Test(Task):
                    self.assertEqual(factor1*factor2, product)
 
         """
-        raise_error_if(type(args) != list, "Test.parameterized() expects a list as argument")
+        raise_error_if(type(args) is not list, "Test.parameterized() expects a list as argument")
 
         class partialmethod(functools.partialmethod):
             def __init__(self, index, func, *args):
@@ -1946,7 +3486,7 @@ class Test(Task):
     def run(self, deps, tools):
         testsuite = ut.TestSuite()
         for test in self._get_test_names():
-            if self.pattern.is_unset() or fnmatch.fnmatch(test, str(self.pattern)):
+            if self.filter.is_unset() or fnmatch.fnmatch(test, str(self.filter)):
                 testfunc = getattr(self, test)
                 if not testfunc:
                     continue
@@ -1967,7 +3507,7 @@ class Test(Task):
 
 
 @ArtifactAttributeSetProvider.Register
-class ResourceAttributeSetProvider(ArtifactAttributeSetProvider):
+class WorkspaceResourceAttributeSetProvider(ArtifactAttributeSetProvider):
     def create(self, artifact):
         pass
 
@@ -1978,33 +3518,31 @@ class ResourceAttributeSetProvider(ArtifactAttributeSetProvider):
         pass
 
     def apply(self, task, artifact):
-        resource = artifact.get_task()
-        if isinstance(resource, Resource):
-            from inspect import signature
+        resource = artifact.task
+        node = artifact.get_node()
+        if not node.is_workspace_resource():
+            return
 
-            deps = resource._run_env
-            deps.__enter__()
-            sig = signature(resource.acquire)
-            try:
-                ba = sig.bind_partial(artifact=artifact, deps=deps, tools=resource.tools, owner=task)
-                acquire = resource.acquire
-            except Exception:
-                ba = sig.bind_partial(artifact, deps, resource.tools)
-                acquire = utils.deprecated(resource.acquire)
-            acquire(*ba.args, **ba.kwargs)
+        resource.deps = node.cache.get_context(node)
+        resource.deps.__enter__()
+
+        try:
+            resource.acquire(artifact=artifact, deps=resource.deps, tools=resource.tools, owner=task)
+        except (KeyboardInterrupt, Exception) as e:
+            if resource.release_on_error:
+                with utils.ignore_exception():
+                    self.unapply(task, artifact)
+            raise e
 
     def unapply(self, task, artifact):
-        resource = artifact.get_task()
-        if isinstance(resource, Resource):
-            from inspect import signature
+        resource = artifact.task
+        node = artifact.get_node()
+        if not node.is_workspace_resource():
+            return
 
-            deps = resource._run_env
-            sig = signature(resource.release)
-            try:
-                ba = sig.bind_partial(artifact=artifact, deps=deps, tools=resource.tools, owner=task)
-                release = resource.release
-            except Exception:
-                ba = sig.bind_partial(artifact, deps, resource.tools)
-                release = utils.deprecated(resource.release)
-            release(*ba.args, **ba.kwargs)
-            deps.__exit__(None, None, None)
+        try:
+            resource.release(artifact=artifact, deps=resource.deps, tools=resource.tools, owner=task)
+        except Exception as e:
+            raise e
+
+        resource.deps.__exit__(None, None, None)