rawfile-localpv/csi/csi_pb2_grpc.py

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

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.v1.Identity/GetPluginInfo',
                request_serializer=csi__pb2.GetPluginInfoRequest.SerializeToString,
                response_deserializer=csi__pb2.GetPluginInfoResponse.FromString,
                )
        self.GetPluginCapabilities = channel.unary_unary(
                '/csi.v1.Identity/GetPluginCapabilities',
                request_serializer=csi__pb2.GetPluginCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.GetPluginCapabilitiesResponse.FromString,
                )
        self.Probe = channel.unary_unary(
                '/csi.v1.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.v1.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,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v1.Identity/GetPluginInfo',
            csi__pb2.GetPluginInfoRequest.SerializeToString,
            csi__pb2.GetPluginInfoResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetPluginCapabilities(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, '/csi.v1.Identity/GetPluginCapabilities',
            csi__pb2.GetPluginCapabilitiesRequest.SerializeToString,
            csi__pb2.GetPluginCapabilitiesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Probe(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, '/csi.v1.Identity/Probe',
            csi__pb2.ProbeRequest.SerializeToString,
            csi__pb2.ProbeResponse.FromString,
            options, channel_credentials,
            insecure, 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.v1.Controller/CreateVolume',
                request_serializer=csi__pb2.CreateVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.CreateVolumeResponse.FromString,
                )
        self.DeleteVolume = channel.unary_unary(
                '/csi.v1.Controller/DeleteVolume',
                request_serializer=csi__pb2.DeleteVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.DeleteVolumeResponse.FromString,
                )
        self.ControllerPublishVolume = channel.unary_unary(
                '/csi.v1.Controller/ControllerPublishVolume',
                request_serializer=csi__pb2.ControllerPublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerPublishVolumeResponse.FromString,
                )
        self.ControllerUnpublishVolume = channel.unary_unary(
                '/csi.v1.Controller/ControllerUnpublishVolume',
                request_serializer=csi__pb2.ControllerUnpublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerUnpublishVolumeResponse.FromString,
                )
        self.ValidateVolumeCapabilities = channel.unary_unary(
                '/csi.v1.Controller/ValidateVolumeCapabilities',
                request_serializer=csi__pb2.ValidateVolumeCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.ValidateVolumeCapabilitiesResponse.FromString,
                )
        self.ListVolumes = channel.unary_unary(
                '/csi.v1.Controller/ListVolumes',
                request_serializer=csi__pb2.ListVolumesRequest.SerializeToString,
                response_deserializer=csi__pb2.ListVolumesResponse.FromString,
                )
        self.GetCapacity = channel.unary_unary(
                '/csi.v1.Controller/GetCapacity',
                request_serializer=csi__pb2.GetCapacityRequest.SerializeToString,
                response_deserializer=csi__pb2.GetCapacityResponse.FromString,
                )
        self.ControllerGetCapabilities = channel.unary_unary(
                '/csi.v1.Controller/ControllerGetCapabilities',
                request_serializer=csi__pb2.ControllerGetCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerGetCapabilitiesResponse.FromString,
                )
        self.CreateSnapshot = channel.unary_unary(
                '/csi.v1.Controller/CreateSnapshot',
                request_serializer=csi__pb2.CreateSnapshotRequest.SerializeToString,
                response_deserializer=csi__pb2.CreateSnapshotResponse.FromString,
                )
        self.DeleteSnapshot = channel.unary_unary(
                '/csi.v1.Controller/DeleteSnapshot',
                request_serializer=csi__pb2.DeleteSnapshotRequest.SerializeToString,
                response_deserializer=csi__pb2.DeleteSnapshotResponse.FromString,
                )
        self.ListSnapshots = channel.unary_unary(
                '/csi.v1.Controller/ListSnapshots',
                request_serializer=csi__pb2.ListSnapshotsRequest.SerializeToString,
                response_deserializer=csi__pb2.ListSnapshotsResponse.FromString,
                )
        self.ControllerExpandVolume = channel.unary_unary(
                '/csi.v1.Controller/ControllerExpandVolume',
                request_serializer=csi__pb2.ControllerExpandVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerExpandVolumeResponse.FromString,
                )
        self.ControllerGetVolume = channel.unary_unary(
                '/csi.v1.Controller/ControllerGetVolume',
                request_serializer=csi__pb2.ControllerGetVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.ControllerGetVolumeResponse.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 ControllerExpandVolume(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 ControllerGetVolume(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,
            ),
            'ControllerExpandVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.ControllerExpandVolume,
                    request_deserializer=csi__pb2.ControllerExpandVolumeRequest.FromString,
                    response_serializer=csi__pb2.ControllerExpandVolumeResponse.SerializeToString,
            ),
            'ControllerGetVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.ControllerGetVolume,
                    request_deserializer=csi__pb2.ControllerGetVolumeRequest.FromString,
                    response_serializer=csi__pb2.ControllerGetVolumeResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'csi.v1.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,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v1.Controller/CreateVolume',
            csi__pb2.CreateVolumeRequest.SerializeToString,
            csi__pb2.CreateVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteVolume(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, '/csi.v1.Controller/DeleteVolume',
            csi__pb2.DeleteVolumeRequest.SerializeToString,
            csi__pb2.DeleteVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerPublishVolume(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, '/csi.v1.Controller/ControllerPublishVolume',
            csi__pb2.ControllerPublishVolumeRequest.SerializeToString,
            csi__pb2.ControllerPublishVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerUnpublishVolume(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, '/csi.v1.Controller/ControllerUnpublishVolume',
            csi__pb2.ControllerUnpublishVolumeRequest.SerializeToString,
            csi__pb2.ControllerUnpublishVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ValidateVolumeCapabilities(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, '/csi.v1.Controller/ValidateVolumeCapabilities',
            csi__pb2.ValidateVolumeCapabilitiesRequest.SerializeToString,
            csi__pb2.ValidateVolumeCapabilitiesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListVolumes(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, '/csi.v1.Controller/ListVolumes',
            csi__pb2.ListVolumesRequest.SerializeToString,
            csi__pb2.ListVolumesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetCapacity(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, '/csi.v1.Controller/GetCapacity',
            csi__pb2.GetCapacityRequest.SerializeToString,
            csi__pb2.GetCapacityResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerGetCapabilities(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, '/csi.v1.Controller/ControllerGetCapabilities',
            csi__pb2.ControllerGetCapabilitiesRequest.SerializeToString,
            csi__pb2.ControllerGetCapabilitiesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateSnapshot(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, '/csi.v1.Controller/CreateSnapshot',
            csi__pb2.CreateSnapshotRequest.SerializeToString,
            csi__pb2.CreateSnapshotResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteSnapshot(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, '/csi.v1.Controller/DeleteSnapshot',
            csi__pb2.DeleteSnapshotRequest.SerializeToString,
            csi__pb2.DeleteSnapshotResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListSnapshots(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, '/csi.v1.Controller/ListSnapshots',
            csi__pb2.ListSnapshotsRequest.SerializeToString,
            csi__pb2.ListSnapshotsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerExpandVolume(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, '/csi.v1.Controller/ControllerExpandVolume',
            csi__pb2.ControllerExpandVolumeRequest.SerializeToString,
            csi__pb2.ControllerExpandVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ControllerGetVolume(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, '/csi.v1.Controller/ControllerGetVolume',
            csi__pb2.ControllerGetVolumeRequest.SerializeToString,
            csi__pb2.ControllerGetVolumeResponse.FromString,
            options, channel_credentials,
            insecure, 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.v1.Node/NodeStageVolume',
                request_serializer=csi__pb2.NodeStageVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeStageVolumeResponse.FromString,
                )
        self.NodeUnstageVolume = channel.unary_unary(
                '/csi.v1.Node/NodeUnstageVolume',
                request_serializer=csi__pb2.NodeUnstageVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeUnstageVolumeResponse.FromString,
                )
        self.NodePublishVolume = channel.unary_unary(
                '/csi.v1.Node/NodePublishVolume',
                request_serializer=csi__pb2.NodePublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodePublishVolumeResponse.FromString,
                )
        self.NodeUnpublishVolume = channel.unary_unary(
                '/csi.v1.Node/NodeUnpublishVolume',
                request_serializer=csi__pb2.NodeUnpublishVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeUnpublishVolumeResponse.FromString,
                )
        self.NodeGetVolumeStats = channel.unary_unary(
                '/csi.v1.Node/NodeGetVolumeStats',
                request_serializer=csi__pb2.NodeGetVolumeStatsRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeGetVolumeStatsResponse.FromString,
                )
        self.NodeExpandVolume = channel.unary_unary(
                '/csi.v1.Node/NodeExpandVolume',
                request_serializer=csi__pb2.NodeExpandVolumeRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeExpandVolumeResponse.FromString,
                )
        self.NodeGetCapabilities = channel.unary_unary(
                '/csi.v1.Node/NodeGetCapabilities',
                request_serializer=csi__pb2.NodeGetCapabilitiesRequest.SerializeToString,
                response_deserializer=csi__pb2.NodeGetCapabilitiesResponse.FromString,
                )
        self.NodeGetInfo = channel.unary_unary(
                '/csi.v1.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 NodeGetVolumeStats(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 NodeExpandVolume(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 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):
        """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_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,
            ),
            'NodeGetVolumeStats': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeGetVolumeStats,
                    request_deserializer=csi__pb2.NodeGetVolumeStatsRequest.FromString,
                    response_serializer=csi__pb2.NodeGetVolumeStatsResponse.SerializeToString,
            ),
            'NodeExpandVolume': grpc.unary_unary_rpc_method_handler(
                    servicer.NodeExpandVolume,
                    request_deserializer=csi__pb2.NodeExpandVolumeRequest.FromString,
                    response_serializer=csi__pb2.NodeExpandVolumeResponse.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.v1.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,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/csi.v1.Node/NodeStageVolume',
            csi__pb2.NodeStageVolumeRequest.SerializeToString,
            csi__pb2.NodeStageVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeUnstageVolume(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, '/csi.v1.Node/NodeUnstageVolume',
            csi__pb2.NodeUnstageVolumeRequest.SerializeToString,
            csi__pb2.NodeUnstageVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodePublishVolume(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, '/csi.v1.Node/NodePublishVolume',
            csi__pb2.NodePublishVolumeRequest.SerializeToString,
            csi__pb2.NodePublishVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeUnpublishVolume(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, '/csi.v1.Node/NodeUnpublishVolume',
            csi__pb2.NodeUnpublishVolumeRequest.SerializeToString,
            csi__pb2.NodeUnpublishVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeGetVolumeStats(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, '/csi.v1.Node/NodeGetVolumeStats',
            csi__pb2.NodeGetVolumeStatsRequest.SerializeToString,
            csi__pb2.NodeGetVolumeStatsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeExpandVolume(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, '/csi.v1.Node/NodeExpandVolume',
            csi__pb2.NodeExpandVolumeRequest.SerializeToString,
            csi__pb2.NodeExpandVolumeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeGetCapabilities(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, '/csi.v1.Node/NodeGetCapabilities',
            csi__pb2.NodeGetCapabilitiesRequest.SerializeToString,
            csi__pb2.NodeGetCapabilitiesResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NodeGetInfo(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, '/csi.v1.Node/NodeGetInfo',
            csi__pb2.NodeGetInfoRequest.SerializeToString,
            csi__pb2.NodeGetInfoResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)