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

from envoy.service.network_ext_proc.v3 import network_external_processor_pb2 as envoy_dot_service_dot_network__ext__proc_dot_v3_dot_network__external__processor__pb2

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

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

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in envoy/service/network_ext_proc/v3/network_external_processor_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 NetworkExternalProcessorStub(object):
    """[#protodoc-title: Network External Processing Service]

    The Network External Processing filter allows an external service to dynamically
    interact with and modify L4 network traffic passing through Envoy. Unlike the
    HTTP External Processing filter, this service operates at the TCP/UDP level,
    providing access to raw network data.

    The filter communicates with an external gRPC service that can:

    1. Inspect network traffic in both directions (client->server and server->client)
    2. Modify the payload data
    3. Control connection lifecycle (continue, close gracefully, or reset)

    Use cases include:

    1. Custom protocol inspection and modification
    2. Advanced traffic manipulation
    3. Security scanning and filtering
    4. Dynamic connection management

    The service uses a bidirectional gRPC stream, maintaining state throughout
    the connection lifetime while allowing asynchronous processing.

    NetworkExternalProcessor service defines the contract between Envoy and
    external processing servers for L4 network traffic.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Process = channel.stream_stream(
                '/envoy.service.network_ext_proc.v3.NetworkExternalProcessor/Process',
                request_serializer=envoy_dot_service_dot_network__ext__proc_dot_v3_dot_network__external__processor__pb2.ProcessingRequest.SerializeToString,
                response_deserializer=envoy_dot_service_dot_network__ext__proc_dot_v3_dot_network__external__processor__pb2.ProcessingResponse.FromString,
                _registered_method=True)


class NetworkExternalProcessorServicer(object):
    """[#protodoc-title: Network External Processing Service]

    The Network External Processing filter allows an external service to dynamically
    interact with and modify L4 network traffic passing through Envoy. Unlike the
    HTTP External Processing filter, this service operates at the TCP/UDP level,
    providing access to raw network data.

    The filter communicates with an external gRPC service that can:

    1. Inspect network traffic in both directions (client->server and server->client)
    2. Modify the payload data
    3. Control connection lifecycle (continue, close gracefully, or reset)

    Use cases include:

    1. Custom protocol inspection and modification
    2. Advanced traffic manipulation
    3. Security scanning and filtering
    4. Dynamic connection management

    The service uses a bidirectional gRPC stream, maintaining state throughout
    the connection lifetime while allowing asynchronous processing.

    NetworkExternalProcessor service defines the contract between Envoy and
    external processing servers for L4 network traffic.
    """

    def Process(self, request_iterator, context):
        """Process establishes a bidirectional stream between Envoy and the external
        processing server. Envoy sends ProcessingRequests containing network data
        and the server responds with ProcessingResponses containing processing
        decisions and potentially modified data.

        The server should handle processing timeout properly to avoid blocking
        network traffic for extended periods. Any uncaught exceptions will
        be treated as errors and will terminate the stream.

        Implementation note: The server should process requests in the order
        they are received to maintain proper sequencing of network traffic.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_NetworkExternalProcessorServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Process': grpc.stream_stream_rpc_method_handler(
                    servicer.Process,
                    request_deserializer=envoy_dot_service_dot_network__ext__proc_dot_v3_dot_network__external__processor__pb2.ProcessingRequest.FromString,
                    response_serializer=envoy_dot_service_dot_network__ext__proc_dot_v3_dot_network__external__processor__pb2.ProcessingResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'envoy.service.network_ext_proc.v3.NetworkExternalProcessor', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('envoy.service.network_ext_proc.v3.NetworkExternalProcessor', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class NetworkExternalProcessor(object):
    """[#protodoc-title: Network External Processing Service]

    The Network External Processing filter allows an external service to dynamically
    interact with and modify L4 network traffic passing through Envoy. Unlike the
    HTTP External Processing filter, this service operates at the TCP/UDP level,
    providing access to raw network data.

    The filter communicates with an external gRPC service that can:

    1. Inspect network traffic in both directions (client->server and server->client)
    2. Modify the payload data
    3. Control connection lifecycle (continue, close gracefully, or reset)

    Use cases include:

    1. Custom protocol inspection and modification
    2. Advanced traffic manipulation
    3. Security scanning and filtering
    4. Dynamic connection management

    The service uses a bidirectional gRPC stream, maintaining state throughout
    the connection lifetime while allowing asynchronous processing.

    NetworkExternalProcessor service defines the contract between Envoy and
    external processing servers for L4 network traffic.
    """

    @staticmethod
    def Process(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/envoy.service.network_ext_proc.v3.NetworkExternalProcessor/Process',
            envoy_dot_service_dot_network__ext__proc_dot_v3_dot_network__external__processor__pb2.ProcessingRequest.SerializeToString,
            envoy_dot_service_dot_network__ext__proc_dot_v3_dot_network__external__processor__pb2.ProcessingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
