def _main_async(reactor, argv=None, _abort_for_test=False):
if argv is None:
argv = sys.argv
if not _abort_for_test:
# Some log messages would be discarded if we did not set up things early.
configure_logging()
# Option parsing is done before importing the main modules so as to avoid the cost of initializing gnuradio if we are aborting early. TODO: Make that happen for createConfig too.
argParser = argparse.ArgumentParser(prog=argv[0])
argParser.add_argument('config_path',
metavar='CONFIG',
help='path of configuration directory or file')
argParser.add_argument(
'--create',
dest='createConfig',
action='store_true',
help='write template configuration file to CONFIG and exit')
argParser.add_argument('-g, --go',
dest='openBrowser',
action='store_true',
help='open the UI in a web browser')
argParser.add_argument(
'--force-run',
dest='force_run',
action='store_true',
help='Run DSP even if no client is connected (for debugging).')
args = argParser.parse_args(args=argv[1:])
# Verify we can actually run.
# Note that this must be done before we actually load core modules, because we might get an import error then.
version_report = yield _check_versions()
if version_report:
print(version_report, file=sys.stderr)
sys.exit(1)
# Write config file and exit, if asked to do so.
if args.createConfig:
write_default_config(args.config_path)
_log.info('Created default configuration at: {config_path}',
config_path=args.config_path)
sys.exit(0) # TODO: Consider using a return value or something instead
# Refuse to run as root.
if hasattr(os, 'getuid') and os.getuid() == 0:
print(
'Network services should not be run as root. Refusing to start ShinySDR.',
file=sys.stderr)
sys.exit(1)
# Read config file.
config_obj = Config(reactor=reactor, log=_log)
try:
execute_config(config_obj, args.config_path)
yield config_obj._wait_and_validate()
except ConfigException:
print_config_exception(sys.exc_info(), sys.stderr)
defer.returnValue(None)
return
_log.info('Constructing...')
app = config_obj._create_app()
reactor.addSystemEventTrigger('during', 'shutdown', app.close_all_devices)
_log.info('Restoring state...')
pfg = PersistenceFileGlue(reactor=reactor,
root_object=app,
filename=config_obj._state_filename,
get_defaults=_app_defaults)
_log.info('Starting web server...')
services = MultiService()
for maker in config_obj._service_makers:
IService(maker(app)).setServiceParent(services)
services.startService()
_log.info('ShinySDR is ready.')
for service in services:
# TODO: should have an interface (currently no proper module to put it in)
service.announce(args.openBrowser)
if args.force_run:
_log.debug('force_run')
# TODO kludge, make this less digging into guts
app.get_receive_flowgraph().get_monitor().state()['fft'].subscribe2(
lambda v: None, the_subscription_context)
if _abort_for_test:
services.stopService()
yield pfg.sync()
defer.returnValue(app)
else:
yield defer.Deferred() # never fires
def __init__(self):
ws.WebSocketClientProtocol.__init__(self)
self.opened = defer.Deferred()
self.closed = defer.Deferred()
def getHeadline(self, input):
self.d = defer.Deferred()
reactor.callLater(1, self.processHeadline, input)
self.d.addCallback(self._toHTML)
return self.d
def run_flow(self,
duration,
tasks=None,
start_d=None,
start_flow=True,
stop_flow=True):
self.debug('run_flow: tasks: %r' % (tasks, ))
flow_d = start_d
if tasks is None:
tasks = []
if flow_d is None:
if start_flow:
flow_d = self.start_flow()
else:
flow_d = defer.succeed(True)
flow_started_finished = [False, False]
guard_d = None
timeout_d = defer.Deferred()
stop_d = defer.Deferred()
stop_timeout_d = defer.Deferred()
chained_d = None
callids = [None, None, None] # callLater ids: stop_d,
# timeout_d, fire_chained
if tasks:
# if have tasks, run simultaneously with the main timer deferred
chained_d = defer.DeferredList([stop_d] + tasks,
fireOnOneErrback=1,
consumeErrors=1)
def chained_failed(failure):
self.info('chained_failed: %r' % (failure, ))
failure.trap(defer.FirstError)
return failure.value.subFailure
chained_d.addErrback(chained_failed)
else:
# otherwise, just idle...
chained_d = stop_d
def start_complete(result):
self.debug('start_complete: %r' % (result, ))
flow_started_finished[0] = True
callids[0] = reactor.callLater(duration, stop_d.callback, None)
if tasks:
def _fire_chained():
callids[2] = None
for t in tasks:
try:
t.callback(result)
except defer.AlreadyCalledError:
pass
callids[2] = reactor.callLater(0, _fire_chained)
return chained_d
def flow_complete(result):
self.debug('flow_complete: %r' % (result, ))
flow_started_finished[1] = True
return result
def flow_timed_out():
self.debug('flow_timed_out!')
if not flow_started_finished[0]:
timeout_d.errback(StartTimeout('flow start timed out'))
elif not flow_started_finished[1]:
timeout_d.errback(FlowTimeout('flow run timed out'))
else:
stop_timeout_d.errback(StopTimeout('flow stop timed out'))
def clean_calls(result):
self.debug('clean_calls: %r' % (result, ))
for i, cid in enumerate(callids):
if cid is not None:
if cid.active():
cid.cancel()
callids[i] = None
return result
flow_d.addCallback(start_complete)
flow_d.addCallback(flow_complete)
guard_d = defer.DeferredList([flow_d, timeout_d],
consumeErrors=1,
fireOnOneErrback=1,
fireOnOneCallback=1)
def guard_failed(failure):
self.info('guard_failed: %r' % (failure, ))
failure.trap(defer.FirstError)
return failure.value.subFailure
if stop_flow:
def _force_stop_flow(result):
self.debug('_force_stop_flow: %r' % (result, ))
d = defer.DeferredList([self.stop_flow(), stop_timeout_d],
fireOnOneErrback=1,
fireOnOneCallback=1,
consumeErrors=1)
def _return_orig_result(stop_result):
if isinstance(result, failure.Failure):
# always return the run's failure first
# what do I return if both the run and stop failed?
self.debug('_return_orig[R]: %r' % (result, ))
return result
elif isinstance(stop_result, failure.Failure):
# return failure from stop
self.debug('_return_orig[S]: %r' % (stop_result, ))
return stop_result
return result
def force_stop_failed(failure):
self.info('force_stop_failed: %r' % (failure, ))
failure.trap(defer.FirstError)
return failure.value.subFailure
d.addCallbacks(lambda r: r[0], force_stop_failed)
d.addBoth(_return_orig_result)
return d
guard_d.addBoth(_force_stop_flow)
guard_d.addErrback(guard_failed)
guard_d.addBoth(clean_calls)
callids[1] = reactor.callLater(self.guard_timeout, flow_timed_out)
return guard_d
def close(self):
self.closing = defer.Deferred()
self._maybe_fire_closing()
return self.closing
def _registerDeferredAsOutputChannel(self):
d = defer.Deferred()
self.addOutput(d.callback)
return d
def __init__(self):
BuildStep.__init__(self)
self._deferred = defer.Deferred()
def gotListeningPort(listeningPort):
def cancel(d):
listeningPort.stopListening()
return defer.Deferred(cancel)
def __init__(self, stream, boundary):
self.stream = stream
self.boundary = boundary
self.data = ''
self.deferred = defer.Deferred()
def update(self, data, tid=None):
dd = defer.Deferred()
log.debug('update requested') # : %s %s' % (data, self.length))
def updated(res):
log.debug('playlist updated')
if len(self.tracks) > 0:
self.mpd.idArray = id_array(self.tracks)
self.mpd.oh_eventPLAYLIST(self.mpd.idArray, 'idarray')
self.plsversion = self.mpd.status['playlist']
if tid:
if int(tid) in self.tracks:
dd.callback(tid)
else:
dd.errback()
def format_track(track):
en = et.Element('Entry')
i = et.Element('Id')
if 'id' not in track:
log.critical('issue with playlist :%s' % track)
i.text = track['id']
en.append(i)
uri = et.Element('Uri')
uri.text = track['url'].decode('utf-8')
en.append(uri)
md = et.Element('Metadata')
md.text = didl_encode(track)
en.append(md)
return (
en,
track,
)
def setter(res, pos):
# print('playlist detail: %s %s' % (pos, res))
self.details[pos] = res
if data is not None:
if not isinstance(data, list):
data = [data]
if self.length == 0:
log.debug('empty')
self.tracks = []
self.details = []
return
else:
l = []
delta = self.length - len(self.tracks)
# print('delta= %d' % delta)
if delta >= 0:
for track in data:
# self.cache_cover(track)
try:
if int(track['Pos']) >= len(self.tracks):
self.tracks.append(int(track['Id']))
d = self.mpd.call('playlistid', track['Id'])
d.addCallback(self.get_cover, track['Id'])
d.addCallback(mpd_decode)
d.addCallback(format_track)
d.addCallback(self.details.append)
else:
self.tracks[int(track['Pos'])] = int(
track['Id'])
d = self.mpd.call('playlistid', track['Id'])
d.addCallback(self.get_cover)
d.addCallback(mpd_decode)
d.addCallback(format_track)
d.addCallback(setter, int(track['Pos']))
l.append(d)
except:
continue
else:
for track in data:
if 'Id' not in track:
continue
if track == {}:
self.tracks.pop()
self.details.pop()
delta += 1
continue
if delta < 0:
self.tracks.pop(int(track['Pos']))
self.details.pop(int(track['Pos']))
delta += 1
else:
self.tracks[int(track['Pos'])] = int(track['Id'])
d = self.mpd.call('playlistid', track['Id'])
d.addCallback(self.get_cover)
d.addCallback(mpd_decode)
d.addCallback(format_track)
d.addCallback(setter, int(track['Pos']))
l.append(d)
if len(l) > 0:
dl = defer.gatherResults(l, consumeErrors=False)
dl.addCallback(updated)
else:
log.warn('Playlist update request returned no data')
if tid:
return dd
else:
dd = None
def startService(self):
assert not self._already_started, "can only start the master once"
self._already_started = True
log.msg("Starting BuildMaster -- buildbot.version: %s" %
buildbot.version)
# Set umask
if self.umask is not None:
os.umask(self.umask)
# first, apply all monkeypatches
monkeypatches.patch_all()
# we want to wait until the reactor is running, so we can call
# reactor.stop() for fatal errors
d = defer.Deferred()
self.reactor.callWhenRunning(d.callback, None)
yield d
startup_succeed = False
try:
yield self.initLock.acquire()
# load the configuration file, treating errors as fatal
try:
# run the master.cfg in thread, so that it can use blocking
# code
self.config = yield threads.deferToThreadPool(
self.reactor, self.reactor.getThreadPool(),
self.config_loader.loadConfig)
except config.ConfigErrors as e:
log.msg("Configuration Errors:")
for msg in e.errors:
log.msg(" " + msg)
log.msg("Halting master.")
self.reactor.stop()
return
except Exception:
log.err(failure.Failure(), 'while starting BuildMaster')
self.reactor.stop()
return
# set up services that need access to the config before everything
# else gets told to reconfig
try:
yield self.db.setup()
except exceptions.DatabaseNotReadyError:
# (message was already logged)
self.reactor.stop()
return
self.mq.setup()
if hasattr(signal, "SIGHUP"):
def sighup(*args):
eventually(self.reconfig)
signal.signal(signal.SIGHUP, sighup)
if hasattr(signal, "SIGUSR1"):
def sigusr1(*args):
eventually(self.botmaster.cleanShutdown)
signal.signal(signal.SIGUSR1, sigusr1)
# get the masterid so other services can use it in
# startup/reconfig. This goes directly to the DB since the data
# API isn't initialized yet, and anyway, this method is aware of
# the DB API since it just called its setup function
self.masterid = yield self.db.masters.findMasterId(name=self.name)
# mark this master as stopped, in case it crashed before
yield self.data.updates.masterStopped(name=self.name,
masterid=self.masterid)
# call the parent method
yield service.AsyncMultiService.startService(self)
# We make sure the housekeeping is done before configuring in order to cleanup
# any remaining claimed schedulers or change sources from zombie
# masters
yield self.data.updates.expireMasters(forceHouseKeeping=True)
# give all services a chance to load the new configuration, rather
# than the base configuration
yield self.reconfigServiceWithBuildbotConfig(self.config)
# Mark the master as active now that mq is running
yield self.data.updates.masterActive(name=self.name,
masterid=self.masterid)
# Start the heartbeat timer
yield self.masterHeartbeatService.setServiceParent(self)
# send the statistics to buildbot.net, without waiting
self.sendBuildbotNetUsageData()
startup_succeed = True
except Exception:
f = failure.Failure()
log.err(f, 'while starting BuildMaster')
self.reactor.stop()
finally:
if startup_succeed:
log.msg("BuildMaster is running")
else:
log.msg("BuildMaster startup failed")
yield self.initLock.release()
self._master_initialized = True
def setup_waiter((bsid,brids)):
d = defer.Deferred()
self._waiters[bsid] = (d, brids)
self._updateWaiters()
return d
def __init__(self):
self.deferred = defer.Deferred()
self.out = b''
self.err = b''
self.exitcode = None
def __init__(self):
self.deferred = defer.Deferred()
self.io = StringIO()
self.write = self.io.write
def setUp(self):
"""Set up."""
self.connlost_deferred = defer.Deferred()
return super(AQCancelTestBase, self).setUp()
def deferUntilLater(secs, result=None):
d = defer.Deferred()
reactor.callLater(secs, d.callback, result)
return d
def prepare(self):
self.d = defer.Deferred()
return self.d
def handleMessage(self, lmsg):
"""Implements the LLRP client state machine."""
logger.debug('LLRPMessage received in state %s: %s', self.state, lmsg)
msgName = lmsg.getName()
lmsg.peername = self.peername
# call per-message callbacks
logger.debug('starting message callbacks for %s', msgName)
for fn in self._message_callbacks[msgName]:
fn(lmsg)
logger.debug('done with message callbacks for %s', msgName)
# keepalives can occur at any time
if msgName == 'KEEPALIVE':
self.send_KEEPALIVE_ACK()
return
if msgName == 'RO_ACCESS_REPORT' and \
self.state != LLRPClient.STATE_INVENTORYING:
logger.debug('ignoring RO_ACCESS_REPORT because not inventorying')
return
logger.debug('in handleMessage(%s), there are %d Deferreds', msgName,
len(self._deferreds[msgName]))
#######
# LLRP client state machine follows. Beware: gets thorny. Note the
# order of the LLRPClient.STATE_* fields.
#######
# in DISCONNECTED, CONNECTING, and CONNECTED states, expect only
# READER_EVENT_NOTIFICATION messages.
if self.state in (LLRPClient.STATE_DISCONNECTED,
LLRPClient.STATE_CONNECTING,
LLRPClient.STATE_CONNECTED):
if msgName != 'READER_EVENT_NOTIFICATION':
logger.error('unexpected message %s while connecting', msgName)
return
if not lmsg.isSuccess():
try:
status = lmsg.msgdict[msgName]\
['ReaderEventNotificationData']\
['ConnectionAttemptEvent']['Status']
except KeyError:
status = '(unknown status)'
logger.fatal('Could not start session on reader: %s', status)
return
self.processDeferreds(msgName, lmsg.isSuccess())
# a Deferred to call when we get GET_READER_CAPABILITIES_RESPONSE
d = defer.Deferred()
d.addCallback(self._setState_wrapper, LLRPClient.STATE_CONNECTED)
d.addErrback(self.panic, 'GET_READER_CAPABILITIES failed')
self.send_GET_READER_CAPABILITIES(onCompletion=d)
# in state SENT_GET_CAPABILITIES, expect only GET_CAPABILITIES_RESPONSE;
# respond to this message by advancing to state CONNECTED.
elif self.state == LLRPClient.STATE_SENT_GET_CAPABILITIES:
if msgName != 'GET_READER_CAPABILITIES_RESPONSE':
logger.error(
'unexpected response %s when getting capabilities',
msgName)
return
if not lmsg.isSuccess():
status = lmsg.msgdict[msgName]['LLRPStatus']['StatusCode']
err = lmsg.msgdict[msgName]['LLRPStatus']['ErrorDescription']
logger.fatal('Error %s getting capabilities: %s', status, err)
return
self.capabilities = lmsg.msgdict[
'GET_READER_CAPABILITIES_RESPONSE']
logger.debug('Capabilities: %s', pprint.pformat(self.capabilities))
try:
self.parseCapabilities(self.capabilities)
except LLRPError as err:
logger.exception('Capabilities mismatch')
raise err
self.processDeferreds(msgName, lmsg.isSuccess())
if self.reset_on_connect:
d = self.stopPolitely(disconnect=False)
if self.start_inventory:
d.addCallback(self.startInventory)
elif self.start_inventory:
self.startInventory()
# in state SENT_ADD_ROSPEC, expect only ADD_ROSPEC_RESPONSE; respond to
# favorable ADD_ROSPEC_RESPONSE by enabling the added ROSpec and
# advancing to state SENT_ENABLE_ROSPEC.
elif self.state == LLRPClient.STATE_SENT_ADD_ROSPEC:
if msgName != 'ADD_ROSPEC_RESPONSE':
logger.error('unexpected response %s when adding ROSpec',
msgName)
return
if not lmsg.isSuccess():
status = lmsg.msgdict[msgName]['LLRPStatus']['StatusCode']
err = lmsg.msgdict[msgName]['LLRPStatus']['ErrorDescription']
logger.fatal('Error %s adding ROSpec: %s', status, err)
return
self.processDeferreds(msgName, lmsg.isSuccess())
# in state PAUSING, we have sent a DISABLE_ROSPEC, so expect only
# DISABLE_ROSPEC_RESPONSE. advance to state PAUSED.
elif self.state == LLRPClient.STATE_PAUSING:
if msgName != 'DISABLE_ROSPEC_RESPONSE':
logger.error(
'unexpected response %s '
' when disabling ROSpec', msgName)
if not lmsg.isSuccess():
status = lmsg.msgdict[msgName]['LLRPStatus']['StatusCode']
err = lmsg.msgdict[msgName]['LLRPStatus']['ErrorDescription']
logger.error('DISABLE_ROSPEC failed with status %s: %s',
status, err)
logger.warn('Error %s disabling ROSpec: %s', status, err)
self.processDeferreds(msgName, lmsg.isSuccess())
# in state SENT_ENABLE_ROSPEC, expect only ENABLE_ROSPEC_RESPONSE;
# respond to favorable ENABLE_ROSPEC_RESPONSE by starting the enabled
# ROSpec and advancing to state INVENTORYING.
elif self.state == LLRPClient.STATE_SENT_ENABLE_ROSPEC:
if msgName != 'ENABLE_ROSPEC_RESPONSE':
logger.error('unexpected response %s when enabling ROSpec',
msgName)
if not lmsg.isSuccess():
status = lmsg.msgdict[msgName]['LLRPStatus']['StatusCode']
err = lmsg.msgdict[msgName]['LLRPStatus']['ErrorDescription']
logger.error('ENABLE_ROSPEC failed with status %s: %s', status,
err)
logger.fatal('Error %s enabling ROSpec: %s', status, err)
return
self.processDeferreds(msgName, lmsg.isSuccess())
elif self.state == LLRPClient.STATE_INVENTORYING:
if msgName not in ('RO_ACCESS_REPORT', 'READER_EVENT_NOTIFICATION',
'ADD_ACCESSSPEC_RESPONSE',
'ENABLE_ACCESSSPEC_RESPONSE',
'DISABLE_ACCESSSPEC_RESPONSE',
'DELETE_ACCESSSPEC_RESPONSE'):
logger.error('unexpected message %s while inventorying',
msgName)
return
self.processDeferreds(msgName, lmsg.isSuccess())
elif self.state == LLRPClient.STATE_SENT_DELETE_ACCESSSPEC:
if msgName != 'DELETE_ACCESSSPEC_RESPONSE':
logger.error('unexpected response %s when deleting AccessSpec',
msgName)
self.processDeferreds(msgName, lmsg.isSuccess())
elif self.state == LLRPClient.STATE_SENT_DELETE_ROSPEC:
if msgName != 'DELETE_ROSPEC_RESPONSE':
logger.error('unexpected response %s when deleting ROSpec',
msgName)
if lmsg.isSuccess():
logger.info('reader finished inventory')
if self.disconnecting:
self.setState(LLRPClient.STATE_DISCONNECTED)
else:
self.setState(LLRPClient.STATE_CONNECTED)
else:
status = lmsg.msgdict[msgName]['LLRPStatus']['StatusCode']
err = lmsg.msgdict[msgName]['LLRPStatus']['ErrorDescription']
logger.error('DELETE_ROSPEC failed with status %s: %s', status,
err)
self.processDeferreds(msgName, lmsg.isSuccess())
if self.disconnecting:
logger.info('disconnecting')
self.transport.loseConnection()
else:
logger.warn('message %s received in unknown state!', msgName)
if self._deferreds[msgName]:
logger.error(
'there should NOT be Deferreds left for %s,'
' but there are!', msgName)
def make_unsafe():
self.safe_kick = defer.Deferred()
self.ticker.add_delay(10, make_safe)
def startAccess(self,
readWords=None,
writeWords=None,
target=None,
accessStopParam=None,
accessSpecID=1,
param=None,
*args):
m = Message_struct['AccessSpec']
if not target:
target = {
'MB': 0,
'Pointer': 0,
'MaskBitCount': 0,
'TagMask': '',
'DataBitCount': 0,
'TagData': ''
}
opSpecParam = {
'OpSpecID': 0,
'AccessPassword': 0,
}
if readWords:
opSpecParam['MB'] = readWords['MB']
opSpecParam['WordPtr'] = readWords['WordPtr']
opSpecParam['WordCount'] = readWords['WordCount']
if 'OpSpecID' in readWords:
opSpecParam['OpSpecID'] = readWords['OpSpecID']
if 'AccessPassword' in readWords:
opSpecParam['AccessPassword'] = readWords['AccessPassword']
elif writeWords:
opSpecParam['MB'] = writeWords['MB']
opSpecParam['WordPtr'] = writeWords['WordPtr']
opSpecParam['WriteDataWordCount'] = writeWords[
'WriteDataWordCount']
opSpecParam['WriteData'] = writeWords['WriteData']
if 'OpSpecID' in writeWords:
opSpecParam['OpSpecID'] = writeWords['OpSpecID']
if 'AccessPassword' in writeWords:
opSpecParam['AccessPassword'] = writeWords['AccessPassword']
elif param:
# special parameters like C1G2Lock
opSpecParam = param
else:
raise LLRPError('startAccess requires readWords or writeWords.')
if not accessStopParam:
accessStopParam = {}
accessStopParam['AccessSpecStopTriggerType'] = 1
accessStopParam['OperationCountValue'] = 5
accessSpec = {
'Type': m['type'],
'AccessSpecID': accessSpecID,
'AntennaID': 0, # all antennas
'ProtocolID': AirProtocol['EPCGlobalClass1Gen2'],
'C': False, # disabled by default
'ROSpecID': 0, # all ROSpecs
'AccessSpecStopTrigger': accessStopParam,
'AccessCommand': {
'TagSpecParameter': {
'C1G2TargetTag': { # XXX correct values?
'MB': target['MB'],
'M': 1,
'Pointer': target['Pointer'],
'MaskBitCount': target['MaskBitCount'],
'TagMask': target['TagMask'],
'DataBitCount': target['DataBitCount'],
'TagData': target['TagData']
}
},
'OpSpecParameter': opSpecParam,
},
'AccessReportSpec': {
'AccessReportTrigger': 1 # report at end of access
}
}
d = defer.Deferred()
d.addCallback(self.send_ENABLE_ACCESSSPEC, accessSpecID)
d.addErrback(self.panic, 'ADD_ACCESSSPEC failed')
self.send_ADD_ACCESSSPEC(accessSpec, onCompletion=d)
def startStep(*args, **kw):
# Now interrupt the build
b.stopBuild("stop it")
return defer.Deferred()
def test_verify_json_objects_for_server_awaits_previous_requests(self):
key1 = signedjson.key.generate_signing_key(1)
kr = keyring.Keyring(self.hs)
json1 = {}
signedjson.sign.sign_json(json1, "server10", key1)
persp_resp = {
"server_keys": [
self.mock_perspective_server.get_signed_key(
"server10", signedjson.key.get_verify_key(key1))
]
}
persp_deferred = defer.Deferred()
@defer.inlineCallbacks
def get_perspectives(**kwargs):
self.assertEquals(LoggingContext.current_context().request, "11")
with PreserveLoggingContext():
yield persp_deferred
return persp_resp
self.http_client.post_json.side_effect = get_perspectives
# start off a first set of lookups
@defer.inlineCallbacks
def first_lookup():
with LoggingContext("11") as context_11:
context_11.request = "11"
res_deferreds = kr.verify_json_objects_for_server([
("server10", json1, 0, "test10"),
("server11", {}, 0, "test11")
])
# the unsigned json should be rejected pretty quickly
self.assertTrue(res_deferreds[1].called)
try:
yield res_deferreds[1]
self.assertFalse("unsigned json didn't cause a failure")
except SynapseError:
pass
self.assertFalse(res_deferreds[0].called)
res_deferreds[0].addBoth(self.check_context, None)
yield make_deferred_yieldable(res_deferreds[0])
# let verify_json_objects_for_server finish its work before we kill the
# logcontext
yield self.clock.sleep(0)
d0 = first_lookup()
# wait a tick for it to send the request to the perspectives server
# (it first tries the datastore)
self.pump()
self.http_client.post_json.assert_called_once()
# a second request for a server with outstanding requests
# should block rather than start a second call
@defer.inlineCallbacks
def second_lookup():
with LoggingContext("12") as context_12:
context_12.request = "12"
self.http_client.post_json.reset_mock()
self.http_client.post_json.return_value = defer.Deferred()
res_deferreds_2 = kr.verify_json_objects_for_server([
("server10", json1, 0, "test")
])
res_deferreds_2[0].addBoth(self.check_context, None)
yield make_deferred_yieldable(res_deferreds_2[0])
# let verify_json_objects_for_server finish its work before we kill the
# logcontext
yield self.clock.sleep(0)
d2 = second_lookup()
self.pump()
self.http_client.post_json.assert_not_called()
# complete the first request
persp_deferred.callback(persp_resp)
self.get_success(d0)
self.get_success(d2)
def delayed_d(time, val):
"""Insert some delay into callback chain."""
d = defer.Deferred()
reactor.callLater(time, d.callback, val)
return d
def remote_deferredJelly(self):
d = defer.Deferred()
d.addCallback(self.raiseJelly)
d.callback(None)
return d
from twisted.internet import defer
def canceller(d):
print "I need to cancel this deferred:", d
print "Firing the deferred with a result"
d.callback('result')
def callback(res):
print 'callback got:', res
def errback(err):
print 'errback got:', err
d = defer.Deferred(canceller) # created by lower-level code
d.addCallbacks(callback, errback) # added by higher-level code
d.cancel()
print 'done'
def remote_deferredSecurity(self):
d = defer.Deferred()
d.addCallback(self.raiseSecurity)
d.callback(None)
return d
def __init__(self, uri):
ws.WebSocketClientFactory.__init__(self, uri)
self.proto = None
self.connected = defer.Deferred()
def stopService(self):
self.d = defer.Deferred()
return self.d
def __init__(self):
service.AsyncMultiService.__init__(self)
self.app = self.router_url = None
self.serviceDeferred = defer.Deferred()
self.service = None
def __init__(self):
self.deferred = defer.Deferred()
