| # Copyright 2015-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. |
| |
| import six |
| |
| from grpc.framework.common import cardinality |
| from grpc.framework.face import exceptions as face_exceptions |
| from grpc.framework.face import interfaces as face_interfaces |
| from grpc.framework.foundation import future |
| from grpc.framework.alpha import exceptions |
| from grpc.framework.alpha import interfaces |
| |
| _EARLY_ADOPTER_CARDINALITY_TO_COMMON_CARDINALITY = { |
| interfaces.Cardinality.UNARY_UNARY: cardinality.Cardinality.UNARY_UNARY, |
| interfaces.Cardinality.UNARY_STREAM: cardinality.Cardinality.UNARY_STREAM, |
| interfaces.Cardinality.STREAM_UNARY: cardinality.Cardinality.STREAM_UNARY, |
| interfaces.Cardinality.STREAM_STREAM: cardinality.Cardinality.STREAM_STREAM, |
| } |
| |
| _ABORTION_REEXPORT = { |
| face_interfaces.Abortion.CANCELLED: interfaces.Abortion.CANCELLED, |
| face_interfaces.Abortion.EXPIRED: interfaces.Abortion.EXPIRED, |
| face_interfaces.Abortion.NETWORK_FAILURE: |
| interfaces.Abortion.NETWORK_FAILURE, |
| face_interfaces.Abortion.SERVICED_FAILURE: |
| interfaces.Abortion.SERVICED_FAILURE, |
| face_interfaces.Abortion.SERVICER_FAILURE: |
| interfaces.Abortion.SERVICER_FAILURE, |
| } |
| |
| |
| class _RpcError(exceptions.RpcError): |
| pass |
| |
| |
| def _reexport_error(face_rpc_error): |
| if isinstance(face_rpc_error, face_exceptions.CancellationError): |
| return exceptions.CancellationError() |
| elif isinstance(face_rpc_error, face_exceptions.ExpirationError): |
| return exceptions.ExpirationError() |
| else: |
| return _RpcError() |
| |
| |
| def _as_face_abortion_callback(abortion_callback): |
| def face_abortion_callback(face_abortion): |
| abortion_callback(_ABORTION_REEXPORT[face_abortion]) |
| return face_abortion_callback |
| |
| |
| class _ReexportedFuture(future.Future): |
| |
| def __init__(self, face_future): |
| self._face_future = face_future |
| |
| def cancel(self): |
| return self._face_future.cancel() |
| |
| def cancelled(self): |
| return self._face_future.cancelled() |
| |
| def running(self): |
| return self._face_future.running() |
| |
| def done(self): |
| return self._face_future.done() |
| |
| def result(self, timeout=None): |
| try: |
| return self._face_future.result(timeout=timeout) |
| except face_exceptions.RpcError as e: |
| raise _reexport_error(e) |
| |
| def exception(self, timeout=None): |
| face_error = self._face_future.exception(timeout=timeout) |
| return None if face_error is None else _reexport_error(face_error) |
| |
| def traceback(self, timeout=None): |
| return self._face_future.traceback(timeout=timeout) |
| |
| def add_done_callback(self, fn): |
| self._face_future.add_done_callback(lambda unused_face_future: fn(self)) |
| |
| |
| def _call_reexporting_errors(behavior, *args, **kwargs): |
| try: |
| return behavior(*args, **kwargs) |
| except face_exceptions.RpcError as e: |
| raise _reexport_error(e) |
| |
| |
| def _reexported_future(face_future): |
| return _ReexportedFuture(face_future) |
| |
| |
| class _CancellableIterator(interfaces.CancellableIterator): |
| |
| def __init__(self, face_cancellable_iterator): |
| self._face_cancellable_iterator = face_cancellable_iterator |
| |
| def __iter__(self): |
| return self |
| |
| def next(self): |
| return _call_reexporting_errors(self._face_cancellable_iterator.next) |
| |
| def cancel(self): |
| self._face_cancellable_iterator.cancel() |
| |
| |
| class _RpcContext(interfaces.RpcContext): |
| |
| def __init__(self, face_rpc_context): |
| self._face_rpc_context = face_rpc_context |
| |
| def is_active(self): |
| return self._face_rpc_context.is_active() |
| |
| def time_remaining(self): |
| return self._face_rpc_context.time_remaining() |
| |
| def add_abortion_callback(self, abortion_callback): |
| self._face_rpc_context.add_abortion_callback( |
| _as_face_abortion_callback(abortion_callback)) |
| |
| |
| class _UnaryUnarySyncAsync(interfaces.UnaryUnarySyncAsync): |
| |
| def __init__(self, face_unary_unary_multi_callable): |
| self._underlying = face_unary_unary_multi_callable |
| |
| def __call__(self, request, timeout): |
| return _call_reexporting_errors( |
| self._underlying, request, timeout) |
| |
| def async(self, request, timeout): |
| return _ReexportedFuture(self._underlying.future(request, timeout)) |
| |
| |
| class _StreamUnarySyncAsync(interfaces.StreamUnarySyncAsync): |
| |
| def __init__(self, face_stream_unary_multi_callable): |
| self._underlying = face_stream_unary_multi_callable |
| |
| def __call__(self, request_iterator, timeout): |
| return _call_reexporting_errors( |
| self._underlying, request_iterator, timeout) |
| |
| def async(self, request_iterator, timeout): |
| return _ReexportedFuture(self._underlying.future(request_iterator, timeout)) |
| |
| |
| def common_cardinality(early_adopter_cardinality): |
| return _EARLY_ADOPTER_CARDINALITY_TO_COMMON_CARDINALITY[ |
| early_adopter_cardinality] |
| |
| |
| def common_cardinalities(early_adopter_cardinalities): |
| common_cardinalities = {} |
| for name, early_adopter_cardinality in six.iteritems(early_adopter_cardinalities): |
| common_cardinalities[name] = _EARLY_ADOPTER_CARDINALITY_TO_COMMON_CARDINALITY[ |
| early_adopter_cardinality] |
| return common_cardinalities |
| |
| |
| def rpc_context(face_rpc_context): |
| return _RpcContext(face_rpc_context) |
| |
| |
| def cancellable_iterator(face_cancellable_iterator): |
| return _CancellableIterator(face_cancellable_iterator) |
| |
| |
| def unary_unary_sync_async(face_unary_unary_multi_callable): |
| return _UnaryUnarySyncAsync(face_unary_unary_multi_callable) |
| |
| |
| def stream_unary_sync_async(face_stream_unary_multi_callable): |
| return _StreamUnarySyncAsync(face_stream_unary_multi_callable) |