# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc

from . import csi_pb2 as csi__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetPluginInfo = channel.unary_unary(
                '/csi.v0.Identity/GetPluginInfo',
                request_serializer=csi__pb2.GetPluginInfoRequest.SerializeToString,
                response_deserializer=csi__pb2.GetPluginInfoResponse.FromString,
                )
        self.GetPluginCapabilities = channel.unary_unary(
                '/csi.v0.Identity/GetPluginCapabilities',
                request_serializer=csi__pb2.GetPluginCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.GetPluginCapabilitiesResponse.FromString,
                )
        self.Probe = channel.unary_unary(
                '/csi.v0.Identity/Probe',
                request_serializer=csi__pb2.ProbeRequest.SerializeToString,
                response_deserializer=csi__pb2.ProbeResponse.FromString,
                )


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

    def GetPluginInfo(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 GetPluginCapabilities(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 Probe(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_IdentityServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetPluginInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPluginInfo,
                    request_deserializer=csi__pb2.GetPluginInfoRequest.FromString,
                    response_serializer=csi__pb2.GetPluginInfoResponse.SerializeToString,
            ),
            'GetPluginCapabilities': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPluginCapabilities,
                    request_deserializer=csi__pb2.GetPluginCapabilitiesRequest.FromString,
                    response_serializer=csi__pb2.GetPluginCapabilitiesResponse.SerializeToString,
            ),
            'Probe': grpc.unary_unary_rpc_method_handler(
                    servicer.Probe,
                    request_deserializer=csi__pb2.ProbeRequest.FromString,
                    response_serializer=csi__pb2.ProbeResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'csi.v0.Identity', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def GetPluginInfo(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Identity/GetPluginInfo',
            csi__pb2.GetPluginInfoRequest.SerializeToString,
            csi__pb2.GetPluginInfoResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetPluginCapabilities(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Identity/GetPluginCapabilities',
            csi__pb2.GetPluginCapabilitiesRequest.SerializeToString,
            csi__pb2.GetPluginCapabilitiesResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Probe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Identity/Probe',
            csi__pb2.ProbeRequest.SerializeToString,
            csi__pb2.ProbeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateVolume = channel.unary_unary(
                '/csi.v0.Controller/CreateVolume',
                request_serializer=csi__pb2.CreateVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.CreateVolumeResponse.FromString,
                )
        self.DeleteVolume = channel.unary_unary(
                '/csi.v0.Controller/DeleteVolume',
                request_serializer=csi__pb2.DeleteVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.DeleteVolumeResponse.FromString,
                )
        self.ControllerPublishVolume = channel.unary_unary(
                '/csi.v0.Controller/ControllerPublishVolume',
                request_serializer=csi__pb2.ControllerPublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerPublishVolumeResponse.FromString,
                )
        self.ControllerUnpublishVolume = channel.unary_unary(
                '/csi.v0.Controller/ControllerUnpublishVolume',
                request_serializer=csi__pb2.ControllerUnpublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerUnpublishVolumeResponse.FromString,
                )
        self.ValidateVolumeCapabilities = channel.unary_unary(
                '/csi.v0.Controller/ValidateVolumeCapabilities',
                request_serializer=csi__pb2.ValidateVolumeCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.ValidateVolumeCapabilitiesResponse.FromString,
                )
        self.ListVolumes = channel.unary_unary(
                '/csi.v0.Controller/ListVolumes',
                request_serializer=csi__pb2.ListVolumesRequest.SerializeToString,
                response_deserializer=csi__pb2.ListVolumesResponse.FromString,
                )
        self.GetCapacity = channel.unary_unary(
                '/csi.v0.Controller/GetCapacity',
                request_serializer=csi__pb2.GetCapacityRequest.SerializeToString,
                response_deserializer=csi__pb2.GetCapacityResponse.FromString,
                )
        self.ControllerGetCapabilities = channel.unary_unary(
                '/csi.v0.Controller/ControllerGetCapabilities',
                request_serializer=csi__pb2.ControllerGetCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerGetCapabilitiesResponse.FromString,
                )
        self.CreateSnapshot = channel.unary_unary(
                '/csi.v0.Controller/CreateSnapshot',
                request_serializer=csi__pb2.CreateSnapshotRequest.SerializeToString,
                response_deserializer=csi__pb2.CreateSnapshotResponse.FromString,
                )
        self.DeleteSnapshot = channel.unary_unary(
                '/csi.v0.Controller/DeleteSnapshot',
                request_serializer=csi__pb2.DeleteSnapshotRequest.SerializeToString,
                response_deserializer=csi__pb2.DeleteSnapshotResponse.FromString,
                )
        self.ListSnapshots = channel.unary_unary(
                '/csi.v0.Controller/ListSnapshots',
                request_serializer=csi__pb2.ListSnapshotsRequest.SerializeToString,
                response_deserializer=csi__pb2.ListSnapshotsResponse.FromString,
                )


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

    def CreateVolume(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 DeleteVolume(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 ControllerPublishVolume(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 ControllerUnpublishVolume(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 ValidateVolumeCapabilities(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 ListVolumes(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 GetCapacity(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 ControllerGetCapabilities(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 CreateSnapshot(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 DeleteSnapshot(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 ListSnapshots(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_ControllerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateVolume,
                    request_deserializer=csi__pb2.CreateVolumeRequest.FromString,
                    response_serializer=csi__pb2.CreateVolumeResponse.SerializeToString,
            ),
            'DeleteVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteVolume,
                    request_deserializer=csi__pb2.DeleteVolumeRequest.FromString,
                    response_serializer=csi__pb2.DeleteVolumeResponse.SerializeToString,
            ),
            'ControllerPublishVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.ControllerPublishVolume,
                    request_deserializer=csi__pb2.ControllerPublishVolumeRequest.FromString,
                    response_serializer=csi__pb2.ControllerPublishVolumeResponse.SerializeToString,
            ),
            'ControllerUnpublishVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.ControllerUnpublishVolume,
                    request_deserializer=csi__pb2.ControllerUnpublishVolumeRequest.FromString,
                    response_serializer=csi__pb2.ControllerUnpublishVolumeResponse.SerializeToString,
            ),
            'ValidateVolumeCapabilities': grpc.unary_unary_rpc_method_handler(
                    servicer.ValidateVolumeCapabilities,
                    request_deserializer=csi__pb2.ValidateVolumeCapabilitiesRequest.FromString,
                    response_serializer=csi__pb2.ValidateVolumeCapabilitiesResponse.SerializeToString,
            ),
            'ListVolumes': grpc.unary_unary_rpc_method_handler(
                    servicer.ListVolumes,
                    request_deserializer=csi__pb2.ListVolumesRequest.FromString,
                    response_serializer=csi__pb2.ListVolumesResponse.SerializeToString,
            ),
            'GetCapacity': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCapacity,
                    request_deserializer=csi__pb2.GetCapacityRequest.FromString,
                    response_serializer=csi__pb2.GetCapacityResponse.SerializeToString,
            ),
            'ControllerGetCapabilities': grpc.unary_unary_rpc_method_handler(
                    servicer.ControllerGetCapabilities,
                    request_deserializer=csi__pb2.ControllerGetCapabilitiesRequest.FromString,
                    response_serializer=csi__pb2.ControllerGetCapabilitiesResponse.SerializeToString,
            ),
            'CreateSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSnapshot,
                    request_deserializer=csi__pb2.CreateSnapshotRequest.FromString,
                    response_serializer=csi__pb2.CreateSnapshotResponse.SerializeToString,
            ),
            'DeleteSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSnapshot,
                    request_deserializer=csi__pb2.DeleteSnapshotRequest.FromString,
                    response_serializer=csi__pb2.DeleteSnapshotResponse.SerializeToString,
            ),
            'ListSnapshots': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSnapshots,
                    request_deserializer=csi__pb2.ListSnapshotsRequest.FromString,
                    response_serializer=csi__pb2.ListSnapshotsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'csi.v0.Controller', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def CreateVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/CreateVolume',
            csi__pb2.CreateVolumeRequest.SerializeToString,
            csi__pb2.CreateVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/DeleteVolume',
            csi__pb2.DeleteVolumeRequest.SerializeToString,
            csi__pb2.DeleteVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerPublishVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/ControllerPublishVolume',
            csi__pb2.ControllerPublishVolumeRequest.SerializeToString,
            csi__pb2.ControllerPublishVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerUnpublishVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/ControllerUnpublishVolume',
            csi__pb2.ControllerUnpublishVolumeRequest.SerializeToString,
            csi__pb2.ControllerUnpublishVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ValidateVolumeCapabilities(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/ValidateVolumeCapabilities',
            csi__pb2.ValidateVolumeCapabilitiesRequest.SerializeToString,
            csi__pb2.ValidateVolumeCapabilitiesResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListVolumes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/ListVolumes',
            csi__pb2.ListVolumesRequest.SerializeToString,
            csi__pb2.ListVolumesResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetCapacity(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/GetCapacity',
            csi__pb2.GetCapacityRequest.SerializeToString,
            csi__pb2.GetCapacityResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerGetCapabilities(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/ControllerGetCapabilities',
            csi__pb2.ControllerGetCapabilitiesRequest.SerializeToString,
            csi__pb2.ControllerGetCapabilitiesResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateSnapshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/CreateSnapshot',
            csi__pb2.CreateSnapshotRequest.SerializeToString,
            csi__pb2.CreateSnapshotResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteSnapshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/DeleteSnapshot',
            csi__pb2.DeleteSnapshotRequest.SerializeToString,
            csi__pb2.DeleteSnapshotResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListSnapshots(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Controller/ListSnapshots',
            csi__pb2.ListSnapshotsRequest.SerializeToString,
            csi__pb2.ListSnapshotsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.NodeStageVolume = channel.unary_unary(
                '/csi.v0.Node/NodeStageVolume',
                request_serializer=csi__pb2.NodeStageVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeStageVolumeResponse.FromString,
                )
        self.NodeUnstageVolume = channel.unary_unary(
                '/csi.v0.Node/NodeUnstageVolume',
                request_serializer=csi__pb2.NodeUnstageVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeUnstageVolumeResponse.FromString,
                )
        self.NodePublishVolume = channel.unary_unary(
                '/csi.v0.Node/NodePublishVolume',
                request_serializer=csi__pb2.NodePublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodePublishVolumeResponse.FromString,
                )
        self.NodeUnpublishVolume = channel.unary_unary(
                '/csi.v0.Node/NodeUnpublishVolume',
                request_serializer=csi__pb2.NodeUnpublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeUnpublishVolumeResponse.FromString,
                )
        self.NodeGetId = channel.unary_unary(
                '/csi.v0.Node/NodeGetId',
                request_serializer=csi__pb2.NodeGetIdRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeGetIdResponse.FromString,
                )
        self.NodeGetCapabilities = channel.unary_unary(
                '/csi.v0.Node/NodeGetCapabilities',
                request_serializer=csi__pb2.NodeGetCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeGetCapabilitiesResponse.FromString,
                )
        self.NodeGetInfo = channel.unary_unary(
                '/csi.v0.Node/NodeGetInfo',
                request_serializer=csi__pb2.NodeGetInfoRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeGetInfoResponse.FromString,
                )


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

    def NodeStageVolume(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 NodeUnstageVolume(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 NodePublishVolume(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 NodeUnpublishVolume(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 NodeGetId(self, request, context):
        """NodeGetId is being deprecated in favor of NodeGetInfo and will be
        removed in CSI 1.0. Existing drivers, however, may depend on this
        RPC call and hence this RPC call MUST be implemented by the CSI
        plugin prior to v1.0.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NodeGetCapabilities(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 NodeGetInfo(self, request, context):
        """Prior to CSI 1.0 - CSI plugins MUST implement both NodeGetId and
        NodeGetInfo RPC calls.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_NodeServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'NodeStageVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeStageVolume,
                    request_deserializer=csi__pb2.NodeStageVolumeRequest.FromString,
                    response_serializer=csi__pb2.NodeStageVolumeResponse.SerializeToString,
            ),
            'NodeUnstageVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeUnstageVolume,
                    request_deserializer=csi__pb2.NodeUnstageVolumeRequest.FromString,
                    response_serializer=csi__pb2.NodeUnstageVolumeResponse.SerializeToString,
            ),
            'NodePublishVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.NodePublishVolume,
                    request_deserializer=csi__pb2.NodePublishVolumeRequest.FromString,
                    response_serializer=csi__pb2.NodePublishVolumeResponse.SerializeToString,
            ),
            'NodeUnpublishVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeUnpublishVolume,
                    request_deserializer=csi__pb2.NodeUnpublishVolumeRequest.FromString,
                    response_serializer=csi__pb2.NodeUnpublishVolumeResponse.SerializeToString,
            ),
            'NodeGetId': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeGetId,
                    request_deserializer=csi__pb2.NodeGetIdRequest.FromString,
                    response_serializer=csi__pb2.NodeGetIdResponse.SerializeToString,
            ),
            'NodeGetCapabilities': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeGetCapabilities,
                    request_deserializer=csi__pb2.NodeGetCapabilitiesRequest.FromString,
                    response_serializer=csi__pb2.NodeGetCapabilitiesResponse.SerializeToString,
            ),
            'NodeGetInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeGetInfo,
                    request_deserializer=csi__pb2.NodeGetInfoRequest.FromString,
                    response_serializer=csi__pb2.NodeGetInfoResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'csi.v0.Node', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def NodeStageVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Node/NodeStageVolume',
            csi__pb2.NodeStageVolumeRequest.SerializeToString,
            csi__pb2.NodeStageVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeUnstageVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Node/NodeUnstageVolume',
            csi__pb2.NodeUnstageVolumeRequest.SerializeToString,
            csi__pb2.NodeUnstageVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodePublishVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Node/NodePublishVolume',
            csi__pb2.NodePublishVolumeRequest.SerializeToString,
            csi__pb2.NodePublishVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeUnpublishVolume(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Node/NodeUnpublishVolume',
            csi__pb2.NodeUnpublishVolumeRequest.SerializeToString,
            csi__pb2.NodeUnpublishVolumeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeGetId(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Node/NodeGetId',
            csi__pb2.NodeGetIdRequest.SerializeToString,
            csi__pb2.NodeGetIdResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeGetCapabilities(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Node/NodeGetCapabilities',
            csi__pb2.NodeGetCapabilitiesRequest.SerializeToString,
            csi__pb2.NodeGetCapabilitiesResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeGetInfo(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v0.Node/NodeGetInfo',
            csi__pb2.NodeGetInfoRequest.SerializeToString,
            csi__pb2.NodeGetInfoResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)
