def addEngine(self, n=1):
for i in range(n):
e = es.EngineService()
e.startService()
regDict = self.multiengine.registerEngine(es.QueuedEngine(e), None)
e.id = regDict['id']
self.engines.append(e)
def setUp(self):
self.services = []
self.clients = []
self.servers = []
# Start a server and append to self.servers
self.sf = VanillaEngineServerFactoryFromControllerService(self)
self.servers.append(reactor.listenTCP(10201, self.sf))
# Start an EngineService and append to services/client
self.engines = es.EngineService()
ef = VanillaEngineClientFactoryFromEngineService(self.engines)
#starterDeferred = defer.Deferred()
#def myNotifySetID():
# starterDeferred.callback(None)
#ef.notifySetID = myNotifySetID
client = reactor.connectTCP('127.0.0.1', 10201, ef)
self.clients.append(client)
self.services.append(self.engines)
self.engines.startService()
# Create and returna Deferred that will fire when self.registerEngine
# is called. By returning this deferred, the actual tests will not
# be run until the client has connected and is registered.
self.setUpDeferred = defer.Deferred()
return self.setUpDeferred
def testRegisterUnregisterMultipleEngines(self):
e1 = es.EngineService()
qe1 = es.QueuedEngine(e1)
e2 = es.EngineService()
qe2 = es.QueuedEngine(e2)
rd1 = self.controller.registerEngine(qe1, 0)
self.assertEquals(rd1['id'], 0)
rd2 = self.controller.registerEngine(qe2, 1)
self.assertEquals(rd2['id'], 1)
self.controller.unregisterEngine(0)
rd1 = self.controller.registerEngine(qe1, 0)
self.assertEquals(rd1['id'], 0)
self.controller.unregisterEngine(1)
rd2 = self.controller.registerEngine(qe2, 0)
self.assertEquals(rd2['id'], 1)
self.controller.unregisterEngine(0)
self.controller.unregisterEngine(1)
self.assertEquals(self.controller.engines, {})
def testRegisterUnregisterEngine(self):
engine = es.EngineService()
qengine = es.QueuedEngine(engine)
regDict = self.controller.registerEngine(qengine, 0)
self.assert_(isinstance(regDict, dict))
self.assert_(regDict.has_key('id'))
self.assert_(regDict['id'] == 0)
self.controller.unregisterEngine(0)
self.assert_(self.controller.engines.get(0, None) == None)
def testRegisterCallables(self):
e1 = es.EngineService()
qe1 = es.QueuedEngine(e1)
self.registerCallableCalled = ';lkj'
self.unregisterCallableCalled = ';lkj'
self.controller.onRegisterEngineDo(self._registerCallable, False)
self.controller.onUnregisterEngineDo(self._unregisterCallable, False)
self.controller.registerEngine(qe1, 0)
self.assertEquals(self.registerCallableCalled, 'asdf')
self.controller.unregisterEngine(0)
self.assertEquals(self.unregisterCallableCalled, 'asdf')
self.controller.onRegisterEngineDoNot(self._registerCallable)
self.controller.onUnregisterEngineDoNot(self._unregisterCallable)
def setUp(self):
self.c = cs.ControllerService()
self.c.startService()
self.me = IMultiEngine(self.c)
self.tc = task.TaskController(self.c)
self.tc.failurePenalty = 0
self.engines = []
for i in range(1):
e = es.EngineService()
# e.startService()
self.c.registerEngine(es.QueuedEngine(e), i)
self.engines.append(e)
def __init__(self, nbfile, logfile=None):
if logfile:
self.log = open(logfile, 'a')
else:
self.log = stdout
dbutil.initDB()
self.nbc = notebook.NotebookController(
es.IEngineQueued(es.EngineService()))
self.nbu = notebook.NotebookUser(self.nbc, 'test', 'test@localhost')
self.user = self.nbu.user
f = open(nbfile)
nbs = f.read()
f.close()
if nbfile[-3:] == 'xml':
self.nb = self.nbu.loadNotebookFromXML(nbs)
else:
self.nb = self.nbu.loadNotebookFromSparse(nbs)
def setUp(self):
#start one controller and connect one engine
self.services = []
self.clients = []
self.servers = []
self.sroot = enginepb.PBRemoteEngineRootFromService(self)
self.sf = pb.PBServerFactory(self.sroot)
self.servers.append(reactor.listenTCP(10201, self.sf))
self.engines = es.EngineService(InteractiveShell)
ef = enginepb.PBEngineClientFactory(self.engines)
client = reactor.connectTCP('127.0.0.1', 10201, ef)
self.clients.append(client)
self.services.append(self.engines)
self.engines.startService()
return ef.deferred
def setUp(self):
self.services = []
self.clients = []
self.servers = []
# Start a server and append to self.servers
self.sroot = PBRemoteEngineRootFromService(self)
self.sf = pb.PBServerFactory(self.sroot)
self.servers.append(reactor.listenTCP(10201, self.sf))
# Start an EngineService and append to services/client
self.engineService = es.EngineService()
ef = PBEngineClientFactory(self.engineService)
client = reactor.connectTCP('127.0.0.1', 10201, ef)
self.clients.append(client)
self.services.append(self.engineService)
self.engineService.startService()
# Create and returna Deferred that will fire when self.registerEngine
# is called. By returning this deferred, the actual tests will not
# be run until the client has connected and is registered.
self.setUpDeferred = defer.Deferred()
return self.setUpDeferred
def setUp(self):
#start one controller and connect one engine
self.services = []
self.clients = []
self.servers = []
self.sf = evsf(self)
self.servers.append(reactor.listenTCP(10201, self.sf))
self.engines = es.EngineService(InteractiveShell)
ef = ev.VanillaEngineClientFactoryFromEngineService(self.engines)
starterDeferred = defer.Deferred()
def myNotifySetID():
starterDeferred.callback(None)
ef.notifySetID = myNotifySetID
client = reactor.connectTCP('127.0.0.1', 10201, ef)
self.clients.append(client)
self.services.append(self.engines)
self.engines.startService()
return starterDeferred
def setUp(self):
self.rawEngine = es.EngineService()
self.rawEngine.startService()
self.engine = es.IEngineQueued(self.rawEngine)
def setUp(self):
self.engine = es.EngineService()
self.engine.startService()
def setUp(self):
self.engine = es.EngineService(InteractiveShell)
self.engine.startService()
def addEngine(self, n=1):
for i in range(n):
e = es.completeEngine(es.EngineService(InteractiveShell))
e.startService()
self.rc.registerEngine(e, None)
self.engines.append(e)
