def _handle_call(self, call):
""" Handles one ``call`` message. """
try:
result = self.execute_call(call)
if not call.want_response:
return
if isiter(result):
for to_yield in result:
self.cxn.send_message(("yield", to_yield))
self.cxn.send_message(("stop",))
else:
self.cxn.send_message(("return", result))
except ConnectionError:
raise
except Exception, e:
if call.want_response:
self.cxn.send_message(("raise", self._serialize_exception(e)))
raise
def _handle_call(self, call):
""" Handles one ``call`` message. """
try:
result = self.execute_call(call)
if not call.want_response:
return
if isiter(result):
for to_yield in result:
self.cxn.send_message(("yield", to_yield))
self.cxn.send_message(("stop", ))
else:
self.cxn.send_message(("return", result))
except ConnectionError:
raise
except Exception, e:
if call.want_response:
self.cxn.send_message(("raise", self._serialize_exception(e)))
raise
def execute(self, call):
""" Calls a method for an RPC call (part of ``ConnectionHandler``'s
``call_handler`` interface).
"""
callable = self.get_call_callable(call)
timeout = None
if self.call_timeout is not None:
timeout = Timeout(getattr(callable, "_timeout", self.call_timeout))
call_semaphore = self._get_call_semaphore(call)
if call_semaphore.locked():
log.warning("too many concurrent callers (%r); call %r will block",
self.max_concurrent_calls, call)
call_semaphore.acquire()
def finished_callback(is_error):
self.active_calls.remove(call)
self.call_stats["completed"] += 1
if is_error:
self.call_stats["errors"] += 1
call_semaphore.release()
if timeout is not None:
timeout.cancel()
got_err = True
result_is_generator = False
try:
if timeout is not None:
timeout.start()
time_in_queue = time.time() - call.meta.get("time_received", 0)
call.meta["time_in_queue"] = time_in_queue
self.active_calls.append(call)
result = callable(*call.args, **call.kwargs)
if isiter(result):
result = self.wrap_generator_result(call, result,
finished_callback)
result_is_generator = True
got_err = False
finally:
if not result_is_generator:
finished_callback(is_error=got_err)
return result
def execute(self, call):
""" Calls a method for an RPC call (part of ``ConnectionHandler``'s
``call_handler`` interface).
"""
callable = self.get_call_callable(call)
timeout = None
if self.call_timeout is not None:
timeout = Timeout(getattr(callable, "_timeout", self.call_timeout))
call_semaphore = self._get_call_semaphore(call)
if call_semaphore.locked():
log.warning("too many concurrent callers (%r); call %r will block",
self.max_concurrent_calls, call)
call_semaphore.acquire()
def finished_callback(is_error):
self.active_calls.remove(call)
self.call_stats["completed"] += 1
if is_error:
self.call_stats["errors"] += 1
call_semaphore.release()
if timeout is not None:
timeout.cancel()
got_err = True
result_is_generator = False
try:
if timeout is not None:
timeout.start()
time_in_queue = time.time() - call.meta.get("time_received", 0)
call.meta["time_in_queue"] = time_in_queue
self.active_calls.append(call)
result = callable(*call.args, **call.kwargs)
if isiter(result):
result = self.wrap_generator_result(call, result,
finished_callback)
result_is_generator = True
got_err = False
finally:
if not result_is_generator:
finished_callback(is_error=got_err)
return result
