def __init__(self, engine=None, history=None):
assert(engine==None or IEngineCore.providedBy(engine))
self.engine = IEngineCore(engine)
if history is None:
self.history = FrontEndHistory(input_cache=[''])
else:
self.history = history
def __init__(self, engine=None, history=None):
assert (engine == None or IEngineCore.providedBy(engine))
self.engine = IEngineCore(engine)
if history is None:
self.history = FrontEndHistory(input_cache=[''])
else:
self.history = history
class AsyncFrontEndBase(FrontEndBase):
"""
Overrides FrontEndBase to wrap execute in a deferred result.
All callbacks are made as callbacks on the deferred result.
"""
implements(IFrontEnd)
classProvides(IFrontEndFactory)
def __init__(self, engine=None, history=None):
assert(engine==None or IEngineCore.providedBy(engine))
self.engine = IEngineCore(engine)
if history is None:
self.history = FrontEndHistory(input_cache=[''])
else:
self.history = history
def execute(self, block, blockID=None):
"""Execute the block and return the deferred result.
Parameters:
block : {str, AST}
blockID : any
Caller may provide an ID to identify this block.
result['blockID'] := blockID
Result:
Deferred result of self.interpreter.execute
"""
if(not self.is_complete(block)):
return Failure(Exception("Block is not compilable"))
if(blockID == None):
blockID = guid.generate()
d = self.engine.execute(block)
d.addCallback(self._add_history, block=block)
d.addCallbacks(self._add_block_id_for_result,
errback=self._add_block_id_for_failure,
callbackArgs=(blockID,),
errbackArgs=(blockID,))
d.addBoth(self.update_cell_prompt, blockID=blockID)
d.addCallbacks(self.render_result,
errback=self.render_error)
return d
class AsyncFrontEndBase(FrontEndBase):
"""
Overrides FrontEndBase to wrap execute in a deferred result.
All callbacks are made as callbacks on the deferred result.
"""
implements(IFrontEnd)
classProvides(IFrontEndFactory)
def __init__(self, engine=None, history=None):
assert(engine==None or IEngineCore.providedBy(engine))
self.engine = IEngineCore(engine)
if history is None:
self.history = FrontEndHistory(input_cache=[''])
else:
self.history = history
def execute(self, block, blockID=None):
"""Execute the block and return the deferred result.
Parameters:
block : {str, AST}
blockID : any
Caller may provide an ID to identify this block.
result['blockID'] := blockID
Result:
Deferred result of self.interpreter.execute
"""
if(not self.is_complete(block)):
return Failure(Exception("Block is not compilable"))
if(blockID == None):
blockID = guid.generate()
d = self.engine.execute(block)
d.addCallback(self._add_history, block=block)
d.addCallbacks(self._add_block_id_for_result,
errback=self._add_block_id_for_failure,
callbackArgs=(blockID,),
errbackArgs=(blockID,))
d.addBoth(self.update_cell_prompt, blockID=blockID)
d.addCallbacks(self.render_result,
errback=self.render_error)
return d
def register_engine(self,
remoteEngine,
id=None,
ip=None,
port=None,
pid=None):
"""Register new engine connection"""
# What happens if these assertions fail?
assert IEngineCore.providedBy(remoteEngine), \
"engine passed to register_engine doesn't provide IEngineCore"
assert IEngineSerialized.providedBy(remoteEngine), \
"engine passed to register_engine doesn't provide IEngineSerialized"
assert IEngineQueued.providedBy(remoteEngine), \
"engine passed to register_engine doesn't provide IEngineQueued"
assert isinstance(id, int) or id is None, \
"id to register_engine must be an integer or None"
assert isinstance(ip, str) or ip is None, \
"ip to register_engine must be a string or None"
assert isinstance(port, int) or port is None, \
"port to register_engine must be an integer or None"
assert isinstance(pid, int) or pid is None, \
"pid to register_engine must be an integer or None"
desiredID = id
if desiredID in self.engines.keys():
desiredID = None
if desiredID in self.availableIDs:
getID = desiredID
self.availableIDs.remove(desiredID)
else:
getID = self.availableIDs.pop()
remoteEngine.id = getID
remoteEngine.service = self
self.engines[getID] = remoteEngine
# Log the Engine Information for monitoring purposes
self._logEngineInfoToFile(getID, ip, port, pid)
msg = "registered engine with id: %i" % getID
log.msg(msg)
for i in range(len(self._onRegister)):
(f, args, kwargs, ifid) = self._onRegister[i]
try:
if ifid:
f(getID, *args, **kwargs)
else:
f(*args, **kwargs)
except:
self._onRegister.pop(i)
# Call functions when the nth engine is registered and them remove them
for i, (n, f, args, kwargs) in enumerate(self._onNRegistered):
if len(self.engines.keys()) == n:
try:
try:
f(*args, **kwargs)
except:
log.msg(
"Function %r failed when the %ith engine registered"
% (f, n))
finally:
self._onNRegistered.pop(i)
return {'id': getID}
def register_engine(self, remoteEngine, id=None,
ip=None, port=None, pid=None):
"""Register new engine connection"""
# What happens if these assertions fail?
assert IEngineCore.providedBy(remoteEngine), \
"engine passed to register_engine doesn't provide IEngineCore"
assert IEngineSerialized.providedBy(remoteEngine), \
"engine passed to register_engine doesn't provide IEngineSerialized"
assert IEngineQueued.providedBy(remoteEngine), \
"engine passed to register_engine doesn't provide IEngineQueued"
assert isinstance(id, int) or id is None, \
"id to register_engine must be an integer or None"
assert isinstance(ip, str) or ip is None, \
"ip to register_engine must be a string or None"
assert isinstance(port, int) or port is None, \
"port to register_engine must be an integer or None"
assert isinstance(pid, int) or pid is None, \
"pid to register_engine must be an integer or None"
desiredID = id
if desiredID in self.engines.keys():
desiredID = None
if desiredID in self.availableIDs:
getID = desiredID
self.availableIDs.remove(desiredID)
else:
getID = self.availableIDs.pop()
remoteEngine.id = getID
remoteEngine.service = self
self.engines[getID] = remoteEngine
# Log the Engine Information for monitoring purposes
self._logEngineInfoToFile(getID, ip, port, pid)
msg = "registered engine with id: %i" %getID
log.msg(msg)
for i in range(len(self._onRegister)):
(f,args,kwargs,ifid) = self._onRegister[i]
try:
if ifid:
f(getID, *args, **kwargs)
else:
f(*args, **kwargs)
except:
self._onRegister.pop(i)
# Call functions when the nth engine is registered and them remove them
for i, (n, f, args, kwargs) in enumerate(self._onNRegistered):
if len(self.engines.keys()) == n:
try:
try:
f(*args, **kwargs)
except:
log.msg("Function %r failed when the %ith engine registered" % (f, n))
finally:
self._onNRegistered.pop(i)
return {'id':getID}
