dragonfly-api 2.3.0__py3-none-any.whl

dragonfly_api/scheduler_pb2_grpc.py

@@ -0,0 +1,1537 @@
+# 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)