def engineList(self, targets):
"""Parse the targets argument into a list of valid engine objects.
:Parameters:
targets : int, list of ints or 'all'
The targets argument to be parsed.
:Returns: List of engine objects.
:Exception:
InvalidEngineID
If targets is not valid or if an engine is not registered.
"""
if isinstance(targets, int):
if targets not in self.engines.keys():
log.msg("Engine with id %i is not registered" % targets)
raise error.InvalidEngineID("Engine with id %i is not registered" % targets)
else:
return [self.engines[targets]]
elif isinstance(targets, (list, tuple)):
for id in targets:
if id not in self.engines.keys():
log.msg("Engine with id %r is not registered" % id)
raise error.InvalidEngineID("Engine with id %r is not registered" % id)
return map(self.engines.get, targets)
elif targets == 'all':
eList = self.engines.values()
if len(eList) == 0:
msg = """There are no engines registered.
Check the logs in ~/.ipython/log if you think there should have been."""
raise error.NoEnginesRegistered(msg)
else:
return eList
else:
raise error.InvalidEngineID("targets argument is not an int, list of ints or 'all': %r"%targets)
def htmlTargetString(self, targets):
if targets == 'all':
return targets
elif isinstance(targets, (tuple, list)):
return ','.join(map(str, targets))
elif isinstance(targets, int):
return str(targets)
raise error.InvalidEngineID(str(targets))
def remote_queueStatus(self, targets):
if not self.multiEngine.verifyTargets(targets):
return defer.fail(error.InvalidEngineID(repr(targets)))
else:
deferredID = self._getNextDeferredID()
d = self.multiEngine.queueStatus(targets)
self.pendingDeferreds[deferredID] = d
return defer.succeed(deferredID)
def remote_kill(self, targets, controller=False):
if not self.multiEngine.verifyTargets(targets):
return defer.fail(error.InvalidEngineID(repr(targets)))
else:
deferredID = self._getNextDeferredID()
d = self.multiEngine.kill(targets, controller)
self.pendingDeferreds[deferredID] = d
return defer.succeed(deferredID)
def remote_gather(self, targets, key, style):
if not self.multiEngine.verifyTargets(targets):
return defer.fail(error.InvalidEngineID(repr(targets)))
else:
deferredID = self._getNextDeferredID()
d = self.multiEngine.gather(targets, key, style)
d.addCallback(pickle.dumps, 2)
d.addCallback(checkMessageSize, repr(key))
self.pendingDeferreds[deferredID] = d
return defer.succeed(deferredID)
def create_targets(ids):
if isinstance(targets, int):
engines = [targets]
elif targets=='all':
engines = ids
elif isinstance(targets, (list, tuple)):
engines = targets
for t in engines:
if not t in ids:
raise error.InvalidEngineID("engine with id %r does not exist"%t)
return engines
def remote_scatter(self, targets, key, pseq, style, flatten):
if not self.multiEngine.verifyTargets(targets):
return defer.fail(error.InvalidEngineID(repr(targets)))
else:
try:
seq = pickle.loads(pseq)
except:
return defer.fail(failure.Failure()).addErrback(packageFailure)
else:
deferredID = self._getNextDeferredID()
d = self.multiEngine.scatter(targets, key, seq, style, flatten)
self.pendingDeferreds[deferredID] = d
return defer.succeed(deferredID)
def remote_pushSerialized(self, targets, pNamespace):
if not self.multiEngine.verifyTargets(targets):
return defer.fail(error.InvalidEngineID(repr(targets)))
else:
try:
namespace = pickle.loads(pNamespace)
except:
return defer.fail(failure.Failure()).addErrback(packageFailure)
else:
deferredID = self._getNextDeferredID()
d = self.multiEngine.pushSerialized(targets, **namespace)
self.pendingDeferreds[deferredID] = d
return defer.succeed(deferredID)
def renderHTTP(self, request):
try:
targetsString = request.prepath[1]
clientID = int(request.args['clientID'][0])
block = int(request.args['block'][0])
except:
return self._badRequest(request)
targetsArg = self.parseTargets(targetsString)
if targetsArg is not False:
d = self.smultiengine.clear_queue(clientID, True, targetsArg)
d.addCallbacks(self.packageSuccess, self.packageFailure)
return d
else:
return self.packageFailure(failure.Failure(
error.InvalidEngineID()))
def renderHTTP(self, request):
try:
targetsString = request.prepath[1]
clientID = int(request.args['clientID'][0])
block = int(request.args['block'][0])
# keys = pickle.loads(request.args['keys'][0])
except:
return self._badRequest(request)
targetsArg = self.parseTargets(targetsString)
if targetsArg is not False:
d = self.smultiengine.clear_properties(clientID, block, targetsArg)
# d.addBoth(_printer)
d.addCallbacks(self.packageSuccess, self.packageFailure)
return d
else:
return self.packageFailure(failure.Failure(
error.InvalidEngineID()))
def renderHTTP(self, request):
try:
targetsString = request.prepath[1]
clientID = int(request.args['clientID'][0])
block = int(request.args['block'][0])
pns = request.args['namespace'][0]
ns = pickle.loads(pns)
except:
return self._badRequest(request)
targetsArg = self.parseTargets(targetsString)
if targetsArg is not False:
d = self.smultiengine.push(clientID, block, targetsArg, **ns)
d.addCallbacks(self.packageSuccess, self.packageFailure)
return d
else:
return self.packageFailure(failure.Failure(
error.InvalidEngineID()))
def renderHTTP(self, request):
try:
targetsString = request.prepath[1]
clientID = int(request.args['clientID'][0])
block = int(request.args['block'][0])
key = request.args['key'][0]
style = request.args['style'][0]
except:
return self._badRequest(request)
targetsArg = self.parseTargets(targetsString)
if targetsArg is not False:
d = self.smultiengine.gather(clientID, block, targetsArg, key,
style)
d.addBoth(_printer)
d.addCallbacks(self.packageSuccess, self.packageFailure)
return d
else:
return self.packageFailure(failure.Failure(
error.InvalidEngineID()))
def renderHTTP(self, request):
try:
targetsString = request.prepath[1]
clientID = int(request.args['clientID'][0])
block = int(request.args['block'][0])
ids = request.args['id'][0]
if ids == 'None':
id = None
else:
id = int(ids)
except:
return self._badRequest(request)
targetsArg = self.parseTargets(targetsString)
if targetsArg is not False:
d = self.smultiengine.get_result(clientID, block, targetsArg, id)
d.addCallbacks(self.packageSuccess, self.packageFailure)
return d
else:
return self.packageFailure(failure.Failure(
error.InvalidEngineID()))
def renderHTTP(self, request):
try:
targetsString = request.prepath[1]
clientID = int(request.args['clientID'][0])
block = int(request.args['block'][0])
key = request.args['key'][0]
seq = pickle.loads(request.args['seq'][0])
style = request.args['style'][0]
flatten = bool(int(request.args['flatten'][0]))
except:
return self._badRequest(request)
targetsArg = self.parseTargets(targetsString)
if targetsArg is not False:
d = self.smultiengine.scatter(clientID, block, targetsArg, key,
seq, style, flatten)
d.addCallbacks(self.packageSuccess, self.packageFailure)
return d
else:
return self.packageFailure(failure.Failure(
error.InvalidEngineID()))
def remote_execute(self, clientID, block, targets, lines):
if not self.multiEngine.verifyTargets(targets):
return defer.fail(error.InvalidEngineID(
repr(targets))).addErrback(packageFailure)
else:
return self.multiEngine.execute(clientID, block, targets, lines)
