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

jolt/pkgs/boost.py

@@ -0,0 +1,111 @@
+import os
+from jolt import attributes, Alias, BooleanParameter, Download, IntParameter, Parameter
+from jolt.pkgs import cpython
+from jolt.plugins import git
+from jolt.tasks import Task, TaskRegistry
+from jolt.error import raise_task_error_if
+
+
+@attributes.common_metadata()
+@attributes.requires("requires_git")
+@attributes.requires("requires_python_{python[on,off]}")
+@attributes.system
+class Boost(Task):
+    name = "boost"
+    version = Parameter("1.90.0", help="Boost version.")
+    shared = BooleanParameter(False, help="Build shared libraries")
+    python = BooleanParameter(False, help="Build Boost.Python")
+    bits = IntParameter(64, values=[32, 64], help="Boost address-model")
+    requires_git = ["git:url=https://github.com/boostorg/boost.git,path={buildroot}/git-boost,rev=boost-{version},submodules=true"]
+    requires_python_on = ["cpython"]
+
+    def write_user_config(self, deps, tools):
+        content = ""
+
+        if self.python:
+            py_exe = tools.which("python3")
+            raise_task_error_if(
+                py_exe is None, self,
+                "Boost.Python requested, but no Python interpreter found in PATH.",
+            )
+
+            # Find the dependency where the Python interpreter is located
+            py_dep = None
+            py_prefix = os.path.dirname(os.path.dirname(py_exe))
+            for _, dep in deps.items():
+                if dep.path == py_prefix:
+                    py_dep = dep
+                    break
+
+            raise_task_error_if(
+                py_dep is None, self,
+                "Boost.Python requested, but the Python dependency could not be found.",
+            )
+
+            py_version = str(py_dep.strings.version_major)
+            content += f"using python : {py_version} : {py_prefix}/bin/python{py_version} : {py_prefix}/include/python{py_version} : {py_prefix}/lib ;\n"
+
+        tools.write_file(
+            self.userconfigfile,
+            content,
+        )
+
+    def clean(self, tools):
+        self.builddir = tools.builddir("build", incremental=True)
+        self.installdir = tools.builddir("install")
+        tools.rmtree(self.builddir)
+        tools.rmtree(self.installdir)
+
+    def run(self, deps, tools):
+        self.builddir = tools.builddir("build", incremental=True)
+        self.installdir = tools.builddir("install")
+        self.userconfigfile = tools.expand_path("{builddir}/user-config.jam")
+        self.write_user_config(deps, tools)
+
+        without_libs = []
+        if not self.python:
+            without_libs.append("python")
+
+        bootstrap_cmd = []
+        if without_libs:
+            bootstrap_cmd = ["--without-libraries={}".format(",".join(without_libs))]
+
+        b2_cmd = [
+            "install",
+            "address-model={bits}",
+            "link={shared[shared,static]}",
+            "--prefix={installdir}",
+            "--build-dir={builddir}",
+            "--user-config={userconfigfile}",
+            "-j{}".format(tools.cpu_count()),
+        ]
+
+        with tools.cwd("{git[boost]}"):
+            if self.system == "windows":
+                bootstrap_cmd = [".\\bootstrap.bat", "msvc"] + bootstrap_cmd
+                b2_cmd = [".\\b2"] + b2_cmd
+            else:
+                bootstrap_cmd = ["./bootstrap.sh"] + bootstrap_cmd
+                b2_cmd = ["./b2"] + b2_cmd
+
+            tools.run(" ".join(bootstrap_cmd))
+            tools.run(" ".join(b2_cmd))
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.installdir):
+            artifact.collect("*", symlinks=True)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+
+        with tools.cwd(self.installdir, "lib"):
+            for lib in tools.glob("libboost_*.a"):
+                name, _ = os.path.splitext(os.path.basename(lib))
+                artifact.cxxinfo.libraries.append(name[3:])
+
+            arch = tools.getenv("VSCMD_ARG_TGT_ARCH", "x64")
+            for lib in tools.glob(f"lib*-mt-{arch}-*.lib"):
+                name, _ = os.path.splitext(lib)
+                artifact.cxxinfo.libraries.append(name)
+
+
+TaskRegistry.get().add_task_class(Boost)

jolt/pkgs/boringssl.py

@@ -0,0 +1,32 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import nasm
+from jolt.plugins import cmake, git
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_nasm_{system}")
+@attributes.common_metadata()
+@attributes.system
+@cmake.requires()
+@cmake.use_ninja()
+class BoringSSL(cmake.CMake):
+    name = "boringssl"
+    version = Parameter("0.20251124.0", help="boringssl version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/google/boringssl.git,rev={version}"]
+    requires_nasm_windows = ["nasm"]
+    srcdir = "{git[boringssl]}"
+    options = [
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("ssl")
+        artifact.cxxinfo.libraries.append("crypto")
+
+
+TaskRegistry.get().add_task_class(BoringSSL)

jolt/pkgs/busybox.py

@@ -0,0 +1,39 @@
+from jolt import attributes, influence, Parameter, Task
+from jolt.plugins import git
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+class BusyBox(Task):
+    name = "busybox"
+    defconfig = Parameter(required=False, help="BusyBox defconfig file.")
+    version = Parameter("1.37.0", help="BusyBox version.")
+    requires_git = ["git:url=git://busybox.net/busybox.git,rev={version_tag}"]
+    srcdir = "{git[busybox]}"
+
+    @property
+    def version_tag(self):
+        return str(self.version).replace(".", "_")
+
+    @property
+    def defconfig_arg(self):
+        if self.defconfig:
+            return f"{self.defconfig}_defconfig"
+        return "defconfig"
+
+    def run(self, deps, tools):
+        self.outdir = tools.builddir()
+        self.installdir = tools.builddir("install")
+
+        with tools.cwd(self.srcdir):
+            tools.run("make O={outdir} {defconfig_arg}")
+            tools.run("make O={outdir} -j{}", tools.cpu_count())
+            tools.run("make O={outdir} install DESTDIR={installdir}")
+
+    def publish(self, artifact, tools):
+        artifact.environ.PATH.append("bin")
+        with tools.cwd(self.installdir):
+            artifact.collect("*", symlinks=True)
+
+
+TaskRegistry.get().add_task_class(BusyBox)

jolt/pkgs/bzip2.py

@@ -0,0 +1,43 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.tasks import TaskRegistry
+from jolt.plugins import fetch, ninja
+
+
+@attributes.requires("requires_src")
+@attributes.system
+@ninja.attributes.cflags("cflags_linux_pic_{pic[on,off]}")
+class LibBzip2(ninja.CXXLibrary):
+    name = "libbzip2"
+    binary = "bzip2"
+    version = Parameter("1.0.8", help="bzip2 version.")
+    pic = BooleanParameter(True, help="Build position independent code")
+    shared = BooleanParameter(False, help="Build shared libraries")
+    cstd = 90
+    cflags_darwin_pic_on = ["-fPIC"]
+    cflags_linux_pic_on = ["-fPIC"]
+    incremental = False
+    requires_src = ["fetch:alias=src,url=https://sourceware.org/pub/bzip2/bzip2-{version}.tar.gz"]
+    source_influence = False
+    sources = [
+        "{fetch[src]}/bzip2-{version}/blocksort.c",
+        "{fetch[src]}/bzip2-{version}/bzlib.c",
+        "{fetch[src]}/bzip2-{version}/bzlib.h",
+        "{fetch[src]}/bzip2-{version}/compress.c",
+        "{fetch[src]}/bzip2-{version}/crctable.c",
+        "{fetch[src]}/bzip2-{version}/decompress.c",
+        "{fetch[src]}/bzip2-{version}/huffman.c",
+        "{fetch[src]}/bzip2-{version}/randtable.c",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("bz2")
+        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+
+        with tools.cwd("{fetch[src]}/bzip2-{version}"):
+            artifact.collect("bzlib.h", "include/")
+
+
+TaskRegistry.get().add_task_class(LibBzip2)

jolt/pkgs/cares.py

@@ -0,0 +1,29 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import cmake
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class CAres(cmake.CMake):
+    name = "c-ares"
+    version = Parameter("1.34.6", help="c-ares version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/c-ares/c-ares.git,rev=v{version}"]
+    srcdir = "{git[c-ares]}"
+    options = [
+        "CARES_SHARED={shared[ON,OFF]}",
+        "CARES_STATIC={shared[OFF,ON]}",
+        "CARES_BUILD_TESTS=OFF",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("cares")
+
+
+TaskRegistry.get().add_task_class(CAres)

jolt/pkgs/catch2.py

@@ -0,0 +1,36 @@
+from jolt import attributes, BooleanParameter, Parameter, Task
+from jolt.pkgs import cmake
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class Catch2(cmake.CMake):
+    name = "catch2"
+    version = Parameter("3.11.0", help="catch2 version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/catchorg/Catch2.git,rev=v{version}"]
+    srcdir = "{git[Catch2]}"
+    options = [
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("Catch2")
+
+
+class Catch2Main(Task):
+    name = "catch2/main"
+    extends = "catch2"
+
+    def publish(self, artifact, tools):
+        artifact.cxxinfo.libraries.append("Catch2Main")
+
+
+TaskRegistry.get().add_task_class(Catch2)
+TaskRegistry.get().add_task_class(Catch2Main)

jolt/pkgs/cbindgen.py

@@ -0,0 +1,17 @@
+from jolt import attributes
+from jolt.pkgs import rust
+from jolt.plugins import rust
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_rust")
+class CBindgen(rust.Rust):
+    name = "cbindgen"
+    version = "0.29.2"
+    requires_git = ["git:url=https://github.com/mozilla/cbindgen.git,rev=v{version},hash=true"]
+    requires_rust = ["rust"]
+    srcdir = "{git[cbindgen]}"
+
+
+TaskRegistry.get().add_task_class(CBindgen)

jolt/pkgs/cista.py

@@ -0,0 +1,19 @@
+from jolt import attributes, Parameter, Task
+from jolt.plugins import git
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+class Cista(Task):
+    name = "cista"
+    version = Parameter("0.16", help="Cista version.")
+    requires_git = ["git:url=https://github.com/felixguendling/cista.git,rev=v{version}"]
+    srcdir = "{git[cista]}"
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.srcdir):
+            artifact.collect("include/")
+        artifact.cxxinfo.incpaths.append("include")
+
+
+TaskRegistry.get().add_task_class(Cista)

jolt/pkgs/clang.py

@@ -0,0 +1,44 @@
+from jolt import attributes, Parameter, Task
+from jolt.pkgs import llvm
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_llvm")
+class Clang(Task):
+    name = "clang"
+    version = Parameter(llvm.VERSION, help="Clang version.")
+
+    requires_llvm = ["llvm:version={version}"]
+
+    def publish(self, artifact, tools):
+        artifact.environ.LLVM_TOOL_clang = "clang"
+        artifact.environ.LLVM_TOOL_clangpp = "clang++"
+        artifact.environ.AR = "llvm-ar"
+        artifact.environ.CC = "clang"
+        artifact.environ.CXX = "clang++"
+        artifact.environ.LD = "clang++"
+        artifact.environ.NM = "llvm-nm"
+        artifact.environ.OBJCOPY = "llvm-objcopy"
+        artifact.environ.OBJDUMP = "llvm-objdump"
+        artifact.environ.PATH.append("bin")
+        artifact.environ.RANLIB = "llvm-ranlib"
+        artifact.environ.STRIP = "llvm-strip"
+
+
+class ClangFormat(llvm.LLVMFromSrc):
+    name = "clang-format"
+    projects = ["clang", "clang-tools-extra"]
+    targets = []
+    install = ["install-clang-format"]
+
+
+class ClangTidy(llvm.LLVMFromSrc):
+    name = "clang-tidy"
+    projects = ["clang", "clang-tools-extra"]
+    targets = []
+    install = ["install-clang-tidy"]
+
+
+TaskRegistry.get().add_task_class(Clang)
+TaskRegistry.get().add_task_class(ClangFormat)
+TaskRegistry.get().add_task_class(ClangTidy)

jolt/pkgs/cli11.py

@@ -0,0 +1,24 @@
+from jolt import attributes, Parameter
+from jolt.plugins import cmake, fetch
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_src")
+@cmake.requires()
+@cmake.use_ninja()
+class CLI11(cmake.CMake):
+    name = "cli11"
+    version = Parameter("2.6.1", help="CLI11 version.")
+    requires_src = ["fetch:alias=src,url=https://github.com/CLIUtils/CLI11/archive/refs/tags/v{version}.tar.gz"]
+    srcdir = "{fetch[src]}/CLI11-{version}"
+    options = [
+        "CLI11_BUILD_EXAMPLES=OFF",
+        "CLI11_BUILD_TESTS=OFF",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+
+
+TaskRegistry.get().add_task_class(CLI11)

jolt/pkgs/cmake.py

@@ -0,0 +1,48 @@
+from jolt import attributes, Alias, Download, Parameter
+from jolt.tasks import TaskRegistry
+
+
+@attributes.arch
+@attributes.system
+@attributes.common_metadata()
+class CMakeBin(Download):
+    name = "cmake/bin"
+    version = Parameter("4.2.1", help="CMake version.")
+    url = ["https://github.com/Kitware/CMake/releases/download/v{version}/cmake-{version}-{cmake_system}-{cmake_arch}{cmake_ext}"]
+    collect = [{"files": "*", "cwd": "cmake-{version}-{cmake_system}-{cmake_arch}{cmake_contents}"}]
+
+    @property
+    def cmake_arch(self):
+        if self.system == "darwin":
+            return "universal"
+        if self.arch == "amd64":
+            return "x86_64"
+        return self.arch
+
+    @property
+    def cmake_ext(self):
+        if self.system == "windows":
+            return ".zip"
+        return ".tar.gz"
+
+    @property
+    def cmake_system(self):
+        if self.system == "darwin":
+            return "macos"
+        return self.system
+
+    @property
+    def cmake_contents(self):
+        if self.system == "darwin":
+            return "/CMake.app/Contents"
+        return ""
+
+
+class CMake(Alias):
+    name = "cmake"
+    version = Parameter("4.2.1", help="CMake version.")
+    requires = ["cmake/bin:version={version}"]
+
+
+TaskRegistry.get().add_task_class(CMake)
+TaskRegistry.get().add_task_class(CMakeBin)

jolt/pkgs/cpython.py

@@ -0,0 +1,196 @@
+from jolt import attributes, Alias, BooleanParameter, Parameter, Task
+from jolt.pkgs import libffi, sqlite, ssl, zlib, zstd, xz
+from jolt.plugins import autotools, git, pkgconfig
+from jolt.tasks import TaskRegistry
+
+
+def _unpack_adjust_scripts(artifact, tools):
+    bindir = "Scripts" if artifact.strings.system == "windows" else "bin"
+
+    with tools.cwd(artifact.path, bindir):
+        # Adjust paths in scripts
+        for script in tools.glob("*"):
+            # Ignore python executables
+            if script.startswith("python"):
+                continue
+            tools.replace_in_file(script, artifact.strings.install_prefix, artifact.final_path)
+
+    artifact.strings.install_prefix = artifact.final_path
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_libffi_{libffi[on,off]}")
+@attributes.requires("requires_sqlite_{sqlite[on,off]}")
+@attributes.requires("requires_ssl_{ssl[on,off]}")
+@attributes.requires("requires_zlib_{zlib[on,off]}")
+@attributes.requires("requires_zstd_{zstd[on,off]}")
+@attributes.requires("requires_xz_{xz[on,off]}")
+@pkgconfig.requires()
+class CPythonPosix(autotools.Autotools):
+    """ Builds and publishes CPython libraries and headers. """
+
+    name = "cpython/posix"
+    version = Parameter("3.14.2", help="CPython version.")
+    libffi = BooleanParameter(True, help="Enable libffi support")
+    sqlite = BooleanParameter(True, help="Enable SQLite support")
+    ssl = BooleanParameter(True, help="Enable SSL support")
+    zlib = BooleanParameter(True, help="Enable zlib support")
+    zstd = BooleanParameter(True, help="Enable zstd support")
+    xz = BooleanParameter(True, help="Enable xz support")
+    requires_git = ["git:url=https://github.com/python/cpython.git,rev=v{version}"]
+    requires_libffi_on = ["libffi"]
+    requires_sqlite_on = ["sqlite"]
+    requires_ssl_on = ["virtual/ssl"]
+    requires_zlib_on = ["virtual/zlib"]
+    requires_zstd_on = ["zstd"]
+    requires_xz_on = ["xz:pic=true"]
+    srcdir = "{git[cpython]}"
+    options = [
+        "--enable-optimizations",
+        "--with-ensurepip=install",
+    ]
+
+    @property
+    def version_major(self):
+        ver = str(self.version).split(".")
+        return f"{ver[0]}.{ver[1]}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.strings.version = str(self.version)
+        artifact.strings.version_major = str(self.version_major)
+
+    def unpack(self, artifact, tools):
+        super().unpack(artifact, tools)
+        _unpack_adjust_scripts(artifact, tools)
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_ssl_{ssl[on,off]}")
+@attributes.common_metadata()
+class CPythonWin32(Task):
+    """ Builds and publishes CPython libraries and headers. """
+
+    name = "cpython/win32"
+    version = Parameter("3.14.2", help="CPython version.")
+    ssl = BooleanParameter(True, help="Enable SSL support")
+    requires_git = ["git:url=https://github.com/python/cpython.git,rev=v{version}"]
+    requires_ssl_on = ["virtual/ssl"]
+    srcdir = "{git[cpython]}"
+
+    @property
+    def version_major(self):
+        ver = str(self.version).split(".")
+        return f"{ver[0]}.{ver[1]}"
+
+    @property
+    def version_major_compact(self):
+        ver = str(self.version).split(".")
+        return f"{ver[0]}{ver[1]}"
+
+    def run(self, deps, tools):
+        with tools.cwd(self.srcdir, "PCbuild"):
+            tools.run("build.bat")
+
+    def publish(self, artifact, tools):
+        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+        artifact.strings.version = str(self.version)
+        artifact.strings.version_major = str(self.version_major)
+        with tools.cwd(self.srcdir):
+            artifact.collect("Include", "include")
+            artifact.collect("Lib", "lib")
+        with tools.cwd(self.srcdir, "PCbuild", "amd64"):
+            artifact.collect("python.exe", "bin/python3.exe")
+            artifact.collect("python.exe", "bin/python{version_major}.exe")
+            artifact.collect("*.dll", "bin/")
+            artifact.collect("*.lib", "lib/")
+        with tools.tmpdir() as tmp, tools.cwd(tmp):
+            tools.write_file(
+                "python3.pc",
+                """
+# See: man pkg-config
+prefix=${{pcfiledir}}/../..
+exec_prefix=${{prefix}}/bin
+libdir=${{prefix}}/lib
+includedir=${{prefix}}/include
+
+Name: Python
+Description: Build a C extension for Python
+Version: {version}-{identity}
+Libs: -L${{libdir}} -lpython3
+Cflags: -I${{includedir}}
+""")
+            tools.write_file(
+                "python3-embed.pc",
+                """
+# See: man pkg-config
+prefix=${{pcfiledir}}/../..
+exec_prefix=${{prefix}}/bin
+libdir=${{prefix}}/lib
+includedir=${{prefix}}/include
+
+Name: Python
+Description: Embed Python into an application
+Version: {version}-{identity}
+Libs: -L${{libdir}} -lpython{version_major_compact}
+Cflags: -I${{includedir}}
+""")
+            artifact.collect("*.pc", "lib/pkgconfig/")
+
+    def unpack(self, artifact, tools):
+        super().unpack(artifact, tools)
+        _unpack_adjust_scripts(artifact, tools)
+
+
+@attributes.requires("requires_{system}")
+@attributes.system
+class CPython(Alias):
+    """ Alias for CPython """
+    name = "cpython"
+    version = Parameter("3.14.2", help="CPython version.")
+    requires_darwin = ["cpython/posix:version={version}"]
+    requires_linux = requires_darwin
+    requires_windows = ["cpython/win32:version={version}"]
+
+
+@pkgconfig.to_cxxinfo("python3-embed")
+@attributes.common_metadata()
+@attributes.system
+@pkgconfig.requires()
+class CPythonEmbed(Task):
+    name = "cpython/embed"
+    requires = ["cpython"]
+    selfsustained = True
+
+    def run(self, deps, tools):
+        name = "cpython/win32" if self.system == "windows" else "cpython/posix"
+        self.cpython = deps[name]
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.cpython.path):
+            artifact.collect("*", symlinks=True)
+
+
+@pkgconfig.to_cxxinfo("python3")
+@attributes.common_metadata()
+@attributes.system
+@pkgconfig.requires()
+class CPythonExtend(Task):
+    name = "cpython/extend"
+    requires = ["cpython"]
+    selfsustained = True
+
+    def run(self, deps, tools):
+        name = "cpython/win32" if self.system == "windows" else "cpython/posix"
+        self.cpython = deps[name]
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.cpython.path):
+            artifact.collect("*", symlinks=True)
+
+
+TaskRegistry.get().add_task_class(CPythonPosix)
+TaskRegistry.get().add_task_class(CPythonWin32)
+TaskRegistry.get().add_task_class(CPython)
+TaskRegistry.get().add_task_class(CPythonEmbed)
+TaskRegistry.get().add_task_class(CPythonExtend)

jolt/pkgs/crun.py

@@ -0,0 +1,29 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import libcap
+from jolt.plugins import git, autotools, pkgconfig
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_libcap_{caps[on,off]}")
+@autotools.requires()
+@pkgconfig.requires()
+class CRun(autotools.Autotools):
+    name = "crun"
+    version = Parameter("1.26", help="crun version.")
+    caps = BooleanParameter(False, help="Enable capabilities support.")
+    systemd = BooleanParameter(False, help="Enable systemd support.")
+    requires_git = ["git:url=https://github.com/containers/crun.git,rev={version},submodules=true"]
+    requires_caps_on = ["libcap"]
+    srcdir = "{git[crun]}"
+    options = [
+        # Unable to get ./configure to pick these up from pkg-config
+        "--disable-criu",
+        "--disable-seccomp",
+        "--enable-embedded-yajl",
+        "{caps[,--disable-caps]}",
+        "{systemd[,--disable-systemd]}",
+    ]
+
+
+TaskRegistry.get().add_task_class(CRun)