def set(value, context):
source = context["model"].source
name = context["key"]
self.assertEqual(source, exp_source)
self.assertEqual(name, exp_name)
method = getattr(source, method_name)
return defer.maybeDeferred(method, value)
def _perform(method, value, params, args, kwargs):
keywords = dict(kwargs)
keywords.update(params)
keywords["value"] = value
arguments = []
func = method
if isinstance(method, types.MethodType):
func = method.im_func
if hasattr(func, 'original_func'):
func = func.original_func
argspec = inspect.getargspec(func)
for name in argspec.args:
if name in ("self"):
continue
if name not in keywords:
break
arguments.append(keywords.pop(name))
arguments.extend(args)
if not argspec.keywords:
expected = set(argspec.args)
for name in keywords.keys():
if name not in expected:
del keywords[name]
return defer.maybeDeferred(method, *arguments, **keywords)
def _call(self, method, *args, **kwargs):
'''Call the method, wrap it in Deferred and bind error handler'''
if self._deferred:
self._deferred.cancel()
self._deferred = d = defer.maybeDeferred(method, *args, **kwargs)
d.addErrback(self._error_handler)
return d
def to_call(callback):
if state:
self._set_state(state)
self.log('Calling method: %r with args: %r', method, args)
d = defer.maybeDeferred(method, *args, **kwargs)
d.addErrback(self._error_handler)
d.addCallback(callback.callback)
def stop_listening(self):
if self._port is not None:
d = defer.maybeDeferred(self._port.stopListening)
d.addCallback(defer.override_result, None)
self._port = None
self._url = None
return d
return defer.succeed(None)
def _run_and_wait(self, _, method, *args, **kwargs):
'''
Run a agent-side method and wait for all the protocols
to finish processing.
'''
d = defer.maybeDeferred(method, *args, **kwargs)
d.addBoth(defer.drop_param, self.wait_for_protocols_finish)
return d
def stop_listening(self):
def stopped(_):
self._port = None
return self
if self._port is not None:
d = defer.maybeDeferred(self._port.stopListening)
d.addCallback(defer.drop_param, self._on_stopped)
d.addCallback(stopped)
return d
return defer.succeed(self)
def _external_route_action(self, _method, _action, backend_id, **kwargs):
defers = []
for backend in self._backends.values():
method = getattr(backend, _method)
d = defer.maybeDeferred(method, backend_id, **kwargs)
d.addErrback(defer.print_trace)
d.addCallback(lambda res: (backend.channel_type, res))
defers.append(d)
d = defer.DeferredList(defers, consumeErrors=True)
d.addCallback(self._external_route_action_cb, _action, backend_id, kwargs)
return d
def disconnect(self):
'''
This is called as part of the agency shutdown.
'''
self.log("Disconnecting broker %r.", self)
if self.is_master():
d = self.listener.stopListening()
d.addCallback(defer.drop_param, self.factory.disconnect)
elif self.is_slave():
d = defer.maybeDeferred(self.factory.disconnect)
elif self._cmp_state(BrokerRole.disconnected):
return defer.succeed(None)
d.addCallback(defer.drop_param, self.become_disconnected)
return d
def _call(self, method, *args, **kwargs):
def raise_on_fiber(res):
if isinstance(res, fiber.Fiber):
raise RuntimeError("We are not expecting method %r to "
"return a Fiber, which it did!" % method)
return res
self.log('Calling method %r, with args: %r, kwargs: %r', method,
args, kwargs)
d = defer.maybeDeferred(method, *args, **kwargs)
d.addCallback(raise_on_fiber)
d.addErrback(self._error_handler)
return d
def _set(method, key, value, args, kwargs):
return defer.maybeDeferred(method, key, value, *args, **kwargs)
def _call(self, method, *args, **kwargs):
'''Call the method, wrap it in Deferred and bind error handler'''
d = defer.maybeDeferred(method, *args, **kwargs)
d.addErrback(lambda f: error_handler(self, f))
return d
def _expired(self, arg):
self._set_state(TaskState.expired)
d = defer.maybeDeferred(self.task.expired)
return d
def _initiate(self, *args, **kwargs):
d = defer.maybeDeferred(self.task.initiate, *args, **kwargs)
d.addCallbacks(self._completed, self._error)
return d
def _run(self):
d = defer.maybeDeferred(self.run)
d.addErrback(defer.inject_param, 1, error.handle_failure, self,
"Failure during stealth task execution")
d.addCallback(self._schedule)
return d
def notify(self, *args, **kwargs):
d = defer.maybeDeferred(self.pack_payload, *args, **kwargs)
d.addCallback(self._build_message)
return d
def _call(method, args, kwargs):
return defer.maybeDeferred(method, *args, **kwargs)
def perform(self):
d = defer.maybeDeferred(self.method, *self.args, **self.kwargs)
d.addCallback(defer.keep_param, self.callback.callback)
return d
def _cancel_long_running_protocols(self):
return defer.DeferredList([defer.maybeDeferred(x.cancel)
for x in self._long_running_protocols])
def _get(method, key, args, kwargs):
return defer.maybeDeferred(method, key, *args, **kwargs)
def _filter(method, value, args, kwargs):
return defer.maybeDeferred(method, value, *args, **kwargs)
def _notify(self, callbacks):
defers = map(lambda cb: defer.maybeDeferred(cb), callbacks)
return defer.DeferredList(defers, consumeErrors=True)
def _call_initiate(self, **kwargs):
self._set_state(AgencyAgentState.initiating)
d = defer.maybeDeferred(self.agent.initiate_agent, **kwargs)
d.addCallback(fiber.drop_param, self._set_state,
AgencyAgentState.initiated)
return d