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

jolt/plugins/cache.py

@@ -85,7 +85,7 @@ class Cache(cache.StorageProvider):
         except ConnectTimeout:
             self._disabled = True
             log.warning(NAME_LOG + " failed to establish server connection, disabled")
-            return []
+            return [], []
 
         if response.status_code != 200:
             log.debug(NAME_LOG + " POST ({}): {}", response.status_code, self._file_uri)

jolt/plugins/cmake.py

@@ -1,3 +1,4 @@
+from jolt import attributes
 from jolt import influence
 from jolt import Task
 from jolt import utils
@@ -6,31 +7,98 @@ from jolt.error import raise_task_error_if
 import os
 
 
+def options(attrib):
+    """
+    Decorates a CMake task with an alternative ``options`` attribute.
+
+    The new attribute will be concatenated with the regular
+    ``options`` attribute.
+
+    Args:
+        attrib (str): Name of alternative attribute.
+            Keywords are expanded.
+    """
+    return utils.concat_attributes("options", attrib)
+
+
+def requires(version=None):
+    """ Decorator to add CMake requirements to a task. """
+
+    import jolt.pkgs.cmake
+
+    def decorate(cls):
+        cls = attributes.requires("requires_cmake")(cls)
+        cls.requires_cmake = ["cmake" + (f":version={version}" if version else "")]
+        return cls
+
+    return decorate
+
+
+def use_ninja():
+    """
+    Decorator to add Ninja dependencies to CMake task.
+
+    It also selects Ninja as the CMake generator and builder.
+    """
+
+    import jolt.pkgs.ninja
+
+    def decorate(cls):
+        cls = attributes.requires("requires_ninja")(cls)
+        cls.generator = "Ninja"
+        cls.requires_ninja = ["ninja"]
+        return cls
+
+    return decorate
+
+
+@attributes.common_metadata()
+@options("options")
 class CMake(Task):
     """ Builds and publishes a CMake project """
-
     abstract = True
 
     cmakelists = "CMakeLists.txt"
     """ Path to CMakeLists.txt or directory containing CMakelists.txt """
 
+    config = "Release"
+    """ The default build configuration to use """
+
     generator = None
+    """ The build file generator that CMake should use """
 
     incremental = True
+    """ Keep build directories between Jolt invocations """
 
     options = []
     """ List of options and their values (``option[:type]=value``) """
 
+    srcdir = None
+    """ Source directory. If not specified, the task working directory is used. """
+
+    install = ["install"]
+    """ List of install build targets. If empty, the default install target is used. """
+
+    def clean(self, tools):
+        cmake = tools.cmake(incremental=self.incremental)
+        cmake.clean()
+
     def run(self, deps, tools):
+        self.deps = deps
         raise_task_error_if(not self.cmakelists, self, "cmakelists attribute has not been defined")
 
-        cmake = tools.cmake(incremental=self.incremental)
-        cmake.configure(tools.expand(self.cmakelists), *["-D" + tools.expand(option) for option in self.options], generator=self.generator)
-        cmake.build()
-        cmake.install()
+        config = tools.expand(str(self.config))
+        options = self._options()
+        options += ["CMAKE_BUILD_TYPE=" + config]
+
+        with tools.cwd(self.srcdir or self.joltdir):
+            cmake = tools.cmake(deps, incremental=self.incremental)
+            cmake.configure(tools.expand(self.cmakelists), *["-D" + tools.expand(option) for option in options], generator=self.generator)
+            for target in self.install or ["install"]:
+                cmake.install(config=config, target=target)
 
     def publish(self, artifact, tools):
-        cmake = tools.cmake()
+        cmake = tools.cmake(incremental=self.incremental)
         cmake.publish(artifact)
 
 

jolt/plugins/conan.py

@@ -3,6 +3,7 @@ from os import path
 
 from jolt import Task
 from jolt import influence
+from jolt import utils
 from jolt.error import raise_task_error_if
 
 
@@ -239,3 +240,240 @@ class Conan(Task):
             artifact.cxxinfo.cflags.append(dep["cflags"])
             artifact.cxxinfo.cxxflags.append(dep["cxxflags"])
             artifact.cxxinfo.ldflags.append(dep["exelinkflags"])
