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

import nodepool_pb2 as nodepool__pb2

GRPC_GENERATED_VERSION = '1.73.1'
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},'
        + f' but the generated code in nodepool_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 UserServiceStub(object):
    """服務定義
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Login = channel.unary_unary(
                '/nodepool.UserService/Login',
                request_serializer=nodepool__pb2.LoginRequest.SerializeToString,
                response_deserializer=nodepool__pb2.LoginResponse.FromString,
                _registered_method=True)
        self.Register = channel.unary_unary(
                '/nodepool.UserService/Register',
                request_serializer=nodepool__pb2.RegisterRequest.SerializeToString,
                response_deserializer=nodepool__pb2.RegisterResponse.FromString,
                _registered_method=True)
        self.Transfer = channel.unary_unary(
                '/nodepool.UserService/Transfer',
                request_serializer=nodepool__pb2.TransferRequest.SerializeToString,
                response_deserializer=nodepool__pb2.TransferResponse.FromString,
                _registered_method=True)
        self.GetBalance = channel.unary_unary(
                '/nodepool.UserService/GetBalance',
                request_serializer=nodepool__pb2.GetBalanceRequest.SerializeToString,
                response_deserializer=nodepool__pb2.GetBalanceResponse.FromString,
                _registered_method=True)


class UserServiceServicer(object):
    """服務定義
    """

    def Login(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Register(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Transfer(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetBalance(self, request, context):
        """新增 GetBalance RPC
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_UserServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Login': grpc.unary_unary_rpc_method_handler(
                    servicer.Login,
                    request_deserializer=nodepool__pb2.LoginRequest.FromString,
                    response_serializer=nodepool__pb2.LoginResponse.SerializeToString,
            ),
            'Register': grpc.unary_unary_rpc_method_handler(
                    servicer.Register,
                    request_deserializer=nodepool__pb2.RegisterRequest.FromString,
                    response_serializer=nodepool__pb2.RegisterResponse.SerializeToString,
            ),
            'Transfer': grpc.unary_unary_rpc_method_handler(
                    servicer.Transfer,
                    request_deserializer=nodepool__pb2.TransferRequest.FromString,
                    response_serializer=nodepool__pb2.TransferResponse.SerializeToString,
            ),
            'GetBalance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBalance,
                    request_deserializer=nodepool__pb2.GetBalanceRequest.FromString,
                    response_serializer=nodepool__pb2.GetBalanceResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'nodepool.UserService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('nodepool.UserService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class UserService(object):
    """服務定義
    """

    @staticmethod
    def Login(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,
            '/nodepool.UserService/Login',
            nodepool__pb2.LoginRequest.SerializeToString,
            nodepool__pb2.LoginResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Register(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,
            '/nodepool.UserService/Register',
            nodepool__pb2.RegisterRequest.SerializeToString,
            nodepool__pb2.RegisterResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Transfer(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,
            '/nodepool.UserService/Transfer',
            nodepool__pb2.TransferRequest.SerializeToString,
            nodepool__pb2.TransferResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBalance(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,
            '/nodepool.UserService/GetBalance',
            nodepool__pb2.GetBalanceRequest.SerializeToString,
            nodepool__pb2.GetBalanceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class NodeManagerServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.RegisterWorkerNode = channel.unary_unary(
                '/nodepool.NodeManagerService/RegisterWorkerNode',
                request_serializer=nodepool__pb2.RegisterWorkerNodeRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.HealthCheck = channel.unary_unary(
                '/nodepool.NodeManagerService/HealthCheck',
                request_serializer=nodepool__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=nodepool__pb2.HealthCheckResponse.FromString,
                _registered_method=True)
        self.ReportStatus = channel.unary_unary(
                '/nodepool.NodeManagerService/ReportStatus',
                request_serializer=nodepool__pb2.ReportStatusRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.GetNodeList = channel.unary_unary(
                '/nodepool.NodeManagerService/GetNodeList',
                request_serializer=nodepool__pb2.GetNodeListRequest.SerializeToString,
                response_deserializer=nodepool__pb2.GetNodeListResponse.FromString,
                _registered_method=True)


class NodeManagerServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def RegisterWorkerNode(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HealthCheck(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReportStatus(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNodeList(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_NodeManagerServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RegisterWorkerNode': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterWorkerNode,
                    request_deserializer=nodepool__pb2.RegisterWorkerNodeRequest.FromString,
                    response_serializer=nodepool__pb2.StatusResponse.SerializeToString,
            ),
            'HealthCheck': grpc.unary_unary_rpc_method_handler(
                    servicer.HealthCheck,
                    request_deserializer=nodepool__pb2.HealthCheckRequest.FromString,
                    response_serializer=nodepool__pb2.HealthCheckResponse.SerializeToString,
            ),
            'ReportStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportStatus,
                    request_deserializer=nodepool__pb2.ReportStatusRequest.FromString,
                    response_serializer=nodepool__pb2.StatusResponse.SerializeToString,
            ),
            'GetNodeList': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNodeList,
                    request_deserializer=nodepool__pb2.GetNodeListRequest.FromString,
                    response_serializer=nodepool__pb2.GetNodeListResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'nodepool.NodeManagerService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('nodepool.NodeManagerService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class NodeManagerService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def RegisterWorkerNode(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,
            '/nodepool.NodeManagerService/RegisterWorkerNode',
            nodepool__pb2.RegisterWorkerNodeRequest.SerializeToString,
            nodepool__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HealthCheck(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,
            '/nodepool.NodeManagerService/HealthCheck',
            nodepool__pb2.HealthCheckRequest.SerializeToString,
            nodepool__pb2.HealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportStatus(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,
            '/nodepool.NodeManagerService/ReportStatus',
            nodepool__pb2.ReportStatusRequest.SerializeToString,
            nodepool__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetNodeList(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,
            '/nodepool.NodeManagerService/GetNodeList',
            nodepool__pb2.GetNodeListRequest.SerializeToString,
            nodepool__pb2.GetNodeListResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class MasterNodeServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.UploadTask = channel.unary_unary(
                '/nodepool.MasterNodeService/UploadTask',
                request_serializer=nodepool__pb2.UploadTaskRequest.SerializeToString,
                response_deserializer=nodepool__pb2.UploadTaskResponse.FromString,
                _registered_method=True)
        self.PollTaskStatus = channel.unary_unary(
                '/nodepool.MasterNodeService/PollTaskStatus',
                request_serializer=nodepool__pb2.PollTaskStatusRequest.SerializeToString,
                response_deserializer=nodepool__pb2.PollTaskStatusResponse.FromString,
                _registered_method=True)
        self.StoreOutput = channel.unary_unary(
                '/nodepool.MasterNodeService/StoreOutput',
                request_serializer=nodepool__pb2.StoreOutputRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.StoreResult = channel.unary_unary(
                '/nodepool.MasterNodeService/StoreResult',
                request_serializer=nodepool__pb2.StoreResultRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.GetTaskResult = channel.unary_unary(
                '/nodepool.MasterNodeService/GetTaskResult',
                request_serializer=nodepool__pb2.GetTaskResultRequest.SerializeToString,
                response_deserializer=nodepool__pb2.GetTaskResultResponse.FromString,
                _registered_method=True)
        self.TaskCompleted = channel.unary_unary(
                '/nodepool.MasterNodeService/TaskCompleted',
                request_serializer=nodepool__pb2.TaskCompletedRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.StoreLogs = channel.unary_unary(
                '/nodepool.MasterNodeService/StoreLogs',
                request_serializer=nodepool__pb2.StoreLogsRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.GetTaskLogs = channel.unary_unary(
                '/nodepool.MasterNodeService/GetTaskLogs',
                request_serializer=nodepool__pb2.GetTaskLogsRequest.SerializeToString,
                response_deserializer=nodepool__pb2.GetTaskLogsResponse.FromString,
                _registered_method=True)
        self.GetAllTasks = channel.unary_unary(
                '/nodepool.MasterNodeService/GetAllTasks',
                request_serializer=nodepool__pb2.GetAllTasksRequest.SerializeToString,
                response_deserializer=nodepool__pb2.GetAllTasksResponse.FromString,
                _registered_method=True)
        self.StopTask = channel.unary_unary(
                '/nodepool.MasterNodeService/StopTask',
                request_serializer=nodepool__pb2.StopTaskRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StopTaskResponse.FromString,
                _registered_method=True)
        self.ReturnTaskResult = channel.unary_unary(
                '/nodepool.MasterNodeService/ReturnTaskResult',
                request_serializer=nodepool__pb2.ReturnTaskResultRequest.SerializeToString,
                response_deserializer=nodepool__pb2.ReturnTaskResultResponse.FromString,
                _registered_method=True)


class MasterNodeServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def UploadTask(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PollTaskStatus(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StoreOutput(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StoreResult(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetTaskResult(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TaskCompleted(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StoreLogs(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetTaskLogs(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetAllTasks(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopTask(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReturnTaskResult(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_MasterNodeServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'UploadTask': grpc.unary_unary_rpc_method_handler(
                    servicer.UploadTask,
                    request_deserializer=nodepool__pb2.UploadTaskRequest.FromString,
                    response_serializer=nodepool__pb2.UploadTaskResponse.SerializeToString,
            ),
            'PollTaskStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.PollTaskStatus,
                    request_deserializer=nodepool__pb2.PollTaskStatusRequest.FromString,
                    response_serializer=nodepool__pb2.PollTaskStatusResponse.SerializeToString,
            ),
            'StoreOutput': grpc.unary_unary_rpc_method_handler(
                    servicer.StoreOutput,
                    request_deserializer=nodepool__pb2.StoreOutputRequest.FromString,
                    response_serializer=nodepool__pb2.StatusResponse.SerializeToString,
            ),
            'StoreResult': grpc.unary_unary_rpc_method_handler(
                    servicer.StoreResult,
                    request_deserializer=nodepool__pb2.StoreResultRequest.FromString,
                    response_serializer=nodepool__pb2.StatusResponse.SerializeToString,
            ),
            'GetTaskResult': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTaskResult,
                    request_deserializer=nodepool__pb2.GetTaskResultRequest.FromString,
                    response_serializer=nodepool__pb2.GetTaskResultResponse.SerializeToString,
            ),
            'TaskCompleted': grpc.unary_unary_rpc_method_handler(
                    servicer.TaskCompleted,
                    request_deserializer=nodepool__pb2.TaskCompletedRequest.FromString,
                    response_serializer=nodepool__pb2.StatusResponse.SerializeToString,
            ),
            'StoreLogs': grpc.unary_unary_rpc_method_handler(
                    servicer.StoreLogs,
                    request_deserializer=nodepool__pb2.StoreLogsRequest.FromString,
                    response_serializer=nodepool__pb2.StatusResponse.SerializeToString,
            ),
            'GetTaskLogs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTaskLogs,
                    request_deserializer=nodepool__pb2.GetTaskLogsRequest.FromString,
                    response_serializer=nodepool__pb2.GetTaskLogsResponse.SerializeToString,
            ),
            'GetAllTasks': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAllTasks,
                    request_deserializer=nodepool__pb2.GetAllTasksRequest.FromString,
                    response_serializer=nodepool__pb2.GetAllTasksResponse.SerializeToString,
            ),
            'StopTask': grpc.unary_unary_rpc_method_handler(
                    servicer.StopTask,
                    request_deserializer=nodepool__pb2.StopTaskRequest.FromString,
                    response_serializer=nodepool__pb2.StopTaskResponse.SerializeToString,
            ),
            'ReturnTaskResult': grpc.unary_unary_rpc_method_handler(
                    servicer.ReturnTaskResult,
                    request_deserializer=nodepool__pb2.ReturnTaskResultRequest.FromString,
                    response_serializer=nodepool__pb2.ReturnTaskResultResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'nodepool.MasterNodeService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('nodepool.MasterNodeService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class MasterNodeService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def UploadTask(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,
            '/nodepool.MasterNodeService/UploadTask',
            nodepool__pb2.UploadTaskRequest.SerializeToString,
            nodepool__pb2.UploadTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PollTaskStatus(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,
            '/nodepool.MasterNodeService/PollTaskStatus',
            nodepool__pb2.PollTaskStatusRequest.SerializeToString,
            nodepool__pb2.PollTaskStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StoreOutput(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,
            '/nodepool.MasterNodeService/StoreOutput',
            nodepool__pb2.StoreOutputRequest.SerializeToString,
            nodepool__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StoreResult(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,
            '/nodepool.MasterNodeService/StoreResult',
            nodepool__pb2.StoreResultRequest.SerializeToString,
            nodepool__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTaskResult(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,
            '/nodepool.MasterNodeService/GetTaskResult',
            nodepool__pb2.GetTaskResultRequest.SerializeToString,
            nodepool__pb2.GetTaskResultResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TaskCompleted(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,
            '/nodepool.MasterNodeService/TaskCompleted',
            nodepool__pb2.TaskCompletedRequest.SerializeToString,
            nodepool__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StoreLogs(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,
            '/nodepool.MasterNodeService/StoreLogs',
            nodepool__pb2.StoreLogsRequest.SerializeToString,
            nodepool__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTaskLogs(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,
            '/nodepool.MasterNodeService/GetTaskLogs',
            nodepool__pb2.GetTaskLogsRequest.SerializeToString,
            nodepool__pb2.GetTaskLogsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAllTasks(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,
            '/nodepool.MasterNodeService/GetAllTasks',
            nodepool__pb2.GetAllTasksRequest.SerializeToString,
            nodepool__pb2.GetAllTasksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopTask(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,
            '/nodepool.MasterNodeService/StopTask',
            nodepool__pb2.StopTaskRequest.SerializeToString,
            nodepool__pb2.StopTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReturnTaskResult(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,
            '/nodepool.MasterNodeService/ReturnTaskResult',
            nodepool__pb2.ReturnTaskResultRequest.SerializeToString,
            nodepool__pb2.ReturnTaskResultResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class WorkerNodeServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.ExecuteTask = channel.unary_unary(
                '/nodepool.WorkerNodeService/ExecuteTask',
                request_serializer=nodepool__pb2.ExecuteTaskRequest.SerializeToString,
                response_deserializer=nodepool__pb2.ExecuteTaskResponse.FromString,
                _registered_method=True)
        self.ReportOutput = channel.unary_unary(
                '/nodepool.WorkerNodeService/ReportOutput',
                request_serializer=nodepool__pb2.ReportOutputRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.ReportRunningStatus = channel.unary_unary(
                '/nodepool.WorkerNodeService/ReportRunningStatus',
                request_serializer=nodepool__pb2.RunningStatusRequest.SerializeToString,
                response_deserializer=nodepool__pb2.RunningStatusResponse.FromString,
                _registered_method=True)
        self.StopTaskExecution = channel.unary_unary(
                '/nodepool.WorkerNodeService/StopTaskExecution',
                request_serializer=nodepool__pb2.StopTaskExecutionRequest.SerializeToString,
                response_deserializer=nodepool__pb2.StopTaskExecutionResponse.FromString,
                _registered_method=True)


class WorkerNodeServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def ExecuteTask(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReportOutput(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReportRunningStatus(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopTaskExecution(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_WorkerNodeServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ExecuteTask': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteTask,
                    request_deserializer=nodepool__pb2.ExecuteTaskRequest.FromString,
                    response_serializer=nodepool__pb2.ExecuteTaskResponse.SerializeToString,
            ),
            'ReportOutput': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportOutput,
                    request_deserializer=nodepool__pb2.ReportOutputRequest.FromString,
                    response_serializer=nodepool__pb2.StatusResponse.SerializeToString,
            ),
            'ReportRunningStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportRunningStatus,
                    request_deserializer=nodepool__pb2.RunningStatusRequest.FromString,
                    response_serializer=nodepool__pb2.RunningStatusResponse.SerializeToString,
            ),
            'StopTaskExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.StopTaskExecution,
                    request_deserializer=nodepool__pb2.StopTaskExecutionRequest.FromString,
                    response_serializer=nodepool__pb2.StopTaskExecutionResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'nodepool.WorkerNodeService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('nodepool.WorkerNodeService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class WorkerNodeService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def ExecuteTask(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,
            '/nodepool.WorkerNodeService/ExecuteTask',
            nodepool__pb2.ExecuteTaskRequest.SerializeToString,
            nodepool__pb2.ExecuteTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportOutput(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,
            '/nodepool.WorkerNodeService/ReportOutput',
            nodepool__pb2.ReportOutputRequest.SerializeToString,
            nodepool__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportRunningStatus(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,
            '/nodepool.WorkerNodeService/ReportRunningStatus',
            nodepool__pb2.RunningStatusRequest.SerializeToString,
            nodepool__pb2.RunningStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopTaskExecution(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,
            '/nodepool.WorkerNodeService/StopTaskExecution',
            nodepool__pb2.StopTaskExecutionRequest.SerializeToString,
            nodepool__pb2.StopTaskExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
