def connectSlave(self, waitForBuilderList=True):
"""
Connect a slave the master via PB
@param waitForBuilderList: don't return until the setBuilderList has
been called
@returns: L{FakeSlaveBuildSlave} and a Deferred that will fire when it
is detached; via deferred
"""
factory = pb.PBClientFactory()
creds = credentials.UsernamePassword("testslave", "pw")
setBuilderList_d = defer.Deferred()
slavebuildslave = FakeSlaveBuildSlave(
lambda : setBuilderList_d.callback(None))
login_d = factory.login(creds, slavebuildslave)
def logged_in(persp):
slavebuildslave.setMasterPerspective(persp)
self.detach_d = defer.Deferred()
self.buildslave.subscribeToDetach(lambda :
self.detach_d.callback(None))
return slavebuildslave
login_d.addCallback(logged_in)
self.connector = reactor.connectTCP("127.0.0.1", self.port, factory)
if not waitForBuilderList:
return login_d
else:
d = defer.DeferredList([login_d, setBuilderList_d],
consumeErrors=True, fireOnOneErrback=True)
d.addCallback(lambda _ : slavebuildslave)
return d
def connectWorker(self, waitForBuilderList=True):
"""
Connect a worker the master via PB
@param waitForBuilderList: don't return until the setBuilderList has
been called
@returns: L{FakeWorkerWorker} and a Deferred that will fire when it
is detached; via deferred
"""
factory = pb.PBClientFactory()
creds = credentials.UsernamePassword(b"testworker", b"pw")
setBuilderList_d = defer.Deferred()
workerworker = FakeWorkerWorker(
lambda: setBuilderList_d.callback(None))
login_d = factory.login(creds, workerworker)
@login_d.addCallback
def logged_in(persp):
workerworker.setMasterPerspective(persp)
# set up to hear when the worker side disconnects
workerworker.detach_d = defer.Deferred()
persp.broker.notifyOnDisconnect(
lambda: workerworker.detach_d.callback(None))
self._detach_deferreds.append(workerworker.detach_d)
return workerworker
self.endpoint = clientFromString(
reactor, self.client_connection_string_tpl.format(port=self.port))
connected_d = self.endpoint.connect(factory)
dlist = [connected_d, login_d]
if waitForBuilderList:
dlist.append(setBuilderList_d)
d = defer.DeferredList(dlist,
consumeErrors=True,
fireOnOneErrback=True)
d.addCallback(lambda _: workerworker)
return d
def connectWorker(self, waitForBuilderList=True):
"""
Connect a worker the master via PB
@param waitForBuilderList: don't return until the setBuilderList has
been called
@returns: L{FakeWorkerWorker} and a Deferred that will fire when it
is detached; via deferred
"""
factory = pb.PBClientFactory()
creds = credentials.UsernamePassword(b"testworker", b"pw")
setBuilderList_d = defer.Deferred()
workerworker = FakeWorkerWorker(
lambda: setBuilderList_d.callback(None))
login_d = factory.login(creds, workerworker)
@login_d.addCallback
def logged_in(persp):
workerworker.setMasterPerspective(persp)
# set up to hear when the worker side disconnects
workerworker.detach_d = defer.Deferred()
persp.broker.notifyOnDisconnect(
lambda: workerworker.detach_d.callback(None))
self._detach_deferreds.append(workerworker.detach_d)
return workerworker
self.endpoint = clientFromString(
reactor, self.client_connection_string_tpl.format(port=self.port))
connected_d = self.endpoint.connect(factory)
dlist = [connected_d, login_d]
if waitForBuilderList:
dlist.append(setBuilderList_d)
d = defer.DeferredList(dlist,
consumeErrors=True, fireOnOneErrback=True)
d.addCallback(lambda _: workerworker)
return d
def connectWorker(self, waitForBuilderList=True):
"""
Connect a worker the master via PB
@param waitForBuilderList: don't return until the setBuilderList has
been called
@returns: L{FakeWorkerWorker} and a Deferred that will fire when it
is detached; via deferred
"""
factory = pb.PBClientFactory()
creds = credentials.UsernamePassword("testworker", "pw")
setBuilderList_d = defer.Deferred()
workerworker = FakeWorkerWorker(
lambda: setBuilderList_d.callback(None))
login_d = factory.login(creds, workerworker)
@login_d.addCallback
def logged_in(persp):
workerworker.setMasterPerspective(persp)
# set up to hear when the worker side disconnects
workerworker.detach_d = defer.Deferred()
persp.broker.notifyOnDisconnect(
lambda: workerworker.detach_d.callback(None))
self._detach_deferreds.append(workerworker.detach_d)
return workerworker
self.connectors.append(
reactor.connectTCP("127.0.0.1", self.port, factory))
if not waitForBuilderList:
return login_d
else:
d = defer.DeferredList([login_d, setBuilderList_d],
consumeErrors=True,
fireOnOneErrback=True)
d.addCallback(lambda _: workerworker)
return d
def connectWorker(self, waitForBuilderList=True):
"""
Connect a worker the master via PB
@param waitForBuilderList: don't return until the setBuilderList has
been called
@returns: L{FakeWorkerWorker} and a Deferred that will fire when it
is detached; via deferred
"""
factory = pb.PBClientFactory()
creds = credentials.UsernamePassword("testworker", "pw")
setBuilderList_d = defer.Deferred()
workerworker = FakeWorkerWorker(
lambda: setBuilderList_d.callback(None))
login_d = factory.login(creds, workerworker)
@login_d.addCallback
def logged_in(persp):
workerworker.setMasterPerspective(persp)
# set up to hear when the worker side disconnects
workerworker.detach_d = defer.Deferred()
persp.broker.notifyOnDisconnect(lambda:
workerworker.detach_d.callback(None))
self._detach_deferreds.append(workerworker.detach_d)
return workerworker
self.connectors.append(
reactor.connectTCP("127.0.0.1", self.port, factory))
if not waitForBuilderList:
return login_d
else:
d = defer.DeferredList([login_d, setBuilderList_d],
consumeErrors=True, fireOnOneErrback=True)
d.addCallback(lambda _: workerworker)
return d
