def rpc_call():
        context = context_module.get_toplevel_context()

        call = method.future(request, timeout=timeout)
        rpc = _remote.RemoteCall(call, "{}({})".format(rpc_name, request))
        log.debug(rpc)
        log.debug("timeout={}".format(timeout))

        try:
            result = yield rpc
        except Exception as error:
            if isinstance(error, grpc.Call):
                error = core_exceptions.from_grpc_error(error)
            raise error
        finally:
            context.rpc_time += rpc.elapsed_time

        raise tasklets.Return(result)
Beispiel #2
0
    def rpc_call():
        context = context_module.get_toplevel_context()

        call = method.future(request, timeout=timeout)
        rpc = _remote.RemoteCall(call, rpc_name)
        utils.logging_debug(log, rpc)
        utils.logging_debug(log, "timeout={}", timeout)

        try:
            result = yield rpc
        except Exception as error:
            if isinstance(error, grpc.Call):
                error = core_exceptions.from_grpc_error(error)
            raise error
        finally:
            context.rpc_time += rpc.elapsed_time

        raise tasklets.Return(result)
Beispiel #3
0
    def run0(self):
        """Run one item (a callback or an RPC wait_any).

        Returns:
            float: A time to sleep if something happened (may be 0);
              None if all queues are empty.
        """
        if self._run_current() or self.run_idle():
            return 0

        delay = None
        if self.queue:
            delay = self.queue[0][0] - time.time()
            if delay <= 0:
                self.inactive = 0
                _, callback, args, kwargs = self.queue.pop(0)
                utils.logging_debug(log, "event: {}", callback.__name__)
                callback(*args, **kwargs)
                return 0

        if self.rpcs:
            # Avoid circular import
            from google.cloud.ndb import context as context_module

            context = context_module.get_toplevel_context()

            # This potentially blocks, waiting for an rpc to finish and put its
            # result on the queue. Functionally equivalent to the ``wait_any``
            # call that was used here in legacy NDB.
            start_time = time.time()
            rpc_id, rpc = self.rpc_results.get()
            elapsed = time.time() - start_time
            utils.logging_debug(log, "Blocked for {}s awaiting RPC results.",
                                elapsed)
            context.wait_time += elapsed

            callback = self.rpcs.pop(rpc_id)
            callback(rpc)
            return 0

        return delay
Beispiel #4
0
 def test_no_context_dont_raise():
     assert context_module.get_toplevel_context(False) is None
Beispiel #5
0
 def test_no_context_raise():
     with pytest.raises(exceptions.ContextError):
         context_module.get_toplevel_context()
Beispiel #6
0
 def test_in_context(in_context):
     with in_context.new().use():
         assert context_module.get_toplevel_context() is in_context