def receiveClose(self):
# three things must happen before our request is complete:
# receiveClose has occurred
# the receiveChild object deferred (if any) has fired
# ready_deferred has finished
# If ready_deferred errbacks, provide its failure object to the
# request. If not, provide the request with whatever receiveChild
# got.
if not self._child_deferred:
raise BananaError("Answer didn't include an answer")
if self._ready_deferreds:
d = AsyncAND(self._ready_deferreds)
else:
d = defer.succeed(None)
def _ready(res):
return self._child_deferred
d.addCallback(_ready)
def _done(res):
self.request.complete(res)
def _fail(f):
# we hit here if any of the _ready_deferreds fail (i.e a Gift
# failed to resolve), or if the _child_deferred fails (not sure
# how this could happen). I think it's ok to return a local
# exception (instead of a RemoteException) for both.
self.request.fail(f)
d.addCallbacks(_done, _fail)
return None, None
def complete(self):
ready_deferred = None
if self._ready_deferreds:
ready_deferred = AsyncAND(self._ready_deferreds)
t = tuple(self.content)
if self.debug:
print(" finished! tuple:%s{%s}" % (t, id(t)))
self.protocol.setObject(self.count, t)
self.deferred.callback(t)
return t, ready_deferred
def receiveClose(self):
if self.stage != 4:
raise BananaError("'call' sequence ended too early")
# time to create the InboundDelivery object so we can queue it
delivery = InboundDelivery(self.broker, self.reqID, self.obj,
self.interface, self.methodname,
self.methodSchema, self.allargs)
ready_deferred = None
if self._ready_deferreds:
ready_deferred = AsyncAND(self._ready_deferreds)
return delivery, ready_deferred
def receiveClose(self):
# three things must happen before our request is complete:
# receiveClose has occurred
# the receiveChild object deferred (if any) has fired
# ready_deferred has finished
# If ready_deferred errbacks, provide its failure object to the
# request. If not, provide the request with whatever receiveChild
# got.
if not self._child_deferred:
raise BananaError("Answer didn't include an answer")
if self._ready_deferreds:
d = AsyncAND(self._ready_deferreds)
else:
d = defer.succeed(None)
def _ready(res):
return self._child_deferred
d.addCallback(_ready)
def _done(res):
self.request.complete(res)
def _fail(f):
# we hit here if any of the _ready_deferreds fail (i.e a Gift
# failed to resolve), or if the _child_deferred fails (not sure
# how this could happen). I think it's ok to return a local
# exception (instead of a RemoteException) for both.
self.request.fail(f)
d.addCallbacks(_done, _fail)
return None, None
def receiveClose(self):
if self.debug:
print("%s[%d].receiveClose" % (self, self.count))
self.finished = 1
if self.num_unreferenceable_children:
# not finished yet, we'll fire our Deferred when we are
if self.debug:
print(" not finished yet")
ready_deferred = None
if self._ready_deferreds:
ready_deferred = AsyncAND(self._ready_deferreds)
return self.deferred, ready_deferred
# the list is already complete
return self.complete()
def receiveClose(self):
if self.debug:
log.msg("%s.receiveClose: %s %s %s" %
(self, self.closed, self.num_unreferenceable_children,
len(self._ready_deferreds)))
if (self.numargs is None or len(self.args) < self.numargs
or self.argname is not None):
raise BananaError("'arguments' sequence ended too early")
self.closed = True
dl = []
if self.num_unreferenceable_children:
d = self._all_children_are_referenceable_d = defer.Deferred()
dl.append(d)
dl.extend(self._ready_deferreds)
ready_deferred = None
if dl:
ready_deferred = AsyncAND(dl)
return self, ready_deferred
def receiveClose(self):
ready_deferred = None
if self._ready_deferreds:
ready_deferred = AsyncAND(self._ready_deferreds)
return self.d, ready_deferred
