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

jolt/plugins/podman.py

@@ -1,4 +1,4 @@
-from jolt import Download, Parameter, Resource, Task
+from jolt import Parameter, Resource, Task
 from jolt.error import raise_task_error_if
 from jolt.tasks import TaskRegistry
 from jolt import attributes
@@ -12,10 +12,9 @@ from jolt.cache import ArtifactListAttribute
 from jolt.cache import ArtifactAttributeSet
 from jolt.cache import ArtifactAttributeSetProvider
 
+import contextlib
 import json
 from os import path
-
-from platform import system
 import tarfile
 
 
@@ -25,24 +24,20 @@ class PodmanListVariable(ArtifactListAttribute):
 
 class PodmanImportListVariable(PodmanListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for tar in self.items():
             try:
                 tag = artifact.podman.tags[0]
             except IndexError:
-                tag = "{}:{}".format(artifact.get_task().canonical_name, artifact.identity)
+                tag = artifact.tools.expand("{canonical_name}:{identity}")
             task.tools.run(
                 "podman import {} {}",
-                fs.path.join(artifact.path, tar, tag), output_on_error=True)
+                fs.path.join(artifact.path, tar), tag, output_on_error=True)
             for extra_tag in artifact.podman.tags[1:]:
                 task.tools.run("podman tag {} {}", tag, extra_tag, output_on_error=True)
 
 
 class PodmanLoadListVariable(PodmanListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run(
                 "podman load -i {}",
@@ -51,16 +46,12 @@ class PodmanLoadListVariable(PodmanListVariable):
 
 class PodmanPullListVariable(PodmanListVariable):
     def apply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run("podman pull {}", image, output_on_error=True)
 
 
 class PodmanRmiListVariable(PodmanListVariable):
     def unapply(self, task, artifact):
-        if isinstance(task, Resource):
-            return
         for image in self.items():
             task.tools.run("podman rmi -f {}", image, output_on_error=True)
 
@@ -108,35 +99,6 @@ class PodmanAttributeProvider(ArtifactAttributeSetProvider):
         artifact.podman.unapply(task, artifact)
 
 
-class PodmanClient(Download):
-    """ Task: Downloads and publishes the Podman command line client.
-
-    The task will be automatically made available after importing
-    ``jolt.plugins.podman``.
-    """
-
-    name = "podman/cli"
-    """ Name of the task """
-
-    arch = Parameter("x86_64", help="Host architecture")
-    """ Host architecture [x86_64] """
-
-    collect = ["podman/podman"]
-
-    host = Parameter(system().lower(), help="Host operating system")
-    """ Host operating system [autodetected] """
-
-    url = "https://download.podman.com/{host}/static/stable/{arch}/podman-{version}.tgz"
-    """ URL of binaries """
-
-    version = Parameter("20.10.13", help="Podman version")
-    """ Podman version [20.10.13] """
-
-    def publish(self, artifact, tools):
-        super().publish(artifact, tools)
-        artifact.environ.PATH.append("podman")
-
-
 @attributes.requires("_image")
 class Container(Resource):
     """
@@ -152,6 +114,9 @@ class Container(Resource):
     cap_drops = []
     """ A list of capabilities to remove from the container """
 
+    chroot = False
+    """ Use as chroot - resource consumers will execute all commands in container """
+
     entrypoint = None
     """ Container entrypoint """
 
@@ -190,6 +155,18 @@ class Container(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. """
+
+    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.
+    """
+
     volumes = []
     """
     A list of volumes to mount.
@@ -199,8 +176,8 @@ class Container(Resource):
     """
 
     volumes_default = [
-        "{joltdir}:{joltdir}",
-        "{joltcachedir}:{joltcachedir}",
+        "{joltdir}",
+        "{joltcachedir}",
     ]
     """
     A list of default volumes to mount.
@@ -240,7 +217,7 @@ class Container(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 []
 
@@ -277,10 +254,12 @@ class Container(Resource):
 
     @property
     def _volumes(self):
-        return " ".join([utils.option("-v ", self.tools.expand(vol))
+        return " ".join([utils.option("-v ", self.tools.expand_path(vol))
                          for vol in self.volumes_default + self.volumes])
 
     def acquire(self, artifact, deps, tools, owner):
+        self._context_stack = None
+        self.container = None
         self.joltcachedir = config.get_cachedir()
         try:
             image = deps[self.image]
@@ -289,21 +268,34 @@ class Container(Resource):
             image = tools.expand(self.image)
 
         self._info(f"Creating container from image '{image}'")
-        self.container = tools.run(
-            "podman 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(
+                "podman run -i -d {_cap_adds} {_cap_drops} {_entrypoint} {_labels} {_ports} {_privileged} {_user} {_environment} {_volumes} {image} {_arguments}",
+                image=image, output_on_error=True)
 
         self._info("Created container '{container}'")
         info = tools.run("podman inspect {container}", output_on_error=True)
         artifact.container = self.container
         artifact.info = json.loads(info)[0]
 
+        if self.chroot:
+            self._context_stack = contextlib.ExitStack()
+            self._context_stack.enter_context(
+                owner.tools.runprefix(f"podman exec -i {artifact.container}"))
+
     def release(self, artifact, deps, tools, owner):
-        self._info("Stopping container '{container}'")
-        tools.run("podman stop {container}", output_on_error=True)
+        if self.chroot and self._context_stack:
+            self._context_stack.close()
+
+        if not self.container:
+            return
 
-        self._info("Deleting container '{container}'")
-        tools.run("podman rm {container}", output_on_error=True)
+        try:
+            self._info("Stopping container '{container}'")
+            tools.run("podman stop -t {stop_timeout} {container}", output_on_error=True)
+        finally:
+            self._info("Deleting container '{container}'")
+            tools.run("podman rm -f {container}", output_on_error=True)
 
 
 class PodmanLogin(Resource):
@@ -322,8 +314,6 @@ class PodmanLogin(Resource):
     name = "podman/login"
     """ Name of the resource """
 
-    requires = ["podman/cli"]
-
     user = Parameter("", help="Podman Registry username")
     """
     Podman Registry username.
@@ -363,7 +353,6 @@ class PodmanLogin(Resource):
         tools.run("podman logout {server}")
 
 
-TaskRegistry.get().add_task_class(PodmanClient)
 TaskRegistry.get().add_task_class(PodmanLogin)
 
 
@@ -423,7 +412,6 @@ class ContainerImage(Task):
 
     Optionally add requirements to:
 
-      - ``podman/cli`` to provision the Podman client, if none is available on the host.
       - ``podman/login`` to automatically login to the Podman registry.
 
     This class must be subclassed.
@@ -446,12 +434,14 @@ class ContainerImage(Task):
         class Busybox(ContainerImage):
             \"\"\" Publishes Busybox image as gzip-compressed tarball \"\"\"
             compression = "gz"
-            requires = ["podman/cli"]
             tags = ["busybox:{identity}"]
 
     """
     abstract = True
 
+    annotations = []
+    """ A list of image annotations """
+
     autoload = True
     """
     Automatically load image file into local registry when the artifact is
@@ -481,10 +471,26 @@ class ContainerImage(Task):
     dockerfile = "Dockerfile"
     """ Path to the Dockerfile to build, or the full source code of such a file. """
 
-    output = "oci-archive"
-    """ none, oci-archive, oci-directory, docker-archive, directory, tar, tar.gz, tgz, tar.bz2, tar.xz"""
+    output = ["oci-archive"]
+    """
+    List of output formats.
+
+    If set to None, no output is produced and published.
 
-    imagefile = "{canonical_name}.tar"
+    Supported formats:
+        - archive
+        - cpio
+        - custom
+        - directory
+        - docker-archive
+        - ext4
+        - oci-archive
+        - oci-directory
+        - squashfs
+
+    """
+
+    imagefile = "{canonical_name}"
     """
     Name of the image tarball published by the task.
 
@@ -496,9 +502,6 @@ class ContainerImage(Task):
     labels = []
     """ A list of image metadata labels """
 
-    platform = None
-    """ Target platform, e.g. linux/arm/v7. """
-
     pull = True
     """
     Always pull images when building.
@@ -514,15 +517,25 @@ class ContainerImage(Task):
     The ``podman/login`` Jolt resource can be used for that purpose.
     """
 
+    size = None
+    """ Size of the image, e.g. "64M" (for certain output formats). """
+
     squash = False
     """ Squash image layers """
 
     tags = ["{canonical_name}:{identity}"]
     """ Optional list of image tags. Defaults to task's canonical name. """
 
+    target = None
+    """ Target platform, e.g. linux/arm/v7. """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+    @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])
@@ -531,9 +544,13 @@ class ContainerImage(Task):
     def _labels(self):
         return " ".join([utils.option("-l ", self.tools.expand(label)) for label in self.labels])
 
+    @property
+    def _output(self):
+        return utils.as_list(self.output) if self.output else []
+
     @property
     def _platform(self):
-        platform = self.tools.expand(self.platform) if self.platform else None
+        platform = self.tools.expand(self.target) if self.target else None
         return utils.option("--platform ", platform)
 
     @property
@@ -564,7 +581,7 @@ class ContainerImage(Task):
                   tools.expand_relpath(context))
 
         with tools.cwd(context):
-            tools.run("podman build {_platform} . -f {} {_buildargs} {_labels} {_tags} {pull}{squash}",
+            tools.run("podman build {_platform} . -f {} {_annotations} {_buildargs} {_labels} {_tags} {pull}{squash}",
                       utils.quote(dockerfile), pull=pull, squash=squash)
 
         try:
@@ -573,48 +590,88 @@ class ContainerImage(Task):
                 for tag in self.tags:
                     tools.run("podman push {}", tag)
 
-            if self.output:
-                self.info("Saving image")
-                with tools.cwd(tools.builddir()):
-                    if self.output in ["oci-archive", "docker-archive"]:
+            for output in self._output:
+                self.info("Saving image as {}", output)
+                outdir = tools.builddir(output)
+                with tools.cwd(outdir):
+                    if output in ["oci-archive", "docker-archive"]:
                         tools.run("podman image save --format={output} {} -o {}", self.tags[0], "image.tar")
-                    if self.output == "oci-directory":
+                    if output == "oci-directory":
                         tools.run("podman image save --format=oci-dir {} -o {}", self.tags[0], "image.dir")
-                    if self.output in ["archive", "directory"]:
+                    if output in ["archive", "cpio", "custom", "directory", "ext4", "squashfs"]:
                         ctr = tools.run("podman create {}", self.tags[0])
                         try:
-                            mount_path = tools.run("podman unshare podman mount {}", ctr, output_on_error=True)
-                            if self.output == "archive":
-                                tools.run("podman unshare tar -C {} -cf image.tar .", mount_path, output_on_error=True)
-                            else:
-                                tools.mkdir("image.dir")
-                                tools.run("podman unshare tar c -C {} . | tar --no-same-permissions --no-same-owner --no-overwrite-dir -x -C ./image.dir/", mount_path, output_on_error=True)
+                            with tools.runprefix("podman unshare "):
+                                mount_path = tools.run("podman mount {}", ctr, output_on_error=True)
+                                if output == "custom":
+                                    self.run_custom(deps, tools, mount_path)
+                                elif output == "archive":
+                                    tools.run("tar -C {} -cf image.tar .", mount_path, output_on_error=True)
+                                elif output == "cpio":
+                                    with tools.cwd(mount_path):
+                                        tools.run("find | podman unshare cpio -o -F {}/image.cpio -H newc", outdir, output_on_error=True)
+                                elif output == "ext4":
+                                    assert self.size, "Size must be set for ext4 output"
+                                    tools.run("mke2fs -t ext4 -F -L rootfs -d {} image.ext4 {size}", mount_path, output_on_error=True)
+                                elif output == "squashfs":
+                                    tools.run("mksquashfs {} image.squashfs", mount_path, output_on_error=True)
+                                else:
+                                    tools.mkdir("image.dir")
+                                    tools.run("tar c -C {} . | tar --no-same-permissions --no-same-owner --no-overwrite-dir -x -C ./image.dir/", mount_path, output_on_error=True)
                         finally:
                             utils.call_and_catch(tools.run, "podman rm {}", ctr)
         finally:
             if self.cleanup:
                 self.info("Removing image from Podman")
                 for tag in self.tags:
-                    utils.call_and_catch(tools.run("podman image rm {}", tag))
+                    utils.call_and_catch(tools.run("podman rmi -f {}", tag))
+
+    def run_custom(self, deps, tools, mount_path):
+        """
+        Save image as custom output format.
+
+        The method is called when the output format is set to "custom".
+        The mount_path is the path to the mounted container root filesystem.
+
+        The default implementation does nothing.
+        """
+        pass
 
     def publish(self, artifact, tools):
+        """ Publish the image as different output formats """
+
         artifact.strings.tag = tools.expand(self.tags[0])
 
         for tag in self.tags:
             artifact.podman.tags.append(tag)
 
-        if self.output:
-            with tools.cwd(tools.builddir()):
-                if self.output in ["oci-archive", "docker-archive"] and self._imagefile:
-                    artifact.collect("image.tar", "{_imagefile}")
+        for output in self._output:
+            outdir = tools.builddir(output)
+            with tools.cwd(outdir):
+                if output in ["oci-archive", "docker-archive"] and self._imagefile:
+                    artifact.collect("image.tar", output + "/{_imagefile}.tar")
                     if self._autoload:
-                        artifact.podman.load.append("{_imagefile}")
-                        artifact.podman.rmi.append(artifact.strings.tag.get_value())
-                if self.output in ["archive"] and self._imagefile:
-                    artifact.collect("image.tar", "{_imagefile}")
+                        artifact.podman.load.append(output + "/{_imagefile}.tar")
+                        artifact.podman.rmi.append(artifact.strings.tag)
+                if output in ["archive"] and self._imagefile:
+                    artifact.collect("image.tar", output + "/{_imagefile}.tar")
                     if self._autoload:
-                        artifact.podman.imprt.append("{_imagefile}")
-                        artifact.podman.rmi.append(artifact.strings.tag.get_value())
-                if self.output in ["directory", "oci-directory"]:
+                        artifact.podman.imprt.append(output + "/{_imagefile}.tar")
+                        artifact.podman.rmi.append(artifact.strings.tag)
+                if output in ["directory", "oci-directory"]:
                     with tools.cwd("image.dir"):
-                        artifact.collect("*", symlinks=True)
+                        artifact.collect("*", f"{output}/", symlinks=True)
+                if output in ["cpio"]:
+                    artifact.collect("image.cpio", output + "/{_imagefile}.cpio")
+                if output in ["custom"]:
+                    self.publish_custom(artifact, tools)
+                if output in ["directory"]:
+                    artifact.paths.rootfs = output
+                if output in ["ext4"]:
+                    artifact.collect("image.ext4", output + "/{_imagefile}.ext4")
+                if output in ["squashfs"]:
+                    artifact.collect("image.squashfs", output + "/{_imagefile}.squashfs")
+
+    def publish_custom(self, artifact, tools):
+        """ Publish custom output as produced by run_custom """
+        pass

jolt/plugins/python.py

@@ -1,9 +1,12 @@
 import sys
 
+from jolt import Task
+from jolt import attributes
 from jolt import filesystem as fs
 from jolt.cache import ArtifactStringAttribute
 from jolt.cache import ArtifactAttributeSet
 from jolt.cache import ArtifactAttributeSetProvider
+from jolt.error import raise_task_error_if
 
 
 class PythonVariable(ArtifactStringAttribute):
@@ -98,3 +101,137 @@ class PythonProvider(ArtifactAttributeSetProvider):
 
     def unapply(self, task, artifact):
         artifact.python.unapply(task, artifact)
+
+
+@attributes.system
+@attributes.requires("requires_python")
+class PythonEnv(Task):
+    """
+    Base class for Python virtual environment tasks.
+
+    Builds a Python virtual environment and installs specified packages.
+
+    The venv module from the Python standard library must be available in the
+    Python installation used to run the task.
+    """
+
+    abstract = True
+    """ This is an abstract base class that should be inherited by concrete tasks. """
+
+    executable = "python3"
+    """ Python executable to use for creating the virtual environment. """
+
+    requirements = []
+    """
+    List of Python packages to install in the virtual environment.
+
+    Each entry should be a string suitable for pip, e.g., "package==version".
+    """
+
+    def _verify_influence(self, deps, artifact, tools, sources=None):
+        # No influence to verify
+        return
+
+    def relocate_scripts(self, artifact, tools, frompath, topath):
+        bindir = "Scripts" if self.system == "windows" else "bin"
+
+        with tools.cwd(artifact.path, bindir):
+            for script in tools.glob("*"):
+                if script.startswith("python"):
+                    continue
+                tools.replace_in_file(script, frompath, topath)
+
+        with tools.cwd(artifact.path):
+            if not tools.exists("local/bin"):
+                return
+            with tools.cwd("local", "bin"):
+                for script in tools.glob("*"):
+                    tools.replace_in_file(script, frompath, topath)
+
+    def publish(self, artifact, tools):
+        # Create a parallel installation by copying a Python installation
+
+        # First locate the Python executable to copy
+        py_exe = tools.which(self.executable)
+        raise_task_error_if(
+            py_exe is None, self,
+            f"Python executable '{self.executable}' not found in PATH.",
+        )
+
+        # Follow symlinks to get the real executable
+        py_exe = fs.path.realpath(py_exe)
+
+        # Determine the Python home directory
+        py_home = fs.path.dirname(fs.path.dirname(py_exe))
+
+        # Determine the Python version
+        self.version_major = tools.run(
+            [py_exe, "-c", "import sys; print(\"{{}}.{{}}\".format(sys.version_info[0], sys.version_info[1]))"],
+            shell=False,
+            output_on_error=True).strip()
+
+        self.info("Python executable: {0}", py_exe)
+        self.info("Python home: {0}", py_home)
+        self.info("Python version: {0}", self.version_major)
+
+        # Copy the Python installation to the artifact path
+        with tools.cwd(py_home):
+            artifact.collect(py_exe, "bin/python3")
+            artifact.collect("lib/python3")
+            artifact.collect("lib/python{version_major}")
+            artifact.collect("lib/libpython{version_major}.*")
+
+        # Create common symlinks
+        if self.system != "windows":
+            with tools.cwd(artifact.path, "bin"):
+                tools.symlink("python3", "python")
+                tools.symlink("python3", "python{version_major}")
+
+        # Install required packages into the artifact using pip
+        with tools.environ(PYTHONHOME=artifact.path):
+            py_exe = fs.path.join(artifact.path, "bin", "python3")
+            with tools.tmpdir() as tmp, tools.cwd(tmp):
+                tools.write_file(
+                    "requirements.txt",
+                    "\n".join(self.requirements) + "\n"
+                )
+
+                pip_cmd = [
+                    py_exe,
+                    "-m",
+                    "pip",
+                    "--isolated",
+                    "--no-cache-dir",
+                    "install",
+                    "-r",
+                    "requirements.txt",
+                    "--break-system-packages",
+                ]
+                tools.run(pip_cmd, shell=False)
+
+        artifact.environ.PATH.append("bin")
+        artifact.environ.PATH.append("local/bin")
+        artifact.strings.install_prefix = artifact.path
+
+    def unpack(self, artifact, tools):
+        # Relocate the virtual environment by adjusting script paths
+        frompath = artifact.strings.install_prefix
+        topath = artifact.final_path
+        self.relocate_scripts(artifact, tools, frompath, topath)
+
+        artifact.strings.install_prefix = artifact.final_path
+
+
+def requires(python=True):
+    """ Decorator to add Python requirements to a task. """
+
+    import jolt.pkgs.cpython
+
+    def decorate(cls):
+        if python:
+            cls = attributes.requires("requires_python")(cls)
+            cls.requires_python = ["cpython"]
+
+        return cls
+
+    return decorate

jolt/plugins/remote_execution/administration_pb2.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: jolt/plugins/remote_execution/administration.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
+from jolt import common_pb2 as jolt_dot_common__pb2
+from jolt.plugins.remote_execution import scheduler_pb2 as jolt_dot_plugins_dot_remote__execution_dot_scheduler__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n2jolt/plugins/remote_execution/administration.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x11jolt/common.proto\x1a-jolt/plugins/remote_execution/scheduler.proto\"\"\n\x11ListBuildsRequest\x12\r\n\x05tasks\x18\x01 \x01(\x08\"\xf4\x02\n\x12ListBuildsResponse\x12)\n\x06\x62uilds\x18\x01 \x03(\x0b\x32\x19.ListBuildsResponse.Build\x1aR\n\x04Task\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x1b\n\x06status\x18\x03 \x01(\x0e\x32\x0b.TaskStatus\x12\x13\n\x0bhasObserver\x18\x04 \x01(\x08\x1a\xde\x01\n\x05\x42uild\x12\n\n\x02id\x18\x01 \x01(\t\x12\x1c\n\x06status\x18\x02 \x01(\x0e\x32\x0c.BuildStatus\x12\'\n\x05tasks\x18\x03 \x03(\x0b\x32\x18.ListBuildsResponse.Task\x12/\n\x0bscheduledAt\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x13\n\x0bhasObserver\x18\x05 \x01(\x08\x12\x16\n\x0ehasRunningTask\x18\x06 \x01(\x08\x12\x15\n\rhasQueuedTask\x18\x07 \x01(\x08\x12\r\n\x05ready\x18\x08 \x01(\x08\"\x14\n\x12ListWorkersRequest\"\x80\x02\n\x13ListWorkersResponse\x12,\n\x07workers\x18\x01 \x03(\x0b\x32\x1b.ListWorkersResponse.Worker\x1a=\n\x04Task\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x1b\n\x06status\x18\x03 \x01(\x0e\x32\x0b.TaskStatus\x1a|\n\x06Worker\x12\n\n\x02id\x18\x01 \x01(\t\x12\x1b\n\x08platform\x18\x02 \x01(\x0b\x32\t.Platform\x12 \n\rtask_platform\x18\x03 \x01(\x0b\x32\t.Platform\x12\'\n\x04task\x18\x04 \x01(\x0b\x32\x19.ListWorkersResponse.Task2\xf9\x01\n\x0e\x41\x64ministration\x12\x38\n\x0b\x43\x61ncelBuild\x12\x13.CancelBuildRequest\x1a\x14.CancelBuildResponse\x12\x35\n\nListBuilds\x12\x12.ListBuildsRequest\x1a\x13.ListBuildsResponse\x12\x38\n\x0bListWorkers\x12\x13.ListWorkersRequest\x1a\x14.ListWorkersResponse\x12<\n\nReschedule\x12\x16.google.protobuf.Empty\x1a\x16.google.protobuf.EmptyB\x0eZ\x0cpkg/protocolb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'jolt.plugins.remote_execution.administration_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  _globals['DESCRIPTOR']._options = None
+  _globals['DESCRIPTOR']._serialized_options = b'Z\014pkg/protocol'
+  _globals['_LISTBUILDSREQUEST']._serialized_start=182
+  _globals['_LISTBUILDSREQUEST']._serialized_end=216
+  _globals['_LISTBUILDSRESPONSE']._serialized_start=219
+  _globals['_LISTBUILDSRESPONSE']._serialized_end=591
+  _globals['_LISTBUILDSRESPONSE_TASK']._serialized_start=284
+  _globals['_LISTBUILDSRESPONSE_TASK']._serialized_end=366
+  _globals['_LISTBUILDSRESPONSE_BUILD']._serialized_start=369
+  _globals['_LISTBUILDSRESPONSE_BUILD']._serialized_end=591
+  _globals['_LISTWORKERSREQUEST']._serialized_start=593
+  _globals['_LISTWORKERSREQUEST']._serialized_end=613
+  _globals['_LISTWORKERSRESPONSE']._serialized_start=616
+  _globals['_LISTWORKERSRESPONSE']._serialized_end=872
+  _globals['_LISTWORKERSRESPONSE_TASK']._serialized_start=284
+  _globals['_LISTWORKERSRESPONSE_TASK']._serialized_end=345
+  _globals['_LISTWORKERSRESPONSE_WORKER']._serialized_start=748
+  _globals['_LISTWORKERSRESPONSE_WORKER']._serialized_end=872
+  _globals['_ADMINISTRATION']._serialized_start=875
+  _globals['_ADMINISTRATION']._serialized_end=1124
+# @@protoc_insertion_point(module_scope)