dragonfly-api 2.3.1

# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

from . import common_pb2 as common__pb2
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
from . import scheduler_pb2 as scheduler__pb2

GRPC_GENERATED_VERSION = '1.76.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + ' but the generated code in scheduler_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


class SchedulerStub(object):
    """Scheduler RPC Service.
    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.AnnouncePeer = channel.stream_stream(
                '/scheduler.v2.Scheduler/AnnouncePeer',
                request_serializer=scheduler__pb2.AnnouncePeerRequest.SerializeToString,
                response_deserializer=scheduler__pb2.AnnouncePeerResponse.FromString,
                _registered_method=True)
        self.StatPeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatPeer',
                request_serializer=scheduler__pb2.StatPeerRequest.SerializeToString,
                response_deserializer=common__pb2.Peer.FromString,
                _registered_method=True)
        self.DeletePeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeletePeer',
                request_serializer=scheduler__pb2.DeletePeerRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.StatTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatTask',
                request_serializer=scheduler__pb2.StatTaskRequest.SerializeToString,
                response_deserializer=common__pb2.Task.FromString,
                _registered_method=True)
        self.DeleteTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeleteTask',
                request_serializer=scheduler__pb2.DeleteTaskRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.AnnounceHost = channel.unary_unary(
                '/scheduler.v2.Scheduler/AnnounceHost',
                request_serializer=scheduler__pb2.AnnounceHostRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.ListHosts = channel.unary_unary(
                '/scheduler.v2.Scheduler/ListHosts',
                request_serializer=scheduler__pb2.ListHostsRequest.SerializeToString,
                response_deserializer=scheduler__pb2.ListHostsResponse.FromString,
                _registered_method=True)
        self.DeleteHost = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeleteHost',
                request_serializer=scheduler__pb2.DeleteHostRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.AnnounceCachePeer = channel.stream_stream(
                '/scheduler.v2.Scheduler/AnnounceCachePeer',
                request_serializer=scheduler__pb2.AnnounceCachePeerRequest.SerializeToString,
                response_deserializer=scheduler__pb2.AnnounceCachePeerResponse.FromString,
                _registered_method=True)
        self.StatCachePeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatCachePeer',
                request_serializer=scheduler__pb2.StatCachePeerRequest.SerializeToString,
                response_deserializer=common__pb2.CachePeer.FromString,
                _registered_method=True)
        self.DeleteCachePeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeleteCachePeer',
                request_serializer=scheduler__pb2.DeleteCachePeerRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.StatCacheTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatCacheTask',
                request_serializer=scheduler__pb2.StatCacheTaskRequest.SerializeToString,
                response_deserializer=common__pb2.CacheTask.FromString,
                _registered_method=True)
        self.DeleteCacheTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeleteCacheTask',
                request_serializer=scheduler__pb2.DeleteCacheTaskRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.AnnouncePersistentPeer = channel.stream_stream(
                '/scheduler.v2.Scheduler/AnnouncePersistentPeer',
                request_serializer=scheduler__pb2.AnnouncePersistentPeerRequest.SerializeToString,
                response_deserializer=scheduler__pb2.AnnouncePersistentPeerResponse.FromString,
                _registered_method=True)
        self.StatPersistentPeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatPersistentPeer',
                request_serializer=scheduler__pb2.StatPersistentPeerRequest.SerializeToString,
                response_deserializer=common__pb2.PersistentPeer.FromString,
                _registered_method=True)
        self.DeletePersistentPeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeletePersistentPeer',
                request_serializer=scheduler__pb2.DeletePersistentPeerRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.UploadPersistentTaskStarted = channel.unary_unary(
                '/scheduler.v2.Scheduler/UploadPersistentTaskStarted',
                request_serializer=scheduler__pb2.UploadPersistentTaskStartedRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.UploadPersistentTaskFinished = channel.unary_unary(
                '/scheduler.v2.Scheduler/UploadPersistentTaskFinished',
                request_serializer=scheduler__pb2.UploadPersistentTaskFinishedRequest.SerializeToString,
                response_deserializer=common__pb2.PersistentTask.FromString,
                _registered_method=True)
        self.UploadPersistentTaskFailed = channel.unary_unary(
                '/scheduler.v2.Scheduler/UploadPersistentTaskFailed',
                request_serializer=scheduler__pb2.UploadPersistentTaskFailedRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.StatPersistentTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatPersistentTask',
                request_serializer=scheduler__pb2.StatPersistentTaskRequest.SerializeToString,
                response_deserializer=common__pb2.PersistentTask.FromString,
                _registered_method=True)
        self.DeletePersistentTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeletePersistentTask',
                request_serializer=scheduler__pb2.DeletePersistentTaskRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.AnnouncePersistentCachePeer = channel.stream_stream(
                '/scheduler.v2.Scheduler/AnnouncePersistentCachePeer',
                request_serializer=scheduler__pb2.AnnouncePersistentCachePeerRequest.SerializeToString,
                response_deserializer=scheduler__pb2.AnnouncePersistentCachePeerResponse.FromString,
                _registered_method=True)
        self.StatPersistentCachePeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatPersistentCachePeer',
                request_serializer=scheduler__pb2.StatPersistentCachePeerRequest.SerializeToString,
                response_deserializer=common__pb2.PersistentCachePeer.FromString,
                _registered_method=True)
        self.DeletePersistentCachePeer = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeletePersistentCachePeer',
                request_serializer=scheduler__pb2.DeletePersistentCachePeerRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.UploadPersistentCacheTaskStarted = channel.unary_unary(
                '/scheduler.v2.Scheduler/UploadPersistentCacheTaskStarted',
                request_serializer=scheduler__pb2.UploadPersistentCacheTaskStartedRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.UploadPersistentCacheTaskFinished = channel.unary_unary(
                '/scheduler.v2.Scheduler/UploadPersistentCacheTaskFinished',
                request_serializer=scheduler__pb2.UploadPersistentCacheTaskFinishedRequest.SerializeToString,
                response_deserializer=common__pb2.PersistentCacheTask.FromString,
                _registered_method=True)
        self.UploadPersistentCacheTaskFailed = channel.unary_unary(
                '/scheduler.v2.Scheduler/UploadPersistentCacheTaskFailed',
                request_serializer=scheduler__pb2.UploadPersistentCacheTaskFailedRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.StatPersistentCacheTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatPersistentCacheTask',
                request_serializer=scheduler__pb2.StatPersistentCacheTaskRequest.SerializeToString,
                response_deserializer=common__pb2.PersistentCacheTask.FromString,
                _registered_method=True)
        self.DeletePersistentCacheTask = channel.unary_unary(
                '/scheduler.v2.Scheduler/DeletePersistentCacheTask',
                request_serializer=scheduler__pb2.DeletePersistentCacheTaskRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.PreheatImage = channel.unary_unary(
                '/scheduler.v2.Scheduler/PreheatImage',
                request_serializer=scheduler__pb2.PreheatImageRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.StatImage = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatImage',
                request_serializer=scheduler__pb2.StatImageRequest.SerializeToString,
                response_deserializer=scheduler__pb2.StatImageResponse.FromString,
                _registered_method=True)
        self.PreheatFile = channel.unary_unary(
                '/scheduler.v2.Scheduler/PreheatFile',
                request_serializer=scheduler__pb2.PreheatFileRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                _registered_method=True)
        self.StatFile = channel.unary_unary(
                '/scheduler.v2.Scheduler/StatFile',
                request_serializer=scheduler__pb2.StatFileRequest.SerializeToString,
                response_deserializer=scheduler__pb2.StatFileResponse.FromString,
                _registered_method=True)


class SchedulerServicer(object):
    """Scheduler RPC Service.
    """

    def AnnouncePeer(self, request_iterator, context):
        """AnnouncePeer announces peer to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatPeer(self, request, context):
        """Checks information of peer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeletePeer(self, request, context):
        """DeletePeer releases peer in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatTask(self, request, context):
        """Checks information of task.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteTask(self, request, context):
        """DeleteTask releases task in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AnnounceHost(self, request, context):
        """AnnounceHost announces host to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListHosts(self, request, context):
        """ListHosts lists hosts in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteHost(self, request, context):
        """DeleteHost releases host in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AnnounceCachePeer(self, request_iterator, context):
        """AnnounceCachePeer announces cache peer to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatCachePeer(self, request, context):
        """Checks information of cache peer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteCachePeer(self, request, context):
        """DeletCacheePeer releases cache peer in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatCacheTask(self, request, context):
        """Checks information of cache task.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteCacheTask(self, request, context):
        """DeleteCacheTask releases cache task in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AnnouncePersistentPeer(self, request_iterator, context):
        """AnnouncePersistentPeer announces persistent peer to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatPersistentPeer(self, request, context):
        """Checks information of persistent peer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeletePersistentPeer(self, request, context):
        """DeletePersistentPeer releases persistent peer in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UploadPersistentTaskStarted(self, request, context):
        """UploadPersistentTaskStarted uploads persistent task started to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UploadPersistentTaskFinished(self, request, context):
        """UploadPersistentTaskFinished uploads persistent task finished to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UploadPersistentTaskFailed(self, request, context):
        """UploadPersistentTaskFailed uploads persistent task failed to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatPersistentTask(self, request, context):
        """Checks information of persistent task.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeletePersistentTask(self, request, context):
        """DeletePersistentTask releases persistent task in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AnnouncePersistentCachePeer(self, request_iterator, context):
        """AnnouncePersistentCachePeer announces persistent cache peer to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatPersistentCachePeer(self, request, context):
        """Checks information of persistent cache peer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeletePersistentCachePeer(self, request, context):
        """DeletePersistentCachePeer releases persistent cache peer in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UploadPersistentCacheTaskStarted(self, request, context):
        """UploadPersistentCacheTaskStarted uploads persistent cache task started to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UploadPersistentCacheTaskFinished(self, request, context):
        """UploadPersistentCacheTaskFinished uploads persistent cache task finished to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UploadPersistentCacheTaskFailed(self, request, context):
        """UploadPersistentCacheTaskFailed uploads persistent cache task failed to scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatPersistentCacheTask(self, request, context):
        """Checks information of persistent cache task.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeletePersistentCacheTask(self, request, context):
        """DeletePersistentCacheTask releases persistent cache task in scheduler.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PreheatImage(self, request, context):
        """PreheatImage synchronously resolves an image manifest and triggers an asynchronous preheat task.

        This is a blocking call. The RPC will not return until the server has completed the
        initial synchronous work: resolving the image manifest and preparing all layer URLs.

        After this call successfully returns, a scheduler on the server begins the actual
        preheating process, instructing peers to download the layers in the background.

        A successful response (google.protobuf.Empty) confirms that the preparation is complete
        and the asynchronous download task has been scheduled.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatImage(self, request, context):
        """StatImage provides detailed status for a container image's distribution in peers.

        This is a blocking call that first resolves the image manifest and then queries
        all peers to collect the image's download state across the network.
        The response includes both layer information and the status on each peer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PreheatFile(self, request, context):
        """PreheatFile synchronously resolves a file URL and triggers an asynchronous preheat task.

        This is a blocking call. The RPC will not return until the server has completed the
        initial synchronous work: resolving the file URL.

        After this call successfully returns, a scheduler on the server begins the actual
        preheating process, instructing peers to download the file in the background.

        A successful response (google.protobuf.Empty) confirms that the preparation is complete
        and the asynchronous download task has been scheduled.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StatFile(self, request, context):
        """StatFile provides detailed status for a file's distribution in peers.

        This is a blocking call that first resolves the file URL and then queries
        all peers to collect the file's download state across the network.
        The response includes both file information and the status on each peer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_SchedulerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AnnouncePeer': grpc.stream_stream_rpc_method_handler(
                    servicer.AnnouncePeer,
                    request_deserializer=scheduler__pb2.AnnouncePeerRequest.FromString,
                    response_serializer=scheduler__pb2.AnnouncePeerResponse.SerializeToString,
            ),
            'StatPeer': grpc.unary_unary_rpc_method_handler(
                    servicer.StatPeer,
                    request_deserializer=scheduler__pb2.StatPeerRequest.FromString,
                    response_serializer=common__pb2.Peer.SerializeToString,
            ),
            'DeletePeer': grpc.unary_unary_rpc_method_handler(
                    servicer.DeletePeer,
                    request_deserializer=scheduler__pb2.DeletePeerRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'StatTask': grpc.unary_unary_rpc_method_handler(
                    servicer.StatTask,
                    request_deserializer=scheduler__pb2.StatTaskRequest.FromString,
                    response_serializer=common__pb2.Task.SerializeToString,
            ),
            'DeleteTask': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteTask,
                    request_deserializer=scheduler__pb2.DeleteTaskRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'AnnounceHost': grpc.unary_unary_rpc_method_handler(
                    servicer.AnnounceHost,
                    request_deserializer=scheduler__pb2.AnnounceHostRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'ListHosts': grpc.unary_unary_rpc_method_handler(
                    servicer.ListHosts,
                    request_deserializer=scheduler__pb2.ListHostsRequest.FromString,
                    response_serializer=scheduler__pb2.ListHostsResponse.SerializeToString,
            ),
            'DeleteHost': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteHost,
                    request_deserializer=scheduler__pb2.DeleteHostRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'AnnounceCachePeer': grpc.stream_stream_rpc_method_handler(
                    servicer.AnnounceCachePeer,
                    request_deserializer=scheduler__pb2.AnnounceCachePeerRequest.FromString,
                    response_serializer=scheduler__pb2.AnnounceCachePeerResponse.SerializeToString,
            ),
            'StatCachePeer': grpc.unary_unary_rpc_method_handler(
                    servicer.StatCachePeer,
                    request_deserializer=scheduler__pb2.StatCachePeerRequest.FromString,
                    response_serializer=common__pb2.CachePeer.SerializeToString,
            ),
            'DeleteCachePeer': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteCachePeer,
                    request_deserializer=scheduler__pb2.DeleteCachePeerRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'StatCacheTask': grpc.unary_unary_rpc_method_handler(
                    servicer.StatCacheTask,
                    request_deserializer=scheduler__pb2.StatCacheTaskRequest.FromString,
                    response_serializer=common__pb2.CacheTask.SerializeToString,
            ),
            'DeleteCacheTask': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteCacheTask,
                    request_deserializer=scheduler__pb2.DeleteCacheTaskRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'AnnouncePersistentPeer': grpc.stream_stream_rpc_method_handler(
                    servicer.AnnouncePersistentPeer,
                    request_deserializer=scheduler__pb2.AnnouncePersistentPeerRequest.FromString,
                    response_serializer=scheduler__pb2.AnnouncePersistentPeerResponse.SerializeToString,
            ),
            'StatPersistentPeer': grpc.unary_unary_rpc_method_handler(
                    servicer.StatPersistentPeer,
                    request_deserializer=scheduler__pb2.StatPersistentPeerRequest.FromString,
                    response_serializer=common__pb2.PersistentPeer.SerializeToString,
            ),
            'DeletePersistentPeer': grpc.unary_unary_rpc_method_handler(
                    servicer.DeletePersistentPeer,
                    request_deserializer=scheduler__pb2.DeletePersistentPeerRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'UploadPersistentTaskStarted': grpc.unary_unary_rpc_method_handler(
                    servicer.UploadPersistentTaskStarted,
                    request_deserializer=scheduler__pb2.UploadPersistentTaskStartedRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'UploadPersistentTaskFinished': grpc.unary_unary_rpc_method_handler(
                    servicer.UploadPersistentTaskFinished,
                    request_deserializer=scheduler__pb2.UploadPersistentTaskFinishedRequest.FromString,
                    response_serializer=common__pb2.PersistentTask.SerializeToString,
            ),
            'UploadPersistentTaskFailed': grpc.unary_unary_rpc_method_handler(
                    servicer.UploadPersistentTaskFailed,
                    request_deserializer=scheduler__pb2.UploadPersistentTaskFailedRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'StatPersistentTask': grpc.unary_unary_rpc_method_handler(
                    servicer.StatPersistentTask,
                    request_deserializer=scheduler__pb2.StatPersistentTaskRequest.FromString,
                    response_serializer=common__pb2.PersistentTask.SerializeToString,
            ),
            'DeletePersistentTask': grpc.unary_unary_rpc_method_handler(
                    servicer.DeletePersistentTask,
                    request_deserializer=scheduler__pb2.DeletePersistentTaskRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'AnnouncePersistentCachePeer': grpc.stream_stream_rpc_method_handler(
                    servicer.AnnouncePersistentCachePeer,
                    request_deserializer=scheduler__pb2.AnnouncePersistentCachePeerRequest.FromString,
                    response_serializer=scheduler__pb2.AnnouncePersistentCachePeerResponse.SerializeToString,
            ),
            'StatPersistentCachePeer': grpc.unary_unary_rpc_method_handler(
                    servicer.StatPersistentCachePeer,
                    request_deserializer=scheduler__pb2.StatPersistentCachePeerRequest.FromString,
                    response_serializer=common__pb2.PersistentCachePeer.SerializeToString,
            ),
            'DeletePersistentCachePeer': grpc.unary_unary_rpc_method_handler(
                    servicer.DeletePersistentCachePeer,
                    request_deserializer=scheduler__pb2.DeletePersistentCachePeerRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'UploadPersistentCacheTaskStarted': grpc.unary_unary_rpc_method_handler(
                    servicer.UploadPersistentCacheTaskStarted,
                    request_deserializer=scheduler__pb2.UploadPersistentCacheTaskStartedRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'UploadPersistentCacheTaskFinished': grpc.unary_unary_rpc_method_handler(
                    servicer.UploadPersistentCacheTaskFinished,
                    request_deserializer=scheduler__pb2.UploadPersistentCacheTaskFinishedRequest.FromString,
                    response_serializer=common__pb2.PersistentCacheTask.SerializeToString,
            ),
            'UploadPersistentCacheTaskFailed': grpc.unary_unary_rpc_method_handler(
                    servicer.UploadPersistentCacheTaskFailed,
                    request_deserializer=scheduler__pb2.UploadPersistentCacheTaskFailedRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'StatPersistentCacheTask': grpc.unary_unary_rpc_method_handler(
                    servicer.StatPersistentCacheTask,
                    request_deserializer=scheduler__pb2.StatPersistentCacheTaskRequest.FromString,
                    response_serializer=common__pb2.PersistentCacheTask.SerializeToString,
            ),
            'DeletePersistentCacheTask': grpc.unary_unary_rpc_method_handler(
                    servicer.DeletePersistentCacheTask,
                    request_deserializer=scheduler__pb2.DeletePersistentCacheTaskRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'PreheatImage': grpc.unary_unary_rpc_method_handler(
                    servicer.PreheatImage,
                    request_deserializer=scheduler__pb2.PreheatImageRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'StatImage': grpc.unary_unary_rpc_method_handler(
                    servicer.StatImage,
                    request_deserializer=scheduler__pb2.StatImageRequest.FromString,
                    response_serializer=scheduler__pb2.StatImageResponse.SerializeToString,
            ),
            'PreheatFile': grpc.unary_unary_rpc_method_handler(
                    servicer.PreheatFile,
                    request_deserializer=scheduler__pb2.PreheatFileRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'StatFile': grpc.unary_unary_rpc_method_handler(
                    servicer.StatFile,
                    request_deserializer=scheduler__pb2.StatFileRequest.FromString,
                    response_serializer=scheduler__pb2.StatFileResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'scheduler.v2.Scheduler', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('scheduler.v2.Scheduler', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Scheduler(object):
    """Scheduler RPC Service.
    """

    @staticmethod
    def AnnouncePeer(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/scheduler.v2.Scheduler/AnnouncePeer',
            scheduler__pb2.AnnouncePeerRequest.SerializeToString,
            scheduler__pb2.AnnouncePeerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatPeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatPeer',
            scheduler__pb2.StatPeerRequest.SerializeToString,
            common__pb2.Peer.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeletePeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeletePeer',
            scheduler__pb2.DeletePeerRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatTask',
            scheduler__pb2.StatTaskRequest.SerializeToString,
            common__pb2.Task.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeleteTask',
            scheduler__pb2.DeleteTaskRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnnounceHost(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/AnnounceHost',
            scheduler__pb2.AnnounceHostRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListHosts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/ListHosts',
            scheduler__pb2.ListHostsRequest.SerializeToString,
            scheduler__pb2.ListHostsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteHost(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeleteHost',
            scheduler__pb2.DeleteHostRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnnounceCachePeer(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/scheduler.v2.Scheduler/AnnounceCachePeer',
            scheduler__pb2.AnnounceCachePeerRequest.SerializeToString,
            scheduler__pb2.AnnounceCachePeerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatCachePeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatCachePeer',
            scheduler__pb2.StatCachePeerRequest.SerializeToString,
            common__pb2.CachePeer.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteCachePeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeleteCachePeer',
            scheduler__pb2.DeleteCachePeerRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatCacheTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatCacheTask',
            scheduler__pb2.StatCacheTaskRequest.SerializeToString,
            common__pb2.CacheTask.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteCacheTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeleteCacheTask',
            scheduler__pb2.DeleteCacheTaskRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnnouncePersistentPeer(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/scheduler.v2.Scheduler/AnnouncePersistentPeer',
            scheduler__pb2.AnnouncePersistentPeerRequest.SerializeToString,
            scheduler__pb2.AnnouncePersistentPeerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatPersistentPeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatPersistentPeer',
            scheduler__pb2.StatPersistentPeerRequest.SerializeToString,
            common__pb2.PersistentPeer.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeletePersistentPeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeletePersistentPeer',
            scheduler__pb2.DeletePersistentPeerRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UploadPersistentTaskStarted(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/UploadPersistentTaskStarted',
            scheduler__pb2.UploadPersistentTaskStartedRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UploadPersistentTaskFinished(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/UploadPersistentTaskFinished',
            scheduler__pb2.UploadPersistentTaskFinishedRequest.SerializeToString,
            common__pb2.PersistentTask.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UploadPersistentTaskFailed(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/UploadPersistentTaskFailed',
            scheduler__pb2.UploadPersistentTaskFailedRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatPersistentTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatPersistentTask',
            scheduler__pb2.StatPersistentTaskRequest.SerializeToString,
            common__pb2.PersistentTask.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeletePersistentTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeletePersistentTask',
            scheduler__pb2.DeletePersistentTaskRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnnouncePersistentCachePeer(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/scheduler.v2.Scheduler/AnnouncePersistentCachePeer',
            scheduler__pb2.AnnouncePersistentCachePeerRequest.SerializeToString,
            scheduler__pb2.AnnouncePersistentCachePeerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatPersistentCachePeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatPersistentCachePeer',
            scheduler__pb2.StatPersistentCachePeerRequest.SerializeToString,
            common__pb2.PersistentCachePeer.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeletePersistentCachePeer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeletePersistentCachePeer',
            scheduler__pb2.DeletePersistentCachePeerRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UploadPersistentCacheTaskStarted(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/UploadPersistentCacheTaskStarted',
            scheduler__pb2.UploadPersistentCacheTaskStartedRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UploadPersistentCacheTaskFinished(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/UploadPersistentCacheTaskFinished',
            scheduler__pb2.UploadPersistentCacheTaskFinishedRequest.SerializeToString,
            common__pb2.PersistentCacheTask.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UploadPersistentCacheTaskFailed(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/UploadPersistentCacheTaskFailed',
            scheduler__pb2.UploadPersistentCacheTaskFailedRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatPersistentCacheTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatPersistentCacheTask',
            scheduler__pb2.StatPersistentCacheTaskRequest.SerializeToString,
            common__pb2.PersistentCacheTask.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeletePersistentCacheTask(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/DeletePersistentCacheTask',
            scheduler__pb2.DeletePersistentCacheTaskRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PreheatImage(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/PreheatImage',
            scheduler__pb2.PreheatImageRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatImage(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatImage',
            scheduler__pb2.StatImageRequest.SerializeToString,
            scheduler__pb2.StatImageResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PreheatFile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/PreheatFile',
            scheduler__pb2.PreheatFileRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StatFile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/scheduler.v2.Scheduler/StatFile',
            scheduler__pb2.StatFileRequest.SerializeToString,
            scheduler__pb2.StatFileResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)