+
+
+@influence.attribute("conanfile")
+@influence.attribute("generators")
+@influence.attribute("incremental")
+@influence.attribute("options")
+@influence.attribute("packages")
+class Conan2(Task):
+    """
+    Conan package installer task.
+
+    This task base class can be used to fetch, build and publish Conan packages
+    as Jolt artifacts. All package metadata is transfered from the Conan package
+    manifest to the Jolt artifact so that no manual configuration of include
+    paths, library paths, macros, etc is required.
+
+    An existing installation of Conan is required. Please visit https://conan.io/
+    for installation instructions and documentation.
+
+    A minimal task to download and publish the Boost C++ libraries can look like this:
+
+    .. code-block:: python
+
+        from jolt.plugins.conan import Conan
+
+        class Boost(Conan):
+            packages = ["boost/1.74.0"]
+
+    Boost may then be used from Ninja tasks by declaring a requirement:
+
+    .. code-block:: python
+
+        from jolt.plugins.ninja import CXXExecutable
+
+        class BoostApplication(CXXExecutable):
+            requires = ["boost"]
+            sources = ["main.cpp"]
+
+    The task supports using an existing conanfile.txt, but it is not required.
+    Packages are installed into and collected from Jolt build directories. The
+    user's regular Conan cache will not be affected.
+
+    """
+
+    abstract = True
+
+    conanfile = None
+    """
+    An existing conanfile.txt file to use.
+
+    Instead of generating the conanfile.txt file on-demand, an external
+    file may be used. If this attribute is set, the ``generators``, ``options``
+    and ``packages`` attributes must not be set.
+
+    See Conan documentation for further details.
+    """
+
+    packages = []
+    """
+    A list of Conan package references to collect and publish.
+
+    The reference format is ``PkgName/<version>@user/channel``. See Conan
+    documentation for further details.
+
+    Any {keyword} arguments, or macros, found in the strings are automatically
+    expanded to the value of the associated task's parameters and properties.
+
+    Example:
+
+    .. code-block:: python
+
+        sdl_version = Parameter("2.0.12")
+
+        packages = [
+            "boost/1.74.0",
+            "sdl2/{sdl_version}@bincrafters/stable",
+        ]
+
+    """
+
+    options = []
+    """
+    A list of Conan package options to apply
+
+    The option format is ``PkgName:Option=Value``. See Conan
+    documentation for further details.
+
+    Any {keyword} arguments, or macros, found in the strings are automatically
+    expanded to the value of the associated task's parameters and properties.
+
+    Example:
+
+    .. code-block:: python
+
+        options = [
+            "boost:shared=True",
+            "zlib:shared=True",
+        ]
+
+    """
+
+    settings = []
+    """
+    A list of Conan settings to apply
+
+    The settings format is ``Option=Value``. See Conan
+    documentation for further details.
+
+    Any {keyword} arguments, or macros, found in the strings are automatically
+    expanded to the value of the associated task's parameters and properties.
+
+    Example:
+
+    .. code-block:: python
+
+        settings = [
+            "compiler.libcxx=libstdc++11",
+        ]
+
+    """
+
+    remotes = {}
+    """
+    A dictionary with Conan remotes to use when fetching packages.
+
+    The dictionary key is the name of remote and its value is the URL.
+
+    Example:
+
+    .. code-block:: python
+
+        remotes = {
+            "bincrafters": "https://api.bintray.com/conan/bincrafters/public-conan"
+        }
+
+    """
+
+    incremental = True
+    """
+    Keep installed packages in the Conan cache between Jolt invokations.
+
+    If incremental build is disabled, the Jolt Conan cache is removed
+    before execution begins.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.conanfile:
+            self.influence.append(influence.FileInfluence(self.conanfile))
+
+    def _options(self):
+        return [] + self.options
+
+    def _settings(self):
+        return [] + self.settings
+
+    def _packages(self):
+        return [] + self.packages
+
+    def _remotes(self):
+        return self.remotes
+
+    def run(self, deps, tools):
+        raise_task_error_if(
+            not tools.which("conan"), self,
+            "Conan: Conan is not installed in the PATH")
+        raise_task_error_if(
+            self.conanfile and (self._packages() or self._options()), self,
+            "Conan: 'conanfile' attribute cannot be used with other attributes")
+
+        conanfile = tools.expand_path(self.conanfile) if self.conanfile else None
+
+        with tools.cwd(tools.builddir()):
+            if conanfile is None or not path.exists(conanfile):
+                conanfile = "conanfile.txt"
+                self.info("Creating conanfile.txt")
+                self.tools.write_file(conanfile, "[requires]\n")
+                for pkg in self._packages():
+                    self.tools.append_file(conanfile, pkg + "\n")
+
+            with tools.environ(CONAN_USER_HOME=tools.builddir("conan", incremental=self.incremental)):
+                for remote, url in self._remotes().items():
+                    self.info("Registering remote '{}'", remote)
+                    tools.run("conan remote add -f {} {}", remote, url, output_on_error=True)
+
+                self.info("Installing packages into the Conan cache")
+                options = " ".join(["-o " + opt for opt in self._options()])
+                settings = " ".join(["-s " + opt for opt in self._settings()])
+                output = tools.run("conan install --build=missing --output-folder . -u --format=json {} {} {}", options, settings, conanfile, output_stdout=False)
+
+            self.info("Parsing manifest")
+            self._manifest = json.loads(output)
+
+            for dep in self._manifest["graph"]["nodes"].values():
+                if dep["package_folder"]:
+                    self.info("Collecting '{}' files from: {}", dep["name"], dep["package_folder"])
+                    tools.copy(dep["package_folder"], dep["name"])
+
+    def publish(self, artifact, tools):
+        self.info("Publishing package files")
+        with tools.cwd(tools.builddir()):
+            artifact.collect("*")
+
+        self.info("Publishing metadata")
+        for dep in self._manifest["graph"]["nodes"].values():
+            if not dep["package_folder"]:
+                continue
+
+            for node in dep["cpp_info"]:
+                for incpath in dep["cpp_info"][node]["includedirs"]:
+                    artifact.cxxinfo.incpaths.append(path.join(dep["name"], path.relpath(incpath, dep["package_folder"])))
+                for libpath in dep["cpp_info"][node]["libdirs"]:
+                    artifact.cxxinfo.libpaths.append(path.join(dep["name"], path.relpath(libpath, dep["package_folder"])))
+                for binpath in dep["cpp_info"][node]["bindirs"]:
+                    artifact.environ.PATH.append(path.join(dep["name"], path.relpath(binpath, dep["package_folder"])))
+                if dep["cpp_info"][node]["libs"]:
+                    artifact.cxxinfo.libraries.extend(dep["cpp_info"][node]["libs"])
+                if dep["cpp_info"][node]["system_libs"]:
+                    artifact.cxxinfo.libraries.extend(dep["cpp_info"][node]["system_libs"])
+                if dep["cpp_info"][node]["defines"]:
+                    artifact.cxxinfo.macros.extend(dep["cpp_info"][node]["defines"])
+                if dep["cpp_info"][node]["cflags"]:
+                    artifact.cxxinfo.cflags.extend(dep["cpp_info"][node]["cflags"])
+                if dep["cpp_info"][node]["cxxflags"]:
+                    artifact.cxxinfo.cxxflags.extend(dep["cpp_info"][node]["cxxflags"])
+                if dep["cpp_info"][node]["exelinkflags"]:
+                    artifact.cxxinfo.ldflags.extend(dep["cpp_info"][node]["exelinkflags"])
+
+        # Make list of unique values
+        artifact.cxxinfo.incpaths = utils.unique_list(artifact.cxxinfo.incpaths)
+        artifact.cxxinfo.libpaths = utils.unique_list(artifact.cxxinfo.libpaths)
+        artifact.cxxinfo.libraries = utils.unique_list(artifact.cxxinfo.libraries)
+        artifact.cxxinfo.macros = utils.unique_list(artifact.cxxinfo.macros)
+        artifact.cxxinfo.cflags = utils.unique_list(artifact.cxxinfo.cflags)
+        artifact.cxxinfo.cxxflags = utils.unique_list(artifact.cxxinfo.cxxflags)
+        artifact.cxxinfo.ldflags = utils.unique_list(artifact.cxxinfo.ldflags)
+        artifact.environ.PATH = path.pathsep.join(utils.unique_list(str(artifact.environ.PATH).split(path.pathsep)))

jolt/plugins/cxxinfo.py

@@ -1,4 +1,5 @@
 from jolt.cache import ArtifactListAttribute
+from jolt.cache import ArtifactStringAttribute
 from jolt.cache import ArtifactAttributeSet
 from jolt.cache import ArtifactAttributeSetProvider
 
@@ -7,6 +8,10 @@ class CppInfoListVariable(ArtifactListAttribute):
     pass
 
 
+class CppInfoStringVariable(ArtifactStringAttribute):
+    pass
+
+
 class CppInfoDictVariable(ArtifactListAttribute):
     def __init__(self, artifact, name):
         super(CppInfoDictVariable, self).__init__(artifact, name)
@@ -26,6 +31,8 @@ class CppInfo(ArtifactAttributeSet):
             return CppInfoListVariable(self._artifact, "asflags")
         if name == "cflags":
             return CppInfoListVariable(self._artifact, "cflags")
+        if name == "msvcrt":
+            return CppInfoStringVariable(self._artifact, "msvcrt")
         if name == "cxxflags":
             return CppInfoListVariable(self._artifact, "cxxflags")
         if name == "incpaths":

jolt/plugins/docker.py

@@ -25,8 +25,6 @@ class DockerListVariable(ArtifactListAttribute):
 
 class DockerLoadListVariable(DockerListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run(
                 "docker load -i {}",
@@ -35,16 +33,12 @@ class DockerLoadListVariable(DockerListVariable):
 
 class DockerPullListVariable(DockerListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run("docker pull {}", image, output_on_error=True)
 
 
 class DockerRmiListVariable(DockerListVariable):
     def unapply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run("docker rmi -f {}", image, output_on_error=True)
 
@@ -109,8 +103,8 @@ class DockerClient(Download):
     url = "https://download.docker.com/{host}/static/stable/{arch}/docker-{version}.tgz"
     """ URL of binaries """
 
-    version = Parameter("20.10.13", help="Docker version")
-    """ Docker version [20.10.13] """
+    version = Parameter("27.4.1", help="Docker version")
+    """ Docker version [27.4.1] """
 
     def publish(self, artifact, tools):
         super().publish(artifact, tools)
@@ -173,6 +167,40 @@ class DockerContainer(Resource):
     Alternatively, assign ``True`` to publish all exposed ports to random ports.
     """
 
+    release_on_error = True
+    """ Stop and remove container on error to avoid resource leaks. """
+
+    security_opts = []
+    """
+    A list of security options.
+
+    By default, the container is started with the default security profile.
+
+    Example:
+
+    .. code-block:: python
+
+        security_opts = [
+            "seccomp:unconfined",
+        ]
+
+    """
+
+    stop_timeout = 10
+    """ Timeout in seconds for stopping the container .
+
+    When stopping the container, the task will wait for the container to stop
+    for the specified number of seconds before forcefully killing it.
+
+    Default: 10 seconds.
+    """
+
+    stop_signal = "SIGTERM"
+    """ Signal to send to the container when stopping it.
+
+    Default: ``SIGTERM``.
+    """
+
     volumes = []
     """
     A list of volumes to mount.
@@ -199,6 +227,9 @@ class DockerContainer(Resource):
     Defaults to the current user.
     """
 
+    workdir = None
+    """ The container working directory. """
+
     @property
     def _arguments(self):
         return " ".join(self.arguments)
@@ -223,7 +254,7 @@ class DockerContainer(Resource):
     def _image(self):
         registry = TaskRegistry.get()
         tool = tools.Tools(self)
-        if registry.get_task_class(tool.expand(self.image)):
+        if registry.has_task(tool.expand(self.image)):
             return [self.image]
         return []
 
@@ -248,6 +279,14 @@ class DockerContainer(Resource):
             return "-P"
         return " ".join([utils.option("-p ", self.tools.expand(port)) for port in self.ports])
 
+    @property
+    def _security_opts(self):
+        return " ".join([utils.option("--security-opt ", self.tools.expand(opt)) for opt in self.security_opts])
+
+    @property
+    def _stop_signal(self):
+        return f" -s {self.stop_signal}" if self.stop_signal else ""
+
     @property
     def _user(self):
         if self.user:
@@ -263,7 +302,13 @@ class DockerContainer(Resource):
         return " ".join([utils.option("-v ", self.tools.expand(vol))
                          for vol in self.volumes_default + self.volumes])
 
+    @property
+    def _workdir(self):
+        return "--workdir " + self.tools.expand(self.workdir) if self.workdir else ""
+
     def acquire(self, artifact, deps, tools, owner):
+        self._context_stack = None
+        self.container = None
         self.joltcachedir = config.get_cachedir()
         try:
             image = deps[self.image]
@@ -272,9 +317,10 @@ class DockerContainer(Resource):
             image = tools.expand(self.image)
 
         self._info(f"Creating container from image '{image}'")
-        self.container = tools.run(
-            "docker run -i -d {_cap_adds} {_cap_drops} {_entrypoint} {_labels} {_ports} {_privileged} {_user} {_environment} {_volumes} {image} {_arguments}",
-            image=image, output_on_error=True)
+        with utils.delayed_interrupt():
+            self.container = tools.run(
+                "docker run -i -d {_cap_adds} {_cap_drops} {_entrypoint} {_labels} {_ports} {_privileged} {_security_opts} {_user} {_environment} {_volumes} {_workdir} {image} {_arguments}",
+                image=image, output_on_error=True)
 
         self._info("Created container '{container}'")
         info = tools.run("docker inspect {container}", output_on_error=True)
@@ -287,14 +333,18 @@ class DockerContainer(Resource):
                 owner.tools.runprefix(f"docker exec -i {artifact.container}"))
 
     def release(self, artifact, deps, tools, owner):
-        if self.chroot:
+        if self.chroot and self._context_stack:
             self._context_stack.close()
 
-        self._info("Stopping container '{container}'")
-        tools.run("docker stop {container}", output_on_error=True)
+        if not self.container:
+            return
 
-        self._info("Deleting container '{container}'")
-        tools.run("docker rm {container}", output_on_error=True)
+        try:
+            self._info("Stopping container '{container}'")
+            tools.run("docker stop{_stop_signal} -t {stop_timeout} {container}", output_on_error=True)
+        finally:
+            self._info("Deleting container '{container}'")
+            tools.run("docker rm -f {container}", output_on_error=True)
 
 
 class DockerLogin(Resource):
@@ -443,6 +493,9 @@ class DockerImage(Task):
     """
     abstract = True
 
+    annotations = []
+    """ A list of image annotations """
+
     autoload = True
     """
     Automatically load image file into local registry when the artifact is
@@ -529,6 +582,10 @@ class DockerImage(Task):
         with _Tarfile.open(layerpath, 'r') as tar:
             tar.extractall(targetpath)
 
+    @property
+    def _annotations(self):
+        return " ".join([utils.option("--annotation ", self.tools.expand(an)) for an in self.annotations])
+
     @property
     def _buildargs(self):
         return " ".join([utils.option("--build-arg ", self.tools.expand(ba)) for ba in self.buildargs])
@@ -570,7 +627,7 @@ class DockerImage(Task):
                   tools.expand_relpath(context))
 
         with tools.cwd(context):
-            tools.run("docker build {_platform} . -f {} {_buildargs} {_labels} {_tags} {pull}{squash}",
+            tools.run("docker build {_platform} . -f {} {_annotations} {_buildargs} {_labels} {_tags} {pull}{squash}",
                       utils.quote(dockerfile), pull=pull, squash=squash)
 
         try:
@@ -620,4 +677,4 @@ class DockerImage(Task):
                     if self._autoload:
                         artifact.docker.load.append("{_imagefile}")
             if self._autoload:
-                artifact.docker.rmi.append(artifact.strings.tag.get_value())
+                artifact.docker.rmi.append(artifact.strings.tag)