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

jolt/tasks.py

@@ -10,6 +10,7 @@ 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
@@ -20,6 +21,7 @@ import traceback
 from jolt import filesystem as fs
 from jolt import log
 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, LoggedJoltError
@@ -135,7 +137,7 @@ class Parameter(object):
         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.
 
@@ -143,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
@@ -164,6 +170,7 @@ class Parameter(object):
         self._default = default
         self._value = default
         self._accepted_values = values
+        self._accepted_values_fn = valuesfn
         self._required = required
         self._const = const
         self._influence = influence
@@ -190,7 +197,7 @@ class Parameter(object):
         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 """
@@ -199,6 +206,8 @@ class Parameter(object):
     def _validate(self, value, what=None):
         if self._accepted_values is not None and value not in self._accepted_values:
             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.
@@ -436,7 +445,7 @@ class IntParameter(Parameter):
     """
 
     def __init__(self, default=None, min=None, max=None, values=None, required=True, const=False,
-                 influence=True, help=None):
+                 influence=True, help=None, valuesfn=None):
         """
         Creates a new parameter.
 
@@ -484,7 +493,8 @@ class IntParameter(Parameter):
             required=required,
             const=const,
             influence=influence,
-            help=help)
+            help=help,
+            valuesfn=valuesfn)
 
     def _validate(self, value, what=None):
         if self._min is not None and value < self._min:
@@ -688,6 +698,10 @@ class ListParameter(Parameter):
             for item in value:
                 if item not in self._accepted_values:
                     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)
@@ -769,6 +783,7 @@ class TaskRegistry(object):
         self.env = env
         self.tasks = {}
         self.instances = {}
+        self._workspace_resources = []
 
     @staticmethod
     def get(*args, **kwargs):
@@ -777,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):
@@ -785,6 +815,13 @@ 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)
 
@@ -811,6 +848,10 @@ class TaskRegistry(object):
 
         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)
 
@@ -882,6 +923,14 @@ class TaskGenerator(object):
 
 
 class attributes:
+    @staticmethod
+    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.
@@ -1167,6 +1216,65 @@ class attributes:
             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):
         """
@@ -2648,7 +2756,7 @@ class ReportProxy(object):
             if not filterfn(error):
                 continue
             if error["location"] not in errors_by_location:
-                errors_by_location[error["location"]] = (error, [error["message"]], error["details"])
+                errors_by_location[error["location"]] = (error, [error["message"]], error.get("details", ""))
             else:
                 errors_by_location[error["location"]][1].append(error["message"])
 
@@ -2935,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
@@ -2997,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")
 
@@ -3094,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("#!"):
@@ -3394,3 +3504,45 @@ class Test(Task):
             "{} tests out of {} were successful".format(
                 len(self.testresult.successes),
                 self.testresult.testsRun))
+
+
+@ArtifactAttributeSetProvider.Register
+class WorkspaceResourceAttributeSetProvider(ArtifactAttributeSetProvider):
+    def create(self, artifact):
+        pass
+
+    def parse(self, artifact, content):
+        pass
+
+    def format(self, artifact, content):
+        pass
+
+    def apply(self, task, artifact):
+        resource = artifact.task
+        node = artifact.get_node()
+        if not node.is_workspace_resource():
+            return
+
+        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.task
+        node = artifact.get_node()
+        if not node.is_workspace_resource():
+            return
+
+        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)

jolt/tools.py

@@ -1,3 +1,4 @@
+import py7zr
 import bz2
 import copy
 import getpass
@@ -42,6 +43,9 @@ from jolt.error import raise_error_if
 from jolt.error import raise_task_error, raise_task_error_if
 
 
+SUPPORTED_ARCHIVE_TYPES = [".tar", ".tar.bz2", ".tar.gz", ".tgz", ".tar.xz", ".tar.zst", ".zip"]
+
+
 http_session = Session()
 
 
@@ -83,11 +87,13 @@ class Reader(threading.Thread):
             self.logbuf.append((self, line))
 
 
-def _run(cmd, cwd, env, preexec_fn, *args, **kwargs):
+def _run(cmd, cwd, env, *args, **kwargs):
     output = kwargs.get("output")
     output_on_error = kwargs.get("output_on_error")
     output_rstrip = kwargs.get("output_rstrip", True)
     output_stdio = kwargs.get("output_stdio", False)
+    output_stderr = kwargs.get("output_stderr", True)
+    output_stdout = kwargs.get("output_stdout", True)
     return_stderr = kwargs.get("return_stderr", False)
     output = output if output is not None else True
     output = False if output_on_error else output
@@ -130,11 +136,17 @@ def _run(cmd, cwd, env, preexec_fn, *args, **kwargs):
                 shell=shell,
                 cwd=cwd,
                 env=env,
-                preexec_fn=preexec_fn,
             )
 
-            stdout_func = log.stdout if not output_stdio else stdout_write
-            stderr_func = log.stderr if not output_stdio else stderr_write
+            if output_stdout:
+                stdout_func = log.stdout if not output_stdio else stdout_write
+            else:
+                stdout_func = None
+
+            if output_stderr:
+                stderr_func = log.stderr if not output_stdio else stderr_write
+            else:
+                stderr_func = None
 
             logbuf = []
             stdout = Reader(
@@ -160,7 +172,7 @@ def _run(cmd, cwd, env, preexec_fn, *args, **kwargs):
             p.wait(10)
         except subprocess.TimeoutExpired:
             kill(p.pid)
-            p.wait()
+            utils.call_and_catch(p.wait, 10)
         raise
 
     except (subprocess.TimeoutExpired, JoltTimeoutError):
@@ -170,7 +182,7 @@ def _run(cmd, cwd, env, preexec_fn, *args, **kwargs):
             p.wait(10)
         except subprocess.TimeoutExpired:
             kill(p.pid)
-            p.wait()
+            utils.call_and_catch(p.wait, 10)
 
     finally:
         if stdout:
@@ -249,6 +261,10 @@ class _CMake(object):
         self.builddir = self.tools.builddir(incremental=incremental)
         self.installdir = self.tools.builddir("install", incremental=False)
 
+    def clean(self):
+        self.tools.rmtree(self.builddir, ignore_errors=True)
+        self.tools.rmtree(self.installdir, ignore_errors=True)
+
     def configure(self, sourcedir, *args, generator=None, **kwargs):
         sourcedir = self.tools.expand_path(sourcedir)
 
@@ -259,74 +275,85 @@ class _CMake(object):
 
         with self.tools.cwd(self.builddir):
             self.tools.run(
-                "cmake {0} -B{1} -DCMAKE_INSTALL_PREFIX={2} {3} {4}",
+                "cmake {0} {1} -DCMAKE_INSTALL_PREFIX=/jolt-prefix {1} {2} {3}",
                 sourcedir,
-                self.builddir,
-                self.installdir,
+                utils.option("-B", self.builddir),
                 utils.option("-G", generator),
                 extra_args,
                 output=True)
 
-    def build(self, release=True, *args, **kwargs):
+    def build(self, *args, config="Release", **kwargs):
         threading_args = ' -j {}'.format(kwargs.get("threads", self.tools.thread_count()))
         with self.tools.cwd(self.builddir):
-            release = "--config Release" if release else ""
-            self.tools.run("cmake --build . {0}{1}", release, threading_args, output=True)
+            self.tools.run("cmake --build . --config {0} {1}", config, threading_args, output=True)
 
-    def install(self, release=True, *args, **kwargs):
-        with self.tools.cwd(self.builddir):
-            release = "--config Release" if release else ""
-            self.tools.run("cmake --build . --target install {0}", release, output=True)
+    def install(self, target="install", config="Release", **kwargs):
+        with self.tools.cwd(self.builddir), self.tools.environ(DESTDIR=self.installdir):
+            self.tools.run("cmake --build . --config {0} --target {1}", config, target, output=True)
 
-    def publish(self, artifact, files='*', *args, **kwargs):
-        with self.tools.cwd(self.installdir):
-            artifact.collect(files, *args, **kwargs)
+    def publish(self, artifact, files='*', symlinks=True, *args, **kwargs):
+        with self.tools.cwd(self.installdir, "jolt-prefix"):
+            artifact.collect(files, *args, symlinks=symlinks, **kwargs)
+        artifact.strings.install_prefix = "/jolt-prefix"
 
 
 class _Meson(object):
-    def __init__(self, deps, tools):
+    def __init__(self, deps, tools, incremental=False):
         self.deps = deps
         self.tools = tools
-        self.builddir = self.tools.builddir()
-        self.installdir = self.tools.builddir("install")
+        self.builddir = self.tools.builddir(incremental=incremental)
+        self.installdir = self.tools.builddir("install", incremental=False)
+        self.prefix = "/jolt-prefix" if os.name != "nt" else "C:\\jolt-prefix"
+
+    def clean(self):
+        self.tools.rmtree(self.builddir, ignore_errors=True)
+        self.tools.rmtree(self.installdir, ignore_errors=True)
 
     def configure(self, sourcedir, *args, **kwargs):
         sourcedir = self.tools.expand_path(sourcedir)
-        self.tools.run("meson --prefix=/ {0} {1}", sourcedir, self.builddir,
+        options = " ".join([f"-D{arg}" for arg in args]) + " "
+        options += " ".join(["-D{0}={1}".format(key, self.tools.expand(val)) for key, val in kwargs.items()])
+        self.tools.run("meson setup --prefix={0} {1} {2} {3}", self.prefix, sourcedir, self.builddir, options,
                        output=True)
 
     def build(self, *args, **kwargs):
         self.tools.run("ninja -C {0} ", self.builddir, output=True)
 
     def install(self, *args, **kwargs):
-        self.tools.run("DESTDIR={0} ninja -C {1} install",
-                       self.installdir, self.builddir,
-                       output=True)
+        with self.tools.environ(DESTDIR=self.installdir):
+            self.tools.run("ninja -C {0} install", self.builddir, output=True)
 
-    def publish(self, artifact, files='*', *args, **kwargs):
-        with self.tools.cwd(self.installdir):
-            artifact.collect(files, *args, **kwargs)
+    def publish(self, artifact, files='*', symlinks=True, *args, **kwargs):
+        with self.tools.cwd(self.installdir, "jolt-prefix"):
+            artifact.collect(files, *args, symlinks=symlinks, **kwargs)
+        artifact.strings.install_prefix = self.prefix
 
 
 class _AutoTools(object):
-    def __init__(self, deps, tools):
+    def __init__(self, deps, tools, incremental=False):
         self.deps = deps
         self.tools = tools
-        self.builddir = self.tools.builddir()
-        self.installdir = self.tools.builddir("install")
+        self.builddir = self.tools.builddir(incremental=incremental)
+        self.installdir = self.tools.builddir("install", incremental=False)
+        self.prefix = "jolt-prefix"
 
-    def configure(self, sourcedir, *args, **kwargs):
+    def clean(self):
+        self.tools.rmtree(self.builddir, ignore_errors=True)
+        self.tools.rmtree(self.installdir, ignore_errors=True)
+
+    def configure(self, sourcedir, *args):
         sourcedir = self.tools.expand_path(sourcedir)
-        prefix = kwargs.get("prefix", "/")
 
         if not fs.path.exists(fs.path.join(sourcedir, "configure")):
             with self.tools.cwd(sourcedir):
                 self.tools.run("autoreconf -visf", output=True)
 
         with self.tools.cwd(self.builddir), self.tools.environ(DESTDIR=self.installdir):
-            self.tools.run("{0}/configure --prefix={1} {2}",
-                           sourcedir, prefix,
+            self.tools.run("{0}/configure --prefix=/{1} {2} {3}",
+                           sourcedir,
+                           self.prefix,
                            self.tools.getenv("CONFIGURE_FLAGS", ""),
+                           " ".join(args),
                            output=True)
 
     def build(self, *args, **kwargs):
@@ -334,13 +361,14 @@ class _AutoTools(object):
             self.tools.run("make VERBOSE=yes Q= V=1 -j{0}",
                            self.tools.cpu_count(), output=True)
 
-    def install(self, target="install", **kwargs):
-        with self.tools.cwd(self.builddir), self.tools.environ(DESTDIR=self.installdir):
-            self.tools.run("make {}", target, output=True)
+    def install(self, target="install"):
+        with self.tools.cwd(self.builddir):
+            self.tools.run("make DESTDIR={} {}", self.installdir, target, output=True)
 
-    def publish(self, artifact, files='*', *args, **kwargs):
-        with self.tools.cwd(self.installdir):
-            artifact.collect(files, *args, **kwargs)
+    def publish(self, artifact, files='*', symlinks=True, *args, **kwargs):
+        with self.tools.cwd(self.installdir, self.prefix):
+            artifact.collect(files, *args, symlinks=symlinks, **kwargs)
+        artifact.strings.install_prefix = "/" + self.prefix
 
 
 class ZipFile(zipfile.ZipFile):
@@ -471,7 +499,6 @@ class Tools(object):
         self._chroot_path = []
         self._deadline = None
         self._run_prefix = []
-        self._preexec_fn = None
         self._cwd = fs.path.normpath(fs.path.join(config.get_workdir(), cwd or config.get_workdir()))
         self._env = copy.deepcopy(env or os.environ)
         self._task = task
@@ -520,6 +547,12 @@ class Tools(object):
                         zf.write(path, zippath)
         return filename
 
+    def _make_7zfile(self, filename, fmt, rootdir):
+        self.mkdirname(filename)
+        with py7zr.SevenZipFile(filename, 'w') as archive:
+            archive.writeall(rootdir, ".")
+        return filename
+
     def _make_tarfile(self, filename, fmt, rootdir):
         self.mkdirname(filename)
         with tarfile.open(filename, 'w|%s' % fmt) as tar:
@@ -552,6 +585,7 @@ class Tools(object):
         The type of archive to create is determined by the filename extension.
         Supported formats are:
 
+        - 7z
         - tar
         - tar.bz2
         - tar.gz
@@ -587,12 +621,16 @@ class Tools(object):
             fmt = "tarbz2"
         elif filename.endswith(".tar.xz"):
             fmt = "tarxz"
+        elif filename.endswith(".7z"):
+            fmt = "7z"
         raise_task_error_if(
             not fmt, self._task,
             "unknown archive type '{0}'", fs.path.basename(filename))
         try:
             if fmt == "zip":
                 outfile = self._make_zipfile(filename, fmt, rootdir=pathname)
+            elif fmt == "7z":
+                outfile = self._make_7zfile(filename, fmt, rootdir=pathname)
             else:
                 outfile = self._make_tarfile(filename, fmt[3:], rootdir=pathname)
             if outfile != filename:
@@ -601,9 +639,9 @@ class Tools(object):
         except Exception:
             raise_task_error(self._task, "failed to create archive from directory '{0}'", pathname)
 
-    def autotools(self, deps=None):
+    def autotools(self, deps=None, incremental=False):
         """ Creates an AutoTools invokation helper """
-        return _AutoTools(deps, self)
+        return _AutoTools(deps, self, incremental=incremental)
 
     @utils.locked(lock='_builddir_lock')
     def builddir(self, name=None, incremental=False, unique=True):
@@ -888,7 +926,7 @@ class Tools(object):
                         pbar.update(len(data))
                 actual_size = self.file_size(pathname)
                 raise_error_if(
-                    size != 0 and size != actual_size,
+                    size != 0 and size > actual_size,
                     f"Downloaded file was truncated to {actual_size}/{size} bytes: {name}")
 
             return response.status_code == 200
@@ -1047,6 +1085,7 @@ class Tools(object):
 
         Supported formats are:
 
+        - 7z
         - tar
         - tar.bz2
         - tar.gz
@@ -1110,6 +1149,13 @@ class Tools(object):
                     self._extract_tarzstd(filename, filepath, files)
                 except tarfile.StreamError as e:
                     raise_task_error(self._task, "failed to extract archive '{0}': {1}", filename, str(e))
+            elif filename.endswith(".7z"):
+                with py7zr.SevenZipFile(filename, 'r') as archive:
+                    if files:
+                        for file in files:
+                            archive.extract(file, filepath)
+                    else:
+                        archive.extractall(filepath)
             else:
                 raise_task_error(self._task, "unknown archive type '{0}'", fs.path.basename(filename))
         except Exception:
@@ -1261,9 +1307,9 @@ class Tools(object):
         """
         return utils.map_concurrent(callable, iterable, max_workers)
 
-    def meson(self, deps=None):
+    def meson(self, deps=None, incremental=False):
         """ Creates a Meson invokation helper """
-        return _Meson(deps, self)
+        return _Meson(deps, self, incremental=incremental)
 
     @contextmanager
     def nixpkgs(self, nixfile=None, packages=None, pure=False, path=None, options=None):
@@ -1539,6 +1585,9 @@ class Tools(object):
                 refuses to terminate, it will be killed after an additional
                 10 seconds have passed. Default: None.
 
+        Returns:
+           str: stdout from command unless output=False
+
         Example:
 
             .. code-block:: python
@@ -1578,7 +1627,7 @@ class Tools(object):
             except Exception:
                 pass
 
-            return _run(cmd, self._cwd, self._env, self._preexec_fn, *args, **kwargs)
+            return _run(cmd, self._cwd, self._env, *args, **kwargs)
 
         finally:
             if stdi:
@@ -1692,11 +1741,15 @@ class Tools(object):
             fs.makedirs(path)
             for relsrcpath, reldstpath in artifact.files.items():
                 srcpath = fs.path.normpath(fs.path.join(artifact.task.joltdir, relsrcpath))
+                srcpath = self.expand_path(srcpath)
                 dstpath = fs.path.normpath(fs.path.join(path, reldstpath))
+                dstpath = self.expand_path(dstpath)
+
                 if dstpath != fs.path.realpath(dstpath):
                     log.debug("Cannot symlink '{} -> {}', parent directory already symlinked",
                               srcpath, dstpath)
                     continue
+
                 if fs.path.isdir(dstpath):
                     files = fs.scandir(srcpath)
                     for file in files:
@@ -1706,7 +1759,8 @@ class Tools(object):
                     self.symlink(srcpath, dstpath)
 
                 # Restore missing srcfiles if they resided in a build directory
-                if srcpath.startswith(artifact.tools.buildroot) and \
+                buildroot_abs = self.expand_path(artifact.tools.buildroot)
+                if srcpath.startswith(buildroot_abs) and \
                    not fs.path.exists(srcpath):
                     fs.copy(fs.path.join(artifact.path, reldstpath), srcpath, symlinks=True)
             self.write_file(meta, artifact.path)
@@ -1865,7 +1919,7 @@ class Tools(object):
 
         if type(chroot) in [cache.Artifact, cache.ArtifactToolsProxy]:
             raise_task_error_if(
-                not str(chroot.paths.rootfs), self._task,
+                not chroot.paths.rootfs, self._task,
                 "No 'rootfs' path in artifact")
             chroot = chroot.paths.rootfs