def testCloseWriteCloser(self):
client = self.client
f = self.f
t = client.transport
t.write("hello")
spinUntil(lambda :len(t._tempDataBuffer) == 0)
t.loseWriteConnection()
spinUntil(lambda :t._writeDisconnected)
self.assertEquals(client.closed, False)
self.assertEquals(client.writeHalfClosed, True)
self.assertEquals(client.readHalfClosed, False)
spinUntil(lambda :f.protocol.readHalfClosed, timeout=1.0)
w = client.transport.write
w(" world")
w("lalala fooled you")
spinWhile(lambda :len(client.transport._tempDataBuffer) > 0)
self.assertEquals(f.protocol.data, "hello")
self.assertEquals(f.protocol.closed, False)
self.assertEquals(f.protocol.readHalfClosed, True)
def testUNIX(self):
if not interfaces.IReactorUNIX(reactor, None):
raise unittest.SkipTest, "This reactor does not support UNIX domain sockets"
s = service.MultiService()
c = compat.IOldApplication(s)
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
if os.path.exists('.hello.skt'):
os.remove('hello.skt')
c.listenUNIX('./hello.skt', factory)
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write('lalala\r\n')
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
c.connectUNIX('./hello.skt', factory)
s.privilegedStartService()
s.startService()
util.spinWhile(lambda: factory.line is None)
util.wait(defer.maybeDeferred(s.stopService))
self.assertEqual(factory.line, 'lalala')
# Cleanup the reactor
util.wait(TestEcho.d)
def waitOnShutDown(self):
if not self.done:
try:
self.transport.signalProcess('KILL')
util.spinWhile(lambda: not self.done)
except error.ProcessExitedAlready:
pass
def testCloseWriteCloser(self):
client = self.client
f = self.f
t = client.transport
t.write("hello")
spinUntil(lambda: len(t._tempDataBuffer) == 0)
t.loseWriteConnection()
spinUntil(lambda: t._writeDisconnected)
self.assertEquals(client.closed, False)
self.assertEquals(client.writeHalfClosed, True)
self.assertEquals(client.readHalfClosed, False)
spinUntil(lambda: f.protocol.readHalfClosed, timeout=1.0)
w = client.transport.write
w(" world")
w("lalala fooled you")
spinWhile(lambda: len(client.transport._tempDataBuffer) > 0)
self.assertEquals(f.protocol.data, "hello")
self.assertEquals(f.protocol.closed, False)
self.assertEquals(f.protocol.readHalfClosed, True)
def testUNIX(self):
if not interfaces.IReactorUNIX(reactor, None):
raise unittest.SkipTest, "This reactor does not support UNIX domain sockets"
s = service.MultiService()
s.startService()
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
t = internet.UNIXServer("echo.skt", factory)
t.setServiceParent(s)
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write("lalala\r\n")
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
internet.UNIXClient("echo.skt", factory).setServiceParent(s)
util.spinWhile(lambda: factory.line is None)
self.assertEqual(factory.line, "lalala")
util.wait(defer.maybeDeferred(s.stopService))
util.wait(TestEcho.d)
TestEcho.d = defer.Deferred()
factory.line = None
s.startService()
util.spinWhile(lambda: factory.line is None)
self.assertEqual(factory.line, "lalala")
util.wait(defer.maybeDeferred(s.stopService))
util.wait(TestEcho.d)
def testProperlyCloseFiles(self):
self.connector()
f = lambda: (self.totalConnections < self.numberRounds)
spinWhile(f, timeout=self.timeLimit)
self.failUnlessEqual(self.totalConnections, self.numberRounds)
def testUNIX(self):
if not interfaces.IReactorUNIX(reactor, None):
raise unittest.SkipTest, "This reactor does not support UNIX domain sockets"
s = service.MultiService()
c = compat.IOldApplication(s)
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
if os.path.exists(".hello.skt"):
os.remove("hello.skt")
c.listenUNIX("./hello.skt", factory)
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write("lalala\r\n")
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
c.connectUNIX("./hello.skt", factory)
s.privilegedStartService()
s.startService()
util.spinWhile(lambda: factory.line is None)
util.wait(defer.maybeDeferred(s.stopService))
self.assertEqual(factory.line, "lalala")
util.wait(TestEcho.d)
def testTCP(self):
s = service.MultiService()
c = compat.IOldApplication(s)
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
c.listenTCP(0, factory)
s.privilegedStartService()
s.startService()
num = list(s)[0]._port.getHost().port
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write('lalala\r\n')
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
c.connectTCP('127.0.0.1', num, factory)
util.spinWhile(lambda: factory.line is None)
util.wait(defer.maybeDeferred(s.stopService))
self.assertEqual(factory.line, 'lalala')
# Cleanup the reactor
util.wait(TestEcho.d)
def testBrokenTimer(self):
t = internet.TimerService(1, lambda: 1 / 0)
t.startService()
util.spinWhile(lambda :t._loop.running, timeout=30)
t.stopService()
self.assertEquals([ZeroDivisionError],
[o.value.__class__ for o in log.flushErrors(ZeroDivisionError)])
def testTCP(self):
s = service.MultiService()
s.startService()
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
t = internet.TCPServer(0, factory)
t.setServiceParent(s)
num = t._port.getHost().port
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write('lalala\r\n')
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
internet.TCPClient('127.0.0.1', num, factory).setServiceParent(s)
util.spinWhile(lambda :factory.line is None)
self.assertEqual(factory.line, 'lalala')
# Cleanup the reactor
util.wait(defer.maybeDeferred(s.stopService))
util.wait(TestEcho.d)
def testTCP(self):
s = service.MultiService()
c = compat.IOldApplication(s)
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
c.listenTCP(0, factory)
s.privilegedStartService()
s.startService()
num = list(s)[0]._port.getHost().port
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write("lalala\r\n")
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
c.connectTCP("127.0.0.1", num, factory)
util.spinWhile(lambda: factory.line is None)
util.wait(defer.maybeDeferred(s.stopService))
self.assertEqual(factory.line, "lalala")
util.wait(TestEcho.d)
def testPrivileged(self):
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
t = internet.TCPServer(0, factory)
t.privileged = 1
t.privilegedStartService()
num = t._port.getHost().port
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write('lalala\r\n')
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
c = internet.TCPClient('127.0.0.1', num, factory)
c.startService()
util.spinWhile(lambda: factory.line is None)
self.assertEqual(factory.line, 'lalala')
# Cleanup the reactor
util.wait(defer.maybeDeferred(c.stopService))
util.wait(defer.maybeDeferred(t.stopService))
util.wait(TestEcho.d)
def testPrivileged(self):
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
t = internet.TCPServer(0, factory)
t.privileged = 1
t.privilegedStartService()
num = t._port.getHost().port
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write("lalala\r\n")
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
c = internet.TCPClient("127.0.0.1", num, factory)
c.startService()
util.spinWhile(lambda: factory.line is None)
self.assertEqual(factory.line, "lalala")
util.wait(defer.maybeDeferred(c.stopService))
util.wait(defer.maybeDeferred(t.stopService))
util.wait(TestEcho.d)
def testProperlyCloseFiles(self):
self.connector()
f = lambda :(self.totalConnections < self.numberRounds)
spinWhile(f, timeout=self.timeLimit)
self.failUnlessEqual(self.totalConnections, self.numberRounds)
def testClientBind(self):
f = MyServerFactory()
p = reactor.listenTCP(0, f, interface="127.0.0.1")
self.ports.append(p)
factory = MyClientFactory()
reactor.connectTCP("127.0.0.1", p.getHost().port, factory,
bindAddress=("127.0.0.1", 0))
spinUntil(lambda :factory.protocol is not None)
self.assertEquals(factory.protocol.made, 1)
port = factory.protocol.transport.getHost().port
f2 = MyClientFactory()
reactor.connectTCP("127.0.0.1", p.getHost().port, f2,
bindAddress=("127.0.0.1", port))
spinUntil(lambda :f2.failed)
self.assertEquals(f2.failed, 1)
f2.reason.trap(error.ConnectBindError)
self.assert_(f2.reason.check(error.ConnectBindError))
self.assertEquals(f2.stopped, 1)
p.stopListening()
factory.protocol.transport.loseConnection()
spinWhile(lambda :p.connected)
self.assertEquals(factory.stopped, 1)
self.cleanPorts(*self.ports)
def getFreePort(self):
"""Get an empty port."""
p = reactor.listenTCP(0, protocol.ServerFactory())
spinUntil(lambda: p.connected)
port = p.getHost().port
p.stopListening()
spinWhile(lambda: p.connected)
return port
def getFreePort(self):
"""Get an empty port."""
p = reactor.listenTCP(0, protocol.ServerFactory())
spinUntil(lambda :p.connected)
port = p.getHost().port
p.stopListening()
spinWhile(lambda :p.connected)
return port
def testBrokenTimer(self):
t = internet.TimerService(1, lambda: 1 / 0)
t.startService()
util.spinWhile(lambda: t._loop.running, timeout=30)
t.stopService()
self.assertEquals(
[ZeroDivisionError],
[o.value.__class__ for o in log.flushErrors(ZeroDivisionError)])
def testSignal(self):
exe = sys.executable
scriptPath = util.sibpath(__file__, "process_signal.py")
signals = ("HUP", "INT", "KILL")
for sig in signals:
p = SignalProtocol(sig, self)
reactor.spawnProcess(p, exe, [exe, "-u", scriptPath, sig], env=None, usePTY=self.usePTY)
spinWhile(lambda: p.going)
self.failIf(p.failure, p.failure)
def tearDown(self):
self.assertEquals(self.client.closed, 0)
self.client.transport.loseConnection()
self.p.stopListening()
spinWhile(lambda :self.p.connected)
self.assertEquals(self.client.closed, 1)
self.assertEquals(self.f.protocol.closed, 0)
self.f.protocol.transport.loseConnection()
spinWhile(lambda :self.f.protocol.transport.connected)
self.assertEquals(self.f.protocol.closed, 1)
def testSignal(self):
exe = sys.executable
scriptPath = util.sibpath(__file__, "process_signal.py")
signals = ('HUP', 'INT', 'KILL')
for sig in signals:
p = SignalProtocol(sig, self)
reactor.spawnProcess(p,
exe, [exe, "-u", scriptPath, sig],
env=None,
usePTY=self.usePTY)
spinWhile(lambda: p.going)
self.failIf(p.failure, p.failure)
def testClosePortInProtocolFactory(self):
f = ClosingFactory()
port = reactor.listenTCP(0, f, interface="127.0.0.1")
self.n = port.getHost().port
self.ports.append(port)
f.port = port
clientF = MyClientFactory()
reactor.connectTCP("127.0.0.1", self.n, clientF)
spinWhile(lambda :(not clientF.protocol or
not clientF.protocol.closed))
self.assert_(clientF.protocol.made)
self.assert_(port.disconnected)
clientF.lostReason.trap(error.ConnectionDone)
def testConnectionGettingRefused(self):
factory = protocol.ServerFactory()
factory.protocol = wire.Echo
t = internet.TCPServer(0, factory)
t.startService()
num = t._port.getHost().port
t.stopService()
l = []
factory = protocol.ClientFactory()
factory.clientConnectionFailed = lambda *args: l.append(None)
c = internet.TCPClient("127.0.0.1", num, factory)
c.startService()
util.spinWhile(lambda: not l)
self.assertEqual(l, [None])
def tearDown(self):
self.assertEquals(self.client.closed, 0)
self.client.transport.loseConnection()
self.p.stopListening()
spinWhile(lambda :self.p.connected)
self.assertEquals(self.client.closed, 1)
# because we did half-close, the server also needs to
# closed explicitly.
self.assertEquals(self.f.protocol.closed, 0)
self.f.protocol.transport.loseConnection()
spinWhile(lambda :self.f.protocol.transport.connected)
self.assertEquals(self.f.protocol.closed, 1)
def testConnectionGettingRefused(self):
factory = protocol.ServerFactory()
factory.protocol = wire.Echo
t = internet.TCPServer(0, factory)
t.startService()
num = t._port.getHost().port
t.stopService()
l = []
factory = protocol.ClientFactory()
factory.clientConnectionFailed = lambda *args: l.append(None)
c = internet.TCPClient('127.0.0.1', num, factory)
c.startService()
util.spinWhile(lambda: not l)
self.assertEqual(l, [None])
def tearDown(self):
self.assertEquals(self.client.closed, 0)
self.client.transport.loseConnection()
self.p.stopListening()
spinWhile(lambda: self.p.connected)
self.assertEquals(self.client.closed, 1)
# because we did half-close, the server also needs to
# closed explicitly.
self.assertEquals(self.f.protocol.closed, 0)
self.f.protocol.transport.loseConnection()
spinWhile(lambda: self.f.protocol.transport.connected)
self.assertEquals(self.f.protocol.closed, 1)
def testStoppingServer(self):
if not interfaces.IReactorUNIX(reactor, None):
raise unittest.SkipTest, "This reactor does not support UNIX domain sockets"
factory = protocol.ServerFactory()
factory.protocol = wire.Echo
t = internet.UNIXServer('echo.skt', factory)
t.startService()
t.stopService()
self.failIf(t.running)
factory = protocol.ClientFactory()
l = []
factory.clientConnectionFailed = lambda *args: l.append(None)
reactor.connectUNIX('echo.skt', factory)
util.spinWhile(lambda: not l)
self.assertEqual(l, [None])
def testClosePortInProtocolFactory(self):
f = ClosingFactory()
port = reactor.listenTCP(0, f, interface="127.0.0.1")
self.n = port.getHost().port
self.ports.append(port)
f.port = port
clientF = MyClientFactory()
reactor.connectTCP("127.0.0.1", self.n, clientF)
spinWhile(lambda:
(not clientF.protocol or not clientF.protocol.closed))
self.assert_(clientF.protocol.made)
self.assert_(port.disconnected)
clientF.lostReason.trap(error.ConnectionDone)
def testUDP(self):
if not interfaces.IReactorUDP(reactor, None):
raise unittest.SkipTest, "This reactor does not support UDP sockets"
p = protocol.DatagramProtocol()
t = internet.TCPServer(0, p)
t.startService()
num = t._port.getHost().port
l = []
defer.maybeDeferred(t.stopService).addCallback(l.append)
util.spinWhile(lambda: not l)
t = internet.TCPServer(num, p)
t.startService()
l = []
defer.maybeDeferred(t.stopService).addCallback(l.append)
util.spinWhile(lambda: not l)
def testStoppingServer(self):
if not interfaces.IReactorUNIX(reactor, None):
raise unittest.SkipTest, "This reactor does not support UNIX domain sockets"
factory = protocol.ServerFactory()
factory.protocol = wire.Echo
t = internet.UNIXServer("echo.skt", factory)
t.startService()
t.stopService()
self.failIf(t.running)
factory = protocol.ClientFactory()
l = []
factory.clientConnectionFailed = lambda *args: l.append(None)
reactor.connectUNIX("echo.skt", factory)
util.spinWhile(lambda: not l)
self.assertEqual(l, [None])
def testUDP(self):
if not interfaces.IReactorUDP(reactor, None):
raise unittest.SkipTest, "This reactor does not support UDP sockets"
p = protocol.DatagramProtocol()
t = internet.TCPServer(0, p)
t.startService()
num = t._port.getHost().port
l = []
defer.maybeDeferred(t.stopService).addCallback(l.append)
util.spinWhile(lambda: not l)
t = internet.TCPServer(num, p)
t.startService()
l = []
defer.maybeDeferred(t.stopService).addCallback(l.append)
util.spinWhile(lambda: not l)
def loopbackUNIX(server, client, noisy=True):
"""Run session between server and client protocol instances over UNIX socket."""
path = tempfile.mktemp()
from twisted.internet import reactor
f = protocol.Factory()
f.noisy = noisy
f.buildProtocol = lambda addr, p=server: p
serverPort = reactor.listenUNIX(path, f)
reactor.iterate()
clientF = LoopbackClientFactory(client)
clientF.noisy = noisy
reactor.connectUNIX(path, clientF)
spinUntil(lambda :clientF.disconnected) # A
spinWhile(lambda :server.transport.connected) # B
serverPort.stopListening()
spinWhile(lambda :serverPort.connected) # C
def loopbackUNIX(server, client, noisy=True):
"""Run session between server and client protocol instances over UNIX socket."""
path = tempfile.mktemp()
from twisted.internet import reactor
f = protocol.Factory()
f.noisy = noisy
f.buildProtocol = lambda addr, p=server: p
serverPort = reactor.listenUNIX(path, f)
reactor.iterate()
clientF = LoopbackClientFactory(client)
clientF.noisy = noisy
reactor.connectUNIX(path, clientF)
spinUntil(lambda: clientF.disconnected) # A
spinWhile(lambda: server.transport.connected) # B
serverPort.stopListening()
spinWhile(lambda: serverPort.connected) # C
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
spinUntil(lambda:sp.started and cp.started)
cp.transport.write("hi")
spinUntil(lambda:sp.gotwhat == "hi" and cp.gotback == "hi back")
s.stopListening()
c.stopListening()
os.unlink(clientaddr)
os.unlink(serveraddr)
spinWhile(lambda:s.connected and c.connected)
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
def loopbackTCP(server, client, port=0, noisy=True):
"""Run session between server and client protocol instances over TCP."""
from twisted.internet import reactor
f = protocol.Factory()
f.noisy = noisy
f.buildProtocol = lambda addr, p=server: p
serverPort = reactor.listenTCP(port, f, interface='127.0.0.1')
reactor.iterate()
clientF = LoopbackClientFactory(client)
clientF.noisy = noisy
reactor.connectTCP('127.0.0.1', serverPort.getHost().port, clientF)
# this needs to wait until:
# A: the client has disconnected
# B: the server has noticed, and its own socket has disconnected
# C: the listening socket has been shut down
spinUntil(lambda: clientF.disconnected) # A
spinWhile(lambda: server.transport.connected) # B
serverPort.stopListening()
spinWhile(lambda: serverPort.connected) # C
def loopbackTCP(server, client, port=0, noisy=True):
"""Run session between server and client protocol instances over TCP."""
from twisted.internet import reactor
f = protocol.Factory()
f.noisy = noisy
f.buildProtocol = lambda addr, p=server: p
serverPort = reactor.listenTCP(port, f, interface='127.0.0.1')
reactor.iterate()
clientF = LoopbackClientFactory(client)
clientF.noisy = noisy
reactor.connectTCP('127.0.0.1', serverPort.getHost().port, clientF)
# this needs to wait until:
# A: the client has disconnected
# B: the server has noticed, and its own socket has disconnected
# C: the listening socket has been shut down
spinUntil(lambda :clientF.disconnected) # A
spinWhile(lambda :server.transport.connected) # B
serverPort.stopListening()
spinWhile(lambda :serverPort.connected) # C
def testServerStartStop(self):
f = StartStopFactory()
# listen on port
p1 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n1 = p1.getHost().port
self.ports.append(p1)
spinUntil(lambda: (p1.connected == 1))
self.assertEquals((f.started, f.stopped), (1, 0))
# listen on two more ports
p2 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n2 = p2.getHost().port
self.ports.append(p2)
p3 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n3 = p3.getHost().port
self.ports.append(p3)
spinUntil(lambda: (p2.connected == 1 and p3.connected == 1))
self.assertEquals((f.started, f.stopped), (1, 0))
# close two ports
p1.stopListening()
p2.stopListening()
spinWhile(lambda: (p1.connected == 1 or p2.connected == 1))
self.assertEquals((f.started, f.stopped), (1, 0))
# close last port
p3.stopListening()
spinWhile(lambda: (p3.connected == 1))
self.assertEquals((f.started, f.stopped), (1, 1))
return self.cleanPorts(*self.ports)
def testUNIX(self):
# FIXME: This test is far too dense. It needs comments.
# -- spiv, 2004-11-07
if not interfaces.IReactorUNIX(reactor, None):
raise unittest.SkipTest, "This reactor does not support UNIX domain sockets"
s = service.MultiService()
s.startService()
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
t = internet.UNIXServer('echo.skt', factory)
t.setServiceParent(s)
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write('lalala\r\n')
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
internet.UNIXClient('echo.skt', factory).setServiceParent(s)
util.spinWhile(lambda: factory.line is None)
self.assertEqual(factory.line, 'lalala')
util.wait(defer.maybeDeferred(s.stopService))
util.wait(TestEcho.d)
TestEcho.d = defer.Deferred()
factory.line = None
s.startService()
util.spinWhile(lambda: factory.line is None)
self.assertEqual(factory.line, 'lalala')
# Cleanup the reactor
util.wait(defer.maybeDeferred(s.stopService))
util.wait(TestEcho.d)
def testServerStartStop(self):
f = StartStopFactory()
# listen on port
p1 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n1 = p1.getHost().port
self.ports.append(p1)
spinUntil(lambda :(p1.connected == 1))
self.assertEquals((f.started, f.stopped), (1,0))
# listen on two more ports
p2 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n2 = p2.getHost().port
self.ports.append(p2)
p3 = reactor.listenTCP(0, f, interface='127.0.0.1')
self.n3 = p3.getHost().port
self.ports.append(p3)
spinUntil(lambda :(p2.connected == 1 and p3.connected == 1))
self.assertEquals((f.started, f.stopped), (1, 0))
# close two ports
p1.stopListening()
p2.stopListening()
spinWhile(lambda :(p1.connected == 1 or p2.connected == 1))
self.assertEquals((f.started, f.stopped), (1, 0))
# close last port
p3.stopListening()
spinWhile(lambda :(p3.connected == 1))
self.assertEquals((f.started, f.stopped), (1, 1))
return self.cleanPorts(*self.ports)
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
spinUntil(lambda:sp.started and cp.started)
cp.transport.write("hi")
spinUntil(lambda:sp.gotwhat == "hi" and cp.gotback == "hi back")
s.stopListening()
c.stopListening()
os.unlink(clientaddr)
os.unlink(serveraddr)
spinWhile(lambda:s.connected and c.connected)
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
def testUNIX(self):
# FIXME: This test is far too dense. It needs comments.
# -- spiv, 2004-11-07
if not interfaces.IReactorUNIX(reactor, None):
raise unittest.SkipTest, "This reactor does not support UNIX domain sockets"
s = service.MultiService()
s.startService()
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
t = internet.UNIXServer('echo.skt', factory)
t.setServiceParent(s)
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write('lalala\r\n')
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
internet.UNIXClient('echo.skt', factory).setServiceParent(s)
util.spinWhile(lambda :factory.line is None)
self.assertEqual(factory.line, 'lalala')
util.wait(defer.maybeDeferred(s.stopService))
util.wait(TestEcho.d)
TestEcho.d = defer.Deferred()
factory.line = None
s.startService()
util.spinWhile(lambda :factory.line is None)
self.assertEqual(factory.line, 'lalala')
# Cleanup the reactor
util.wait(defer.maybeDeferred(s.stopService))
util.wait(TestEcho.d)
def testTimer(self):
l = []
t = internet.TimerService(1, l.append, "hello")
t.startService()
util.spinWhile(lambda: not l, timeout=30)
t.stopService()
self.failIf(t.running)
self.assertEqual(l, ["hello"])
l.pop()
t.startService()
util.spinWhile(lambda: not l, timeout=30)
t.stopService()
self.failIf(t.running)
self.assertEqual(l, ["hello"])
l.pop()
t = internet.TimerService(0.01, l.append, "hello")
t.startService()
util.spinWhile(lambda: len(l) < 10, timeout=30)
t.stopService()
self.assertEqual(l, ["hello"] * 10)
def testTimer(self):
l = []
t = internet.TimerService(1, l.append, "hello")
t.startService()
util.spinWhile(lambda: not l, timeout=30)
t.stopService()
self.failIf(t.running)
self.assertEqual(l, ["hello"])
l.pop()
# restart the same TimerService
t.startService()
util.spinWhile(lambda: not l, timeout=30)
t.stopService()
self.failIf(t.running)
self.assertEqual(l, ["hello"])
l.pop()
t = internet.TimerService(0.01, l.append, "hello")
t.startService()
util.spinWhile(lambda: len(l) < 10, timeout=30)
t.stopService()
self.assertEqual(l, ["hello"] * 10)
def cleanPorts(self, *ports):
for p in ports:
if p.connected:
p.loseConnection()
util.spinWhile(lambda :p.connected)
def wait(self, sec_delay):
wake_up = time.time() + sec_delay
def _waiting():
return time.time() < wake_up
util.spinWhile(_waiting, sec_delay+1)
def wait(self, sec_delay):
self.wake_up = time.time()+sec_delay
util.spinWhile(self._waiting, sec_delay+1)
