| # Copyright 2016, Google Inc. |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following disclaimer |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| """Translates gRPC's server-side API into gRPC's server-side Beta API.""" |
| |
| import collections |
| import threading |
| |
| import grpc |
| from grpc import _common |
| from grpc.beta import interfaces |
| from grpc.framework.common import cardinality |
| from grpc.framework.common import style |
| from grpc.framework.foundation import abandonment |
| from grpc.framework.foundation import logging_pool |
| from grpc.framework.foundation import stream |
| from grpc.framework.interfaces.face import face |
| |
| _DEFAULT_POOL_SIZE = 8 |
| |
| |
| class _ServerProtocolContext(interfaces.GRPCServicerContext): |
| |
| def __init__(self, servicer_context): |
| self._servicer_context = servicer_context |
| |
| def peer(self): |
| return self._servicer_context.peer() |
| |
| def disable_next_response_compression(self): |
| pass # TODO(https://github.com/grpc/grpc/issues/4078): design, implement. |
| |
| |
| class _FaceServicerContext(face.ServicerContext): |
| |
| def __init__(self, servicer_context): |
| self._servicer_context = servicer_context |
| |
| def is_active(self): |
| return self._servicer_context.is_active() |
| |
| def time_remaining(self): |
| return self._servicer_context.time_remaining() |
| |
| def add_abortion_callback(self, abortion_callback): |
| raise NotImplementedError( |
| 'add_abortion_callback no longer supported server-side!') |
| |
| def cancel(self): |
| self._servicer_context.cancel() |
| |
| def protocol_context(self): |
| return _ServerProtocolContext(self._servicer_context) |
| |
| def invocation_metadata(self): |
| return _common.cygrpc_metadata( |
| self._servicer_context.invocation_metadata()) |
| |
| def initial_metadata(self, initial_metadata): |
| self._servicer_context.send_initial_metadata(initial_metadata) |
| |
| def terminal_metadata(self, terminal_metadata): |
| self._servicer_context.set_terminal_metadata(terminal_metadata) |
| |
| def code(self, code): |
| self._servicer_context.set_code(code) |
| |
| def details(self, details): |
| self._servicer_context.set_details(details) |
| |
| |
| def _adapt_unary_request_inline(unary_request_inline): |
| def adaptation(request, servicer_context): |
| return unary_request_inline(request, _FaceServicerContext(servicer_context)) |
| return adaptation |
| |
| |
| def _adapt_stream_request_inline(stream_request_inline): |
| def adaptation(request_iterator, servicer_context): |
| return stream_request_inline( |
| request_iterator, _FaceServicerContext(servicer_context)) |
| return adaptation |
| |
| |
| class _Callback(stream.Consumer): |
| |
| def __init__(self): |
| self._condition = threading.Condition() |
| self._values = [] |
| self._terminated = False |
| self._cancelled = False |
| |
| def consume(self, value): |
| with self._condition: |
| self._values.append(value) |
| self._condition.notify_all() |
| |
| def terminate(self): |
| with self._condition: |
| self._terminated = True |
| self._condition.notify_all() |
| |
| def consume_and_terminate(self, value): |
| with self._condition: |
| self._values.append(value) |
| self._terminated = True |
| self._condition.notify_all() |
| |
| def cancel(self): |
| with self._condition: |
| self._cancelled = True |
| self._condition.notify_all() |
| |
| def draw_one_value(self): |
| with self._condition: |
| while True: |
| if self._cancelled: |
| raise abandonment.Abandoned() |
| elif self._values: |
| return self._values.pop(0) |
| elif self._terminated: |
| return None |
| else: |
| self._condition.wait() |
| |
| def draw_all_values(self): |
| with self._condition: |
| while True: |
| if self._cancelled: |
| raise abandonment.Abandoned() |
| elif self._terminated: |
| all_values = tuple(self._values) |
| self._values = None |
| return all_values |
| else: |
| self._condition.wait() |
| |
| |
| def _run_request_pipe_thread(request_iterator, request_consumer, |
| servicer_context): |
| thread_joined = threading.Event() |
| def pipe_requests(): |
| for request in request_iterator: |
| if not servicer_context.is_active() or thread_joined.is_set(): |
| return |
| request_consumer.consume(request) |
| if not servicer_context.is_active() or thread_joined.is_set(): |
| return |
| request_consumer.terminate() |
| |
| def stop_request_pipe(timeout): |
| thread_joined.set() |
| |
| request_pipe_thread = _common.CleanupThread( |
| stop_request_pipe, target=pipe_requests) |
| request_pipe_thread.start() |
| |
| |
| def _adapt_unary_unary_event(unary_unary_event): |
| def adaptation(request, servicer_context): |
| callback = _Callback() |
| if not servicer_context.add_callback(callback.cancel): |
| raise abandonment.Abandoned() |
| unary_unary_event( |
| request, callback.consume_and_terminate, |
| _FaceServicerContext(servicer_context)) |
| return callback.draw_all_values()[0] |
| return adaptation |
| |
| |
| def _adapt_unary_stream_event(unary_stream_event): |
| def adaptation(request, servicer_context): |
| callback = _Callback() |
| if not servicer_context.add_callback(callback.cancel): |
| raise abandonment.Abandoned() |
| unary_stream_event( |
| request, callback, _FaceServicerContext(servicer_context)) |
| while True: |
| response = callback.draw_one_value() |
| if response is None: |
| return |
| else: |
| yield response |
| return adaptation |
| |
| |
| def _adapt_stream_unary_event(stream_unary_event): |
| def adaptation(request_iterator, servicer_context): |
| callback = _Callback() |
| if not servicer_context.add_callback(callback.cancel): |
| raise abandonment.Abandoned() |
| request_consumer = stream_unary_event( |
| callback.consume_and_terminate, _FaceServicerContext(servicer_context)) |
| _run_request_pipe_thread( |
| request_iterator, request_consumer, servicer_context) |
| return callback.draw_all_values()[0] |
| return adaptation |
| |
| |
| def _adapt_stream_stream_event(stream_stream_event): |
| def adaptation(request_iterator, servicer_context): |
| callback = _Callback() |
| if not servicer_context.add_callback(callback.cancel): |
| raise abandonment.Abandoned() |
| request_consumer = stream_stream_event( |
| callback, _FaceServicerContext(servicer_context)) |
| _run_request_pipe_thread( |
| request_iterator, request_consumer, servicer_context) |
| while True: |
| response = callback.draw_one_value() |
| if response is None: |
| return |
| else: |
| yield response |
| return adaptation |
| |
| |
| class _SimpleMethodHandler( |
| collections.namedtuple( |
| '_MethodHandler', |
| ('request_streaming', 'response_streaming', 'request_deserializer', |
| 'response_serializer', 'unary_unary', 'unary_stream', 'stream_unary', |
| 'stream_stream',)), |
| grpc.RpcMethodHandler): |
| pass |
| |
| |
| def _simple_method_handler( |
| implementation, request_deserializer, response_serializer): |
| if implementation.style is style.Service.INLINE: |
| if implementation.cardinality is cardinality.Cardinality.UNARY_UNARY: |
| return _SimpleMethodHandler( |
| False, False, request_deserializer, response_serializer, |
| _adapt_unary_request_inline(implementation.unary_unary_inline), None, |
| None, None) |
| elif implementation.cardinality is cardinality.Cardinality.UNARY_STREAM: |
| return _SimpleMethodHandler( |
| False, True, request_deserializer, response_serializer, None, |
| _adapt_unary_request_inline(implementation.unary_stream_inline), None, |
| None) |
| elif implementation.cardinality is cardinality.Cardinality.STREAM_UNARY: |
| return _SimpleMethodHandler( |
| True, False, request_deserializer, response_serializer, None, None, |
| _adapt_stream_request_inline(implementation.stream_unary_inline), |
| None) |
| elif implementation.cardinality is cardinality.Cardinality.STREAM_STREAM: |
| return _SimpleMethodHandler( |
| True, True, request_deserializer, response_serializer, None, None, |
| None, |
| _adapt_stream_request_inline(implementation.stream_stream_inline)) |
| elif implementation.style is style.Service.EVENT: |
| if implementation.cardinality is cardinality.Cardinality.UNARY_UNARY: |
| return _SimpleMethodHandler( |
| False, False, request_deserializer, response_serializer, |
| _adapt_unary_unary_event(implementation.unary_unary_event), None, |
| None, None) |
| elif implementation.cardinality is cardinality.Cardinality.UNARY_STREAM: |
| return _SimpleMethodHandler( |
| False, True, request_deserializer, response_serializer, None, |
| _adapt_unary_stream_event(implementation.unary_stream_event), None, |
| None) |
| elif implementation.cardinality is cardinality.Cardinality.STREAM_UNARY: |
| return _SimpleMethodHandler( |
| True, False, request_deserializer, response_serializer, None, None, |
| _adapt_stream_unary_event(implementation.stream_unary_event), None) |
| elif implementation.cardinality is cardinality.Cardinality.STREAM_STREAM: |
| return _SimpleMethodHandler( |
| True, True, request_deserializer, response_serializer, None, None, |
| None, _adapt_stream_stream_event(implementation.stream_stream_event)) |
| |
| |
| def _flatten_method_pair_map(method_pair_map): |
| method_pair_map = method_pair_map or {} |
| flat_map = {} |
| for method_pair in method_pair_map: |
| method = _common.fully_qualified_method(method_pair[0], method_pair[1]) |
| flat_map[method] = method_pair_map[method_pair] |
| return flat_map |
| |
| |
| class _GenericRpcHandler(grpc.GenericRpcHandler): |
| |
| def __init__( |
| self, method_implementations, multi_method_implementation, |
| request_deserializers, response_serializers): |
| self._method_implementations = _flatten_method_pair_map( |
| method_implementations) |
| self._request_deserializers = _flatten_method_pair_map( |
| request_deserializers) |
| self._response_serializers = _flatten_method_pair_map( |
| response_serializers) |
| self._multi_method_implementation = multi_method_implementation |
| |
| def service(self, handler_call_details): |
| method_implementation = self._method_implementations.get( |
| handler_call_details.method) |
| if method_implementation is not None: |
| return _simple_method_handler( |
| method_implementation, |
| self._request_deserializers.get(handler_call_details.method), |
| self._response_serializers.get(handler_call_details.method)) |
| elif self._multi_method_implementation is None: |
| return None |
| else: |
| try: |
| return None #TODO(nathaniel): call the multimethod. |
| except face.NoSuchMethodError: |
| return None |
| |
| |
| class _Server(interfaces.Server): |
| |
| def __init__(self, server): |
| self._server = server |
| |
| def add_insecure_port(self, address): |
| return self._server.add_insecure_port(address) |
| |
| def add_secure_port(self, address, server_credentials): |
| return self._server.add_secure_port(address, server_credentials) |
| |
| def start(self): |
| self._server.start() |
| |
| def stop(self, grace): |
| return self._server.stop(grace) |
| |
| def __enter__(self): |
| self._server.start() |
| return self |
| |
| def __exit__(self, exc_type, exc_val, exc_tb): |
| self._server.stop(None) |
| return False |
| |
| |
| def server( |
| service_implementations, multi_method_implementation, request_deserializers, |
| response_serializers, thread_pool, thread_pool_size): |
| generic_rpc_handler = _GenericRpcHandler( |
| service_implementations, multi_method_implementation, |
| request_deserializers, response_serializers) |
| if thread_pool is None: |
| effective_thread_pool = logging_pool.pool( |
| _DEFAULT_POOL_SIZE if thread_pool_size is None else thread_pool_size) |
| else: |
| effective_thread_pool = thread_pool |
| return _Server( |
| grpc.server(effective_thread_pool, handlers=(generic_rpc_handler,))) |