Here are the examples of the python api twisted.internet.task.deferLater taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
125 Examples
3
Example 1
Project: mythbox Source File: loopback.py
def _loopbackAsyncContinue(ignored, server, serverToClient, client,
clientToServer, pumpPolicy):
# Clear the Deferred from each message queue, since it has already fired
# and cannot be used again.
clientToServer._notificationDeferred = None
serverToClient._notificationDeferred = None
# Schedule some more byte-pushing to happen. This isn't done
# synchronously because no actual transport can re-enter dataReceived as
# a result of calling write, and doing this synchronously could result
# in that.
from twisted.internet import reactor
return deferLater(
reactor, 0,
_loopbackAsyncBody,
server, serverToClient, client, clientToServer, pumpPolicy)
3
Example 2
Project: ccs-calendarserver Source File: test_http.py
def testTimeout_betweenRequests(self):
cxn = self.connect(betweenRequestsTimeOut=0.3)
cmds = [[]]
data = ""
cxn.client.write("GET / HTTP/1.1\r\n\r\n")
cmds[0] += [('init', 'GET', '/', (1, 1), 0, ()),
('contentComplete',)]
self.compareResult(cxn, cmds, data)
response = TestResponse()
response.headers.setRawHeaders("Content-Length", ("0",))
cxn.requests[0].writeResponse(response)
response.finish()
data += "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"
self.compareResult(cxn, cmds, data)
return deferLater(reactor, 0.5, self.assertDone, cxn) # Wait for timeout
3
Example 3
def monitor_result(self, result, reactor):
"""
Loop periodically or until the factory stops to monitor the results
and return them.
"""
log.msg('>>>>> monitor_result() called')
log.msg('>>>>> self.all_done = %s' % self.all_done)
if self.all_done:
log.msg('>>>>> SENDING RESULTS: %r' % self.results)
log.msg('>>>>> SENDING ERRORS: %r' % self.errors)
#return self.results
return dict(result=self.results, errors=self.errors)
return task.deferLater(reactor, 0.5, self.monitor_result, result, reactor)
3
Example 4
Project: golem Source File: ranking.py
def __end_round(self):
logger.debug("End gossip round")
try:
self.received_gossip = self.client.collect_gossip() + self.received_gossip
self.__make_prev_rank()
self.working_vec = {}
self.__add_gossip()
self.__check_finished()
finally:
deferLater(self.reactor, self.round_oracle.sec_to_break(), self.__make_break)
3
Example 5
def signedOn(self):
for command in ircSettings.get_key('autoexec'):
self.sendLine(command)
print("[IRC-AUTO] >>> %s" % command)
task.deferLater(reactor, 15, self.joinChan)
print("[GlobalChat] Joining channels in 15 seconds...")
3
Example 6
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testCancelRemovesFromQueue(self):
"""
Cancelling a job should remove it from the queue.
"""
def eb(failure):
self.assertEqual(failure.value.state, Job.CANCELLED)
dq = ResizableDispatchQueue(self.slow, 1)
dq.put('a', 1)
deferred = dq.put('b', 2)
deferred.addErrback(eb)
deferred.cancel()
yield task.deferLater(reactor, 0.1, dq.pause)
pendingJobs = dq.pending()
self.assertEqual(pendingJobs, [])
3
Example 7
Project: btcx Source File: mtgox.py
def send_signed_call(self, call, params=None, item='BTC', **kwargs):
if self.connected:
return self.client.signed_call(call, params, item, **kwargs)
else:
print("Client is not connected! Retrying in one second")
task.deferLater(reactor, 1, self.send_signed_call, call,
params, item, **kwargs)
3
Example 8
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def _stopAndTest(self, when, dq, expectedPending):
pendingJobs = yield task.deferLater(reactor, when, dq.stop)
pendingArgs = [p.jobarg for p in pendingJobs]
self.assertEqual(sorted(expectedPending), sorted(pendingArgs))
self.assertEqual(dq.size(), (0, len(pendingJobs)))
3
Example 9
def on_connection_made(self):
if self.connection is None or self.connection.state == State.CONNECTING:
return task.deferLater(reactor, .1, self.on_connection_made)
if self.connection.state == State.CONNECTED:
self.addr = str(self.connection.dest_addr[0]) + ":" + str(self.connection.dest_addr[1])
self.log.info("connected to %s" % self.addr)
3
Example 10
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testPauseStop(self):
items = range(3)
dq = ResizableDispatchQueue(self.slow, 1)
map(dq.put, items)
d1 = task.deferLater(reactor, 0.1, dq.pause)
d2 = self._stopAndTest(0.15, dq, [1, 2])
yield d1
yield d2
3
Example 11
Project: golem Source File: ranking.py
def __init_stage(self):
try:
logger.debug("New gossip stage")
self.__push_local_ranks()
self.finished = False
self.global_finished = False
self.step = 0
self.finished_neighbours = set()
self.__init_working_vec()
finally:
deferLater(self.reactor, self.round_oracle.sec_to_round(), self.__new_round)
3
Example 12
def sleep(seconds=0, reactor=reactor):
"""A simple helper for asynchronously sleeping a certain amount of time.
Standard usage:
sleep(1.0).addCallback(on_wakeup)
inlineCallbacks usage:
yield sleep(1.0)
"""
return task.deferLater(reactor, seconds, lambda: None)
3
Example 13
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testPauseWidenResumeStop(self):
items = range(3)
dq = ResizableDispatchQueue(self.slow, 1)
map(dq.put, items)
d1 = task.deferLater(reactor, 0.1, dq.pause)
reactor.callLater(0.2, dq.setWidth, 2)
reactor.callLater(0.5, dq.resume)
d2 = self._stopAndTest(0.6, dq, [])
yield d1
yield d2
3
Example 14
def _wait_for_session(self, host, port):
deferred = Deferred()
def on_success(result):
if result:
deferred.callback(result)
else:
retry()
def retry(*_):
conn_deferred = task.deferLater(self.reactor, self.retry_timeout,
self.factory.get_session, host, port,
timeout=self.conn_timeout)
conn_deferred.addCallbacks(on_success, retry)
retry()
return deferred
3
Example 15
Project: vumi-go Source File: jsbox_send.py
@inlineCallbacks
def send_to_conv(self, conv, msg):
publisher = self._publishers[conv.conversation_type]
yield publisher.publish_message(msg)
# Give the reactor time to actually send the message.
yield deferLater(reactor, self.SEND_DELAY, lambda: None)
3
Example 16
def enable_radio(self, enable):
"""
Enables the radio according to ``enable``
It will not enable it if it's already enabled and viceversa
"""
def check_if_necessary(status):
if (status == 1 and enable) or (status == 0 and not enable):
return defer.succeed('OK')
d = super(HuaweiK4505Wrapper, self).enable_radio(enable)
d.addCallback(lambda x: deferLater(reactor, 5, lambda: x))
return d
d = self.get_radio_status()
d.addCallback(check_if_necessary)
return d
3
Example 17
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testPuttingMoreThanWidthOnlyDispatchesWidth(self):
"""
Make sure that if we put 5 things onto a queue whose width is 3
that shortly thereafter there are 3 jobs underway and 2 pending.
"""
dq = ResizableDispatchQueue(self.slow, 3)
for value in range(5):
reactor.callLater(0.01, dq.put, value)
yield task.deferLater(reactor, 0.1, self._testSize, dq, (3, 2))
yield dq.stop()
3
Example 18
Project: lbry Source File: sqlite_helpers.py
def rerun_if_locked(f):
def rerun(err, *args, **kwargs):
if err.check(sqlite3.OperationalError) and err.value.message == "database is locked":
log.warning("database was locked. rerunning %s with args %s, kwargs %s",
str(f), str(args), str(kwargs))
return task.deferLater(reactor, 0, wrapper, *args, **kwargs)
return err
def wrapper(*args, **kwargs):
d = f(*args, **kwargs)
d.addErrback(rerun, *args, **kwargs)
return d
return wrapper
3
Example 19
Project: sllurp Source File: llrp.py
def send_DELETE_ACCESSSPEC(self, placeHolderArg, readSpecParam,
writeSpecParam, stopParam, accessSpecID=1,
onCompletion=None):
# logger.info('Deleting current accessSpec.')
self.sendLLRPMessage(LLRPMessage(msgdict={
'DELETE_ACCESSSPEC': {
'Ver': 1,
'Type': 41,
'ID': 0,
'AccessSpecID': accessSpecID # ONE AccessSpec
}}))
# Hackfix to chain startAccess to send_DELETE, since appending a
# deferred doesn't seem to work...
task.deferLater(reactor, 0, self.startAccess, readWords=readSpecParam,
writeWords=writeSpecParam, accessStopParam=stopParam,
accessSpecID=accessSpecID)
3
Example 20
Project: worker Source File: test_data.py
@trigger("bad-trigger")
@inlineCallbacks
def testTriggersCheckService(self):
service = TriggersCheck(self.db)
service.start()
yield self.db.saveTrigger(self.trigger.id, {})
yield self.db.addTriggerCheck(self.trigger.id)
worker.ERROR_TIMEOUT = 0.01
yield deferLater(reactor, worker.PERFORM_INTERVAL * 2, lambda: None)
self.flushLoggedErrors()
yield service.stop()
3
Example 21
Project: txpostgres Source File: retrying.py
def _callWithDelay(self, delay):
# if the delay is 0, call the function synchronously
if not delay:
self._inProgress = defer.maybeDeferred(
self._f, *self._args, **self._kw)
else:
self._inProgress = task.deferLater(
self.reactor, delay, self._f, *self._args, **self._kw)
self._inProgress.addCallbacks(self._deferred.callback, self._err)
3
Example 22
Project: powerstrip-flocker Source File: adapter.py
def loop_until(predicate):
"""Call predicate every 0.1 seconds, until it returns something ``Truthy``.
:param predicate: Callable returning termination condition.
:type predicate: 0-argument callable returning a Deferred.
:return: A ``Deferred`` firing with the first ``Truthy`` response from
``predicate``.
"""
d = maybeDeferred(predicate)
def loop(result):
if not result:
d = deferLater(reactor, 0.1, predicate)
d.addCallback(loop)
return d
return result
d.addCallback(loop)
return d
3
Example 23
def render_GET(self, request):
request.setHeader(b"Content-Type", b"image/gif")
request.setHeader(b"Cache-Control", b"no-cache, must-revalidate")
request.setHeader(b"Pragma", b"no-cache")
request.write(b"GIF89a")
n = getarg(request, "n", 1, type=float)
d = deferLater(reactor, n, lambda: (request, n))
d.addCallback(self._delayedRender)
return NOT_DONE_YET
3
Example 24
Project: deluge Source File: core.py
def enable(self):
# reduce typing, assigning some values to self...
self.config = deluge.configmanager.ConfigManager('autoadd.conf', DEFAULT_PREFS)
self.config.run_converter((0, 1), 2, self.__migrate_config_1_to_2)
self.config.save()
self.watchdirs = self.config['watchdirs']
component.get('EventManager').register_event_handler(
'PreTorrentRemovedEvent', self.__on_pre_torrent_removed
)
# Dict of Filename:Attempts
self.invalid_torrents = {}
# Loopingcall timers for each enabled watchdir
self.update_timers = {}
deferLater(reactor, 5, self.enable_looping)
3
Example 25
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testPauseAddStop(self):
items = range(3)
dq = ResizableDispatchQueue(self.slow, 1)
map(dq.put, items)
d1 = task.deferLater(reactor, 0.1, dq.pause)
reactor.callLater(0.12, dq.put, None)
reactor.callLater(0.14, dq.put, 'hello')
reactor.callLater(0.16, dq.put, 'world')
d2 = self._stopAndTest(0.18, dq, [1, 2, None, 'hello', 'world'])
yield d1
yield d2
3
Example 26
Project: carbon Source File: test_client.py
def test_send_datapoint(self):
def assert_sent():
sent_data = self.transport.value()
sent_datapoints = decode_sent(sent_data)
self.assertEqual([datapoint], sent_datapoints)
datapoint = ('foo.bar', (1000000000, 1.0))
self.protocol.sendDatapoint(*datapoint)
return deferLater(reactor, 0.1, assert_sent)
3
Example 27
Project: calvin-base Source File: append_server.py
def bootstrap(self, addrs):
"""
Bootstrap the server by connecting to other known nodes in the network.
Args:
addrs: A `list` of (ip, port) `tuple` pairs. Note that only IP addresses
are acceptable - hostnames will cause an error.
"""
# if the transport hasn't been initialized yet, wait a second
if self.protocol.transport is None:
return task.deferLater(reactor, .2, self.bootstrap, addrs)
else:
_log.debug("AppendServer.bootstrap(%s)" % addrs)
return Server.bootstrap(self, addrs)
3
Example 28
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testPauseStopResume(self):
"""
Pause a queue, then stop it, then check that trying to resume it
gets a C{QueueStopped} exception.
"""
items = range(3)
dq = ResizableDispatchQueue(self.slow, 1)
map(dq.put, items)
d1 = task.deferLater(reactor, 0.1, dq.pause)
d2 = self._stopAndTest(0.2, dq, [1, 2])
d3 = task.deferLater(reactor, 0.3, dq.resume)
yield d1
yield d2
yield self.failUnlessFailure(d3, QueueStopped)
3
Example 29
def __new_round(self):
logger.debug("New gossip round")
try:
self.__set_k()
self.step += 1
gossip = self.__prepare_gossip()
if len(self.neighbours) > 0:
send_to = random.sample(self.neighbours, self.k)
self.client.send_gossip(gossip, send_to)
self.received_gossip = [gossip]
finally:
deferLater(self.reactor, self.round_oracle.sec_to_end_round(), self.__end_round)
3
Example 30
Project: smokesignal Source File: tests_twisted.py
def asynchronous_failure(target):
"""
Fail asynchronously
"""
def err():
{}['key_error']
return task.deferLater(reactor, 0, err)
3
Example 31
def __make_break(self):
logger.debug("Gossip round finished")
try:
self.__check_global_finished()
except Exception:
deferLater(self.reactor, self.round_oracle.sec_to_round(), self.__new_round)
raise
if self.global_finished:
try:
self.client.collect_gossip()
self.client.collect_stopped_peers()
self.__save_working_vec()
finally:
deferLater(self.reactor, self.round_oracle.sec_to_new_stage(), self.__init_stage)
else:
deferLater(self.reactor, self.round_oracle.sec_to_round(), self.__new_round)
3
Example 32
def delay(target):
"""
Succeed after a delay
"""
def done():
return 'delay done'
return task.deferLater(reactor, 15, done)
3
Example 33
def loseConnection(self, connDone=failure.Failure(main.CONNECTION_DONE)):
"""
Stop accepting connections on this port.
This will shut down the socket and call self.connectionLost(). It
returns a deferred which will fire successfully when the port is
actually closed, or with a failure if an error occurs shutting down.
"""
self.disconnecting = True
self.stopReading()
if self.connected:
self.deferred = deferLater(
self.reactor, 0, self.connectionLost, connDone)
return self.deferred
3
Example 34
Project: vumi Source File: test_vumi_model_migrator.py
def post_migrate_function_deferred(obj):
"""
Post-migrate-function for use in tests.
"""
from twisted.internet import reactor
return deferLater(reactor, 0.1, post_migrate_function, obj)
3
Example 35
def enable_radio(self, enable):
d = self.get_radio_status()
def get_radio_status_cb(status):
if status in [0, 4] and enable:
self.send_at('AT+CFUN=1')
# delay here to give the device chance to wake up
return deferLater(reactor, 2, lambda: None)
elif status == 1 and not enable:
return self.send_at('AT+CFUN=4')
d.addCallback(get_radio_status_cb)
return d
3
Example 36
@defer.inlineCallbacks
def testSetWidthToZeroAfterInitiallyNonZero(self):
"""
Make sure that a queue whose width is initially non-zero and which
is then set to zero width does not then begin to process any added
jobs.
"""
dq = ResizableDispatchQueue(self.slow, 3)
yield task.deferLater(reactor, 0.01, dq.setWidth, 0)
reactor.callLater(0.01, dq.put, 'aaa')
reactor.callLater(0.01, dq.put, 'bbb')
yield task.deferLater(reactor, 0.05, self._testSize, dq, (0, 2))
remaining = yield dq.stop()
self.assertEqual(['aaa', 'bbb'], [job.jobarg for job in remaining])
3
Example 37
def send_request(self, json_msg):
if self.connected:
self.client.sendMessage(json_msg)
else:
print("Client is not connected! Retrying in one second")
task.deferLater(reactor, 1, self.send_request, json_msg)
3
Example 38
def __wait(self, pred, poll, target=None):
_async = target is not None
def __checkPred(res):
if res:
target.callback(self)
return res
else:
task.deferLater(reactor, poll, self.__wait, pred, poll, target)
return
if _async:
return pred().addCallback(__checkPred)
else:
while not pred():
time.sleep(poll)
return True
3
Example 39
Project: shinysdr Source File: test_top.py
@defer.inlineCallbacks
def test_monitor_vfo_change(self):
freq1 = 1e6
freq2 = 2e6
dev = simulate.SimulatedDevice(freq=freq1, allow_tuning=True)
top = Top(devices={'s1': dev})
self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq1)
dev.set_freq(freq2)
yield deferLater(the_reactor, 0.1, lambda: None) # wait for tune delay
self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq2)
3
Example 40
def monitor_result(self, result, reactor):
"""
Loop periodically or until the factory stops to check if we're
``all_done`` and then return the results.
"""
# Once we're done, return the results
if self.all_done:
return self.results
# Otherwise tell the reactor to call me again after 0.5 seconds.
return task.deferLater(reactor, 0.5, self.monitor_result, result, reactor)
3
Example 41
Project: nagcat Source File: scheduler.py
def schedule(self, runnable, delay=None):
"""(re)schedule a top level runnable"""
if delay is None:
delay = runnable.repeat
if not delay:
log.error("Task %s has no repeat value.", runnable)
else:
log.debug("Scheduling %s in %s seconds.", runnable, delay)
deferred = task.deferLater(reactor, delay, runnable.start)
deferred.addBoth(lambda x: self.schedule(runnable))
3
Example 42
def task(self, msg):
"""
Method for a time consuming task.
This function must return a deferred. If it is successfull,
a `basic.ack` will be sent to AMQP. If the task was not completed a
`basic.nack` will be sent. In this example it will always return
successfully after a 2 second pause.
"""
return task.deferLater(reactor, 2, lambda: log.msg("task completed"))
3
Example 43
Project: ccs-calendarserver Source File: test_http.py
def testTimeout_idleRequest(self):
cxn = self.connect(idleTimeOut=0.3)
cmds = [[]]
data = ""
cxn.client.write("GET / HTTP/1.1\r\n\r\n")
cmds[0] += [('init', 'GET', '/', (1, 1), 0, ()),
('contentComplete',)]
self.compareResult(cxn, cmds, data)
return deferLater(reactor, 0.5, self.assertDone, cxn) # Wait for timeout
3
Example 44
Project: treq Source File: test_treq_integration.py
def tearDown(self):
def _check_fds(_):
# This appears to only be necessary for HTTPS tests.
# For the normal HTTP tests then closeCachedConnections is
# sufficient.
fds = set(reactor.getReaders() + reactor.getReaders())
if not [fd for fd in fds if isinstance(fd, Client)]:
return
return deferLater(reactor, 0, _check_fds, None)
return self.pool.closeCachedConnections().addBoth(_check_fds)
3
Example 45
@defer.inlineCallbacks
def testPause(self):
items = range(3)
dq = ResizableDispatchQueue(self.slow, 1)
map(dq.put, items)
reactor.callLater(0.2, self._testPaused, dq)
yield task.deferLater(reactor, 0.1, dq.pause)
pendingJobs = dq.pending()
self.assertEqual([p.jobarg for p in pendingJobs], [1, 2])
3
Example 46
def wait0(r=None):
"""
Wait zero seconds to give the reactor a chance to work.
Returns its (optional) argument, so it's useful as a callback.
"""
from twisted.internet import reactor
return deferLater(reactor, 0, lambda: r)
3
Example 47
Project: scrapy Source File: mockserver.py
def deferRequest(self, request, delay, f, *a, **kw):
def _cancelrequest(_):
# silence CancelledError
d.addErrback(lambda _: None)
d.cancel()
d = deferLater(reactor, delay, f, *a, **kw)
request.notifyFinish().addErrback(_cancelrequest)
return d
3
Example 48
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testPauseResumeStop(self):
"""
Pause a queue, then resume it, then stop it and check its contents.
"""
items = range(3)
dq = ResizableDispatchQueue(self.slow, 1)
map(dq.put, items)
d1 = task.deferLater(reactor, 0.1, dq.pause)
reactor.callLater(0.5, dq.resume)
reactor.callLater(0.51, self._testNotPaused, dq)
d2 = self._stopAndTest(0.6, dq, [2])
yield d1
yield d2
3
Example 49
Project: Tor2web Source File: stats.py
def update_stats(self, run_again=True):
yesterday = date.today() - timedelta(1)
hidden_services = list()
for k in self:
hidden_services.append(({'id': k, 'access_count': self[k]}))
self.yesterday_stats = json.dumps({'date': yesterday.strftime('%Y-%m-%d'),
'hidden_services': hidden_services})
self.clear()
next_time = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) + \
timedelta(days=1)
next_delta = (next_time - datetime.now()).total_seconds()
deferLater(reactor, next_delta, self.update_stats)
2
Example 50
Project: txrdq Source File: test_rdq.py
@defer.inlineCallbacks
def testPausePlayAroundResumeStop(self):
# As above, with some playing around while paused.
items = range(3)
dq = ResizableDispatchQueue(self.slow, 1)
map(dq.put, items)
d1 = task.deferLater(reactor, 0.1, dq.pause)
reactor.callLater(0.12, dq.setWidth, 100)
reactor.callLater(0.16, dq.setWidth, 0)
reactor.callLater(0.2, dq.setWidth, 2)
reactor.callLater(0.5, dq.resume)
d2 = self._stopAndTest(0.6, dq, [])
yield d1
yield d2