def logOn(self, chatui):
"""
@returns: this breaks with L{interfaces.IAccount}
@returntype: DeferredList of L{interfaces.IClient}s
"""
# Overriding basesupport's implementation on account of the
# fact that _startLogOn tends to return a deferredList rather
# than a simple Deferred, and we need to do registerAccountClient.
if (not self._isConnecting) and (not self._isOnline):
self._isConnecting = 1
d = self._startLogOn(chatui)
d.addErrback(self._loginFailed)
def registerMany(results):
for success, result in results:
if success:
chatui.registerAccountClient(result)
self._cb_logOn(result)
else:
log.err(result)
d.addCallback(registerMany)
return d
else:
raise error.ConnectionError("Connection in progress")
python类DeferredList()的实例源码
def _cbGetFileSize(self, attrs, rf, lf):
if not stat.S_ISREG(attrs['permissions']):
rf.close()
lf.close()
return "Can't get non-regular file: %s" % rf.name
rf.size = attrs['size']
bufferSize = self.client.transport.conn.options['buffersize']
numRequests = self.client.transport.conn.options['requests']
rf.total = 0.0
dList = []
chunks = []
startTime = self.reactor.seconds()
for i in range(numRequests):
d = self._cbGetRead('', rf, lf, chunks, 0, bufferSize, startTime)
dList.append(d)
dl = defer.DeferredList(dList, fireOnOneErrback=1)
dl.addCallback(self._cbGetDone, rf, lf)
return dl
def testResults(self):
inputOutput = [
("add", (2, 3), 5),
("defer", ("a",), "a"),
("dict", ({"a": 1}, "a"), 1),
("triple", ("a", 1), ["a", 1, None])]
dl = []
for meth, args, outp in inputOutput:
d = self.proxy().callRemote(meth, *args)
d.addCallback(self.assertEqual, outp)
dl.append(d)
# SOAPpy kinda blows.
d = self.proxy().callRemote('complex')
d.addCallback(lambda result: result._asdict())
d.addCallback(self.assertEqual, {"a": ["b", "c", 12, []], "D": "foo"})
dl.append(d)
# We now return to our regularly scheduled program, already in progress.
return defer.DeferredList(dl, fireOnOneErrback=True)
def tearDown(self):
if self.agent:
# clean up connections for twisted.web.client.Agent test.
self.agent.closeCachedConnections()
self.agent = None
# If the test indicated it might leave some server-side connections
# around, clean them up.
connections = list(self.wrapper.protocols.keys())
# If there are fewer server-side connections than requested,
# that's okay. Some might have noticed that the client closed
# the connection and cleaned up after themselves.
for n in range(min(len(connections), self.cleanupServerConnections)):
proto = connections.pop()
msg("Closing %r" % (proto,))
proto.transport.abortConnection()
d = self.port.stopListening()
return defer.DeferredList([waitUntilAllDisconnected(
reactor, list(self.wrapper.protocols.keys())), d])
def testCooperation(self):
L = []
def myiter(things):
for th in things:
L.append(th)
yield None
groupsOfThings = ['abc', (1, 2, 3), 'def', (4, 5, 6)]
c = task.Cooperator()
tasks = []
for stuff in groupsOfThings:
tasks.append(c.coiterate(myiter(stuff)))
return defer.DeferredList(tasks).addCallback(
lambda ign: self.assertEqual(tuple(L), sum(zip(*groupsOfThings), ())))
def test_callFromThread(self):
"""
Test callFromThread functionality: from the main thread, and from
another thread.
"""
def cb(ign):
firedByReactorThread = defer.Deferred()
firedByOtherThread = defer.Deferred()
def threadedFunc():
reactor.callFromThread(firedByOtherThread.callback, None)
reactor.callInThread(threadedFunc)
reactor.callFromThread(firedByReactorThread.callback, None)
return defer.DeferredList(
[firedByReactorThread, firedByOtherThread],
fireOnOneErrback=True)
return self._waitForThread().addCallback(cb)
def test_connectionLost(self):
"""
When disconnection occurs while commands are still outstanding, the
commands fail.
"""
d1 = self.proto.get(b"foo")
d2 = self.proto.get(b"bar")
self.transport.loseConnection()
done = DeferredList([d1, d2], consumeErrors=True)
def checkFailures(results):
for success, result in results:
self.assertFalse(success)
result.trap(ConnectionDone)
return done.addCallback(checkFailures)
def testDeferredListWithAlreadyFiredDeferreds(self):
# Create some deferreds, and err one, call the other
d1 = defer.Deferred()
d2 = defer.Deferred()
d1.errback(GenericError('Bang'))
d2.callback(2)
# *Then* build the DeferredList
dl = defer.DeferredList([d1, d2])
result = []
dl.addCallback(result.append)
self.assertEqual(1, len(result))
d1.addErrback(lambda e: None) # Swallow error
def test_cancelDeferredListCallback(self):
"""
When cancelling an unfired L{defer.DeferredList} without the
C{fireOnOneCallback} and C{fireOnOneErrback} flags set, the
L{defer.DeferredList} will be callback with a C{list} of
(success, result) C{tuple}s.
"""
deferredOne = defer.Deferred(fakeCallbackCanceller)
deferredTwo = defer.Deferred()
deferredList = defer.DeferredList([deferredOne, deferredTwo])
deferredList.cancel()
self.failureResultOf(deferredTwo, defer.CancelledError)
result = self.successResultOf(deferredList)
self.assertTrue(result[0][0])
self.assertEqual(result[0][1], "Callback Result")
self.assertFalse(result[1][0])
self.assertTrue(result[1][1].check(defer.CancelledError))
def test_cancelDeferredListWithFireOnOneErrback(self):
"""
When cancelling an unfired L{defer.DeferredList} with the flag
C{fireOnOneErrback} set, cancel every L{defer.Deferred} in the list.
"""
deferredOne = defer.Deferred()
deferredTwo = defer.Deferred()
deferredList = defer.DeferredList([deferredOne, deferredTwo],
fireOnOneErrback=True)
deferredList.cancel()
self.failureResultOf(deferredOne, defer.CancelledError)
self.failureResultOf(deferredTwo, defer.CancelledError)
deferredListFailure = self.failureResultOf(deferredList,
defer.FirstError)
firstError = deferredListFailure.value
self.assertTrue(firstError.subFailure.check(defer.CancelledError))
def test_cancelDeferredListWithFireOnOneErrbackAllDeferredsCallback(self):
"""
When cancelling an unfired L{defer.DeferredList} with the flag
C{fireOnOneErrback} set, if all the L{defer.Deferred} callbacks
in its canceller, the L{defer.DeferredList} will callback with a
C{list} of (success, result) C{tuple}s.
"""
deferredOne = defer.Deferred(fakeCallbackCanceller)
deferredTwo = defer.Deferred(fakeCallbackCanceller)
deferredList = defer.DeferredList([deferredOne, deferredTwo],
fireOnOneErrback=True)
deferredList.cancel()
result = self.successResultOf(deferredList)
self.assertTrue(result[0][0])
self.assertEqual(result[0][1], "Callback Result")
self.assertTrue(result[1][0])
self.assertEqual(result[1][1], "Callback Result")
def test_cancelDeferredListWithException(self):
"""
Cancelling a L{defer.DeferredList} will cancel every L{defer.Deferred}
in the list even exceptions raised from the C{cancel} method of the
L{defer.Deferred}s.
"""
def cancellerRaisesException(deferred):
"""
A L{defer.Deferred} canceller that raises an exception.
@param deferred: The cancelled L{defer.Deferred}.
"""
raise RuntimeError("test")
deferredOne = defer.Deferred(cancellerRaisesException)
deferredTwo = defer.Deferred()
deferredList = defer.DeferredList([deferredOne, deferredTwo])
deferredList.cancel()
self.failureResultOf(deferredTwo, defer.CancelledError)
errors = self.flushLoggedErrors(RuntimeError)
self.assertEqual(len(errors), 1)
def test_concurrentRetrieves(self):
"""
Issue three retrieve calls immediately without waiting for any to
succeed and make sure they all do succeed eventually.
"""
p, t = setUp()
messages = [
p.retrieve(i).addCallback(
self.assertEqual,
["First line of %d." % (i + 1,),
"Second line of %d." % (i + 1,)])
for i
in range(3)]
for i in range(1, 4):
self.assertEqual(t.value(), "RETR %d\r\n" % (i,))
t.clear()
p.dataReceived("+OK 2 lines on the way\r\n")
p.dataReceived("First line of %d.\r\n" % (i,))
p.dataReceived("Second line of %d.\r\n" % (i,))
self.assertEqual(t.value(), "")
p.dataReceived(".\r\n")
return defer.DeferredList(messages, fireOnOneErrback=True)
def get_devices_by_email(email, extensions, debug=False):
"""Returns all devices matching given email."""
deferreds = []
for ext in extensions:
if hasattr(ext.obj, 'get_devices_by_email'):
deferred = ext.obj.get_devices_by_email(email)
deferred.addErrback(stethoscope.api.utils.check_user_not_found)
deferred.addCallback(functools.partial(log_response, 'device',
ext.name + " ({!s})".format(email), debug=debug))
deferreds.append(deferred)
deferred_list = defer.DeferredList(deferreds, consumeErrors=True)
deferred_list.addCallback(functools.partial(stethoscope.api.utils.filter_keyed_by_status,
["{!s}({!s})".format(ext.name, email) for ext in extensions],
context=sys._getframe().f_code.co_name))
deferred_list.addCallback(lambda d: chain.from_iterable(d.values()))
deferred_list.addCallback(list)
return deferred_list
def get_devices_by_macaddr(macaddr, extensions, debug=False):
"""Returns all devices matching given MAC address."""
deferreds = []
for ext in extensions:
if hasattr(ext.obj, 'get_devices_by_macaddr'):
deferred = ext.obj.get_devices_by_macaddr(macaddr)
deferred.addErrback(stethoscope.api.utils.check_device_not_found)
deferred.addCallback(functools.partial(log_response, 'device',
ext.name + " ({!s})".format(macaddr), debug=debug))
deferreds.append(deferred)
deferred_list = defer.DeferredList(deferreds, consumeErrors=True)
deferred_list.addCallback(functools.partial(stethoscope.api.utils.filter_keyed_by_status,
["{!s}({!s})".format(ext.name, macaddr) for ext in extensions],
context=sys._getframe().f_code.co_name))
deferred_list.addCallback(lambda d: chain.from_iterable(d.values()))
deferred_list.addCallback(list)
return deferred_list
def _test_tcp_connect(self, consistent_addresses):
for key, addresses in consistent_addresses.items():
if key == 'stun':
# XXX we currently don't test stun
continue
dl = []
for address in addresses:
dl.append(self._test_connect_to_port(address, 443))
results = yield defer.DeferredList(dl, consumeErrors=True)
tcp_blocked = False
for success, result in results:
if success == False:
tcp_blocked = True
if tcp_blocked == True:
log.msg("{0} server is BLOCKED based on TCP".format(key))
if len(addresses) > 0:
self.report['facebook_{0}_reachable'.format(key)] = not tcp_blocked
def _test_tcp_connect(self):
for dc_id, address in TELEGRAM_DCS:
dl = []
log.debug("Testing %s:443|80" % (address))
dl.append(self._test_connect_to_port(address, 443))
dl.append(self._test_connect_to_port(address, 80))
results = yield defer.DeferredList(dl, consumeErrors=True)
tcp_blocked = True
for success, result in results:
if success == True:
tcp_blocked = False
if tcp_blocked == True:
self.report['telegram_tcp_blocking'] = True
log.msg("Telegram servers are BLOCKED based on TCP")
else:
self.report['telegram_tcp_blocking'] = False
log.msg("Telegram servers are not blocked based on TCP")
def test_filesystem_lock_and_mutex(self):
lock_dir = tempfile.mkdtemp()
lock_path = os.path.join(lock_dir, 'lock')
lock = FileSystemlockAndMutex(lock_path)
os.symlink(str(2**30), lock_path) # that's non-existend PID for sure
lock_count = 100
unlock_count = 0
dl = []
for i in range(lock_count):
dl.append(lock.acquire())
if random.choice([0, 1]) == 0:
unlock_count += 1
lock.release()
for i in range(lock_count - unlock_count):
lock.release()
yield defer.DeferredList(dl)
self.assertFalse(lock.locked)
shutil.rmtree(lock_dir)
def render_POST(self, request):
#
# Turn a path or show command into a set of candidate protobuf definitions.
# If it looks like a show command, then schema-describe it, get the set of
# paths, and run the GPB generation on each one. Otherwise, just run that on
# the sole provided path.
#
path = request.args['path'][0].strip()
if path.startswith('sh'):
d = scrape.schema_describe(path, request.sdata)
else:
d = defer.succeed([path])
def request_protobufs(paths):
print('### PROTOBUF PATHS = {}'.format(paths))
ds = []
for path in reversed(paths):
path = re.sub('\(.*?\)', '', path)
ds.append(request.sdata.api.cli_exec(
'run telemetry_generate_gpb "{}"'.format(path)))
return defer.DeferredList(ds)
d.addCallback(request_protobufs)
def get_protobufs(replies):
line = '-' * 77
sep = '\n//\n// ' + line + '\n//\n\n'
text = sep.join([reply[1]['result'] for reply in replies])
request.sdata.set_text('#protobuf_result', text)
request.sdata.add_to_push_queue('stop_current_spinner')
request.sdata.highlight('#protobuf_result')
d.addCallback(get_protobufs)
request.setHeader('Content-Type', 'application/json')
return '{}'
def _cbIdent(self, ident, chatui):
if not ident:
print 'falsely identified.'
return self._ebConnected(Failure(Exception("username or password incorrect")))
print 'Identified!'
dl = []
for handlerClass, sname, pname in self.services:
d = defer.Deferred()
dl.append(d)
handler = handlerClass(self, sname, pname, chatui, d)
ident.callRemote('attach', sname, pname, handler).addCallback(handler.connected)
return defer.DeferredList(dl)
