def testDNSFailure(self):
client = Client()
# if this domain exists, shoot your sysadmin
reactor.connectUDP("xxxxxxxxx.zzzzzzzzz.yyyyy.", 8888, client)
while not hasattr(client, 'failure'):
reactor.iterate(0.05)
self.assert_(client.failure.trap(error.DNSLookupError))
self.assertEquals(client.stopped, 0)
self.assertEquals(client.started, 0)
def send_to(self, message, host, port, tcp=True):
"""
Send a message to other servers.
"""
factory = ClientFactory(self, message)
if tcp:
reactor.connectTCP(host, port, factory)
else:
reactor.connectUDP(host, port, factory)
def testDNSFailure(self):
client = Client()
d = client.startedDeferred = defer.Deferred()
# if this domain exists, shoot your sysadmin
reactor.connectUDP("xxxxxxxxx.zzzzzzzzz.yyyyy.", 8888, client)
def didNotConnect(ign):
self.assertEquals(client.stopped, 0)
self.assertEquals(client.started, 0)
d = self.assertFailure(d, error.DNSLookupError)
d.addCallback(didNotConnect)
return d
def testDNSFailure(self):
client = Client()
d = client.startedDeferred = defer.Deferred()
# if this domain exists, shoot your sysadmin
reactor.connectUDP("xxxxxxxxx.zzzzzzzzz.yyyyy.", 8888, client)
def didNotConnect(ign):
self.assertEquals(client.stopped, 0)
self.assertEquals(client.started, 0)
d = self.assertFailure(d, error.DNSLookupError)
d.addCallback(didNotConnect)
return d
def testConnectionRefused(self):
# assume no one listening on port 80 UDP
client = Client()
port = reactor.connectUDP("127.0.0.1", 80, client)
server = Server()
port2 = reactor.listenUDP(0, server, interface="127.0.0.1")
reactor.iterate()
reactor.iterate()
reactor.iterate()
client.transport.write("a")
client.transport.write("b")
server.transport.write("c", ("127.0.0.1", 80))
server.transport.write("d", ("127.0.0.1", 80))
server.transport.write("e", ("127.0.0.1", 80))
server.transport.write("toserver",
(port2.getHost().host, port2.getHost().port))
server.transport.write("toclient",
(port.getHost().host, port.getHost().port))
reactor.iterate()
reactor.iterate()
self.assertEquals(client.refused, 1)
port.stopListening()
port2.stopListening()
reactor.iterate()
reactor.iterate()
def connectUDP(self, remotehost, remoteport, protocol, localport=0,
interface='', maxPacketSize=8192):
"""Connects a L{ConnectedDatagramProtocol} instance to a UDP port."""
self.udpConnectors.append((
remotehost, remoteport, protocol,
localport, interface, maxPacketSize
))
if self.running:
from twisted.internet import reactor
return reactor.connectUDP(
remotehost, remoteport, protocol,
localport, interface, maxPacketSize
)
def connectUDP(self,
remotehost,
remoteport,
protocol,
localport=0,
interface='',
maxPacketSize=8192):
"""Connects a L{ConnectedDatagramProtocol} instance to a UDP port."""
self.udpConnectors.append((remotehost, remoteport, protocol, localport,
interface, maxPacketSize))
if self.running:
from twisted.internet import reactor
return reactor.connectUDP(remotehost, remoteport, protocol,
localport, interface, maxPacketSize)
def testStartStop(self):
client = Client()
d = client.startedDeferred = defer.Deferred()
port2 = reactor.connectUDP("127.0.0.1", 8888, client)
def assertName():
self.failUnless(repr(port2).find('test_udp.Client') >= 0)
def cbStarted(ignored):
self.assertEquals(client.started, 1)
self.assertEquals(client.stopped, 0)
assertName()
return defer.maybeDeferred(port2.stopListening).addCallback(lambda ign: assertName())
return d.addCallback(cbStarted)
def testStartStop(self):
client = Client()
port2 = reactor.connectUDP("127.0.0.1", 8888, client)
reactor.iterate()
reactor.iterate()
self.assertEquals(client.started, 1)
self.assertEquals(client.stopped, 0)
l = []
self.assert_(repr(port2).find('test_udp.Client') > 0)
defer.maybeDeferred(port2.stopListening).addCallback(l.append)
reactor.iterate()
reactor.iterate()
self.assert_(repr(port2).find('test_udp.Client') > 0)
self.assertEquals(client.stopped, 1)
self.assertEquals(len(l), 1)
def testSendPackets(self):
server = Server()
port1 = reactor.listenUDP(0, server, interface="127.0.0.1")
client = Client()
port2 = reactor.connectUDP("127.0.0.1", server.transport.getHost()[2], client)
reactor.iterate()
reactor.iterate()
reactor.iterate()
server.transport.write("hello", client.transport.getHost()[1:])
client.transport.write("world")
reactor.iterate()
reactor.iterate()
self.assertEquals(client.packets, ["hello"])
self.assertEquals(server.packets, [("world", ("127.0.0.1", client.transport.getHost()[2]))])
port1.stopListening(); port2.stopListening()
reactor.iterate(); reactor.iterate()
def testStartStop(self):
client = Client()
d = client.startedDeferred = defer.Deferred()
port2 = reactor.connectUDP("127.0.0.1", 8888, client)
def assertName():
self.failUnless(repr(port2).find('test_udp.Client') >= 0)
def cbStarted(ignored):
self.assertEquals(client.started, 1)
self.assertEquals(client.stopped, 0)
assertName()
d = defer.maybeDeferred(port2.stopListening)
d.addCallback(lambda ign: assertName())
return d
return d.addCallback(cbStarted)
def test_connectionRefused(self):
"""
Test that using the connected UDP API will deliver connection refused
notification when packets are sent to an address at which no one is
listening.
"""
# XXX - assume no one listening on port 80 UDP
client = Client()
clientStarted = client.startedDeferred = Deferred()
server = Server()
serverStarted = server.startedDeferred = Deferred()
started = gatherResults([clientStarted, serverStarted])
clientPort = reactor.connectUDP("127.0.0.1", 80, client)
serverPort = reactor.listenUDP(0, server, interface="127.0.0.1")
def cbStarted(ignored):
clientRefused = client.startedDeferred = Deferred()
client.transport.write("a")
client.transport.write("b")
server.transport.write("c", ("127.0.0.1", 80))
server.transport.write("d", ("127.0.0.1", 80))
server.transport.write("e", ("127.0.0.1", 80))
c = clientPort.getHost()
s = serverPort.getHost()
server.transport.write("toserver", (s.host, s.port))
server.transport.write("toclient", (c.host, c.port))
return self.assertFailure(clientRefused,
error.ConnectionRefusedError)
started.addCallback(cbStarted)
def cleanup(passthrough):
result = gatherResults([
maybeDeferred(clientPort.stopListening),
maybeDeferred(serverPort.stopListening)
])
result.addCallback(lambda ign: passthrough)
return result
started.addBoth(cleanup)
return started
def test_connectionRefused(self):
"""
Test that using the connected UDP API will deliver connection refused
notification when packets are sent to an address at which no one is
listening.
"""
# XXX - assume no one listening on port 80 UDP
client = Client()
clientStarted = client.startedDeferred = Deferred()
server = Server()
serverStarted = server.startedDeferred = Deferred()
started = gatherResults([clientStarted, serverStarted])
clientPort = reactor.connectUDP("127.0.0.1", 80, client)
serverPort = reactor.listenUDP(0, server, interface="127.0.0.1")
def cbStarted(ignored):
clientRefused = client.startedDeferred = Deferred()
client.transport.write("a")
client.transport.write("b")
server.transport.write("c", ("127.0.0.1", 80))
server.transport.write("d", ("127.0.0.1", 80))
server.transport.write("e", ("127.0.0.1", 80))
c = clientPort.getHost()
s = serverPort.getHost()
server.transport.write("toserver", (s.host, s.port))
server.transport.write("toclient", (c.host, c.port))
return self.assertFailure(clientRefused, error.ConnectionRefusedError)
started.addCallback(cbStarted)
def cleanup(passthrough):
result = gatherResults([
maybeDeferred(clientPort.stopListening),
maybeDeferred(serverPort.stopListening)])
result.addCallback(lambda ign: passthrough)
return result
started.addBoth(cleanup)
return started
def testConnectionRefused(self):
# assume no one listening on port 80 UDP
client = Client()
port = reactor.connectUDP("127.0.0.1", 80, client)
server = Server()
port2 = reactor.listenUDP(0, server, interface="127.0.0.1")
reactor.iterate()
reactor.iterate()
reactor.iterate()
client.transport.write("a")
client.transport.write("b")
server.transport.write("c", ("127.0.0.1", 80))
server.transport.write("d", ("127.0.0.1", 80))
server.transport.write("e", ("127.0.0.1", 80))
server.transport.write("toserver", port2.getHost()[1:])
server.transport.write("toclient", port.getHost()[1:])
reactor.iterate(); reactor.iterate()
self.assertEquals(client.refused, 1)
port.stopListening()
port2.stopListening()
reactor.iterate(); reactor.iterate()
def testStartStop(self):
server = Server()
port1 = reactor.listenUDP(0, server, interface="127.0.0.1")
client = Client()
port2 = reactor.connectUDP("127.0.0.1", 8888, client)
reactor.iterate()
reactor.iterate()
reactor.iterate()
self.assertEquals(server.started, 1)
self.assertEquals(client.started, 1)
self.assertEquals(server.stopped, 0)
self.assertEquals(client.stopped, 0)
port1.stopListening()
port2.stopListening()
reactor.iterate()
reactor.iterate()
reactor.iterate()
self.assertEquals(server.stopped, 1)
self.assertEquals(client.stopped, 1)
return
for port, factory, ctxFactory, backlog, interface in self.sslPorts:
try:
reactor.listenSSL(port, factory, ctxFactory, backlog, interface)
except error.CannotListenError, msg:
log.msg('error on SSL port %s: %s' % (port, msg))
return
for portType, args, kw in self.extraPorts:
self._extraListeners[(portType, args, tuple(kw.items()))] = (
reactor.listenWith(portType, *args, **kw))
for host, port, factory, ctxFactory, timeout, bindAddress in self.sslConnectors:
reactor.connectSSL(host, port, factory, ctxFactory, timeout, bindAddress)
for host, port, factory, timeout, bindAddress in self.tcpConnectors:
reactor.connectTCP(host, port, factory, timeout, bindAddress)
for rhost, rport, protocol, lport, interface, size in self.udpConnectors:
reactor.connectUDP(rhost, rport, protocol, lport, interface, size)
for address, factory, timeout in self.unixConnectors:
reactor.connectUNIX(address, factory, timeout)
for connectorType, args, kw in self.extraConnectors:
reactor.connectWith(connectorType, *args, **kw)
for service in self.services.values():
service.startService()
self.running = 1
def run(self, save=1, installSignalHandlers=1):
"""run(save=1, installSignalHandlers=1)
Run this application, running the main loop if necessary.
If 'save' is true, then when this Application is shut down, it
will be persisted to a pickle.
'installSignalHandlers' is passed through to reactor.run(), the
function that starts the mainloop.
"""
def cbServerStarted(ignored):
self.port2 = reactor.connectUDP("127.0.0.1",
server.transport.getHost().port,
client)
return clientStarted
def cbServerStarted(ignored):
self.port2 = reactor.connectUDP("127.0.0.1",
server.transport.getHost().port,
client)
return clientStarted
except error.CannotListenError, msg:
log.msg('error on SSL port %s: %s' % (port, msg))
return
for portType, args, kw in self.extraPorts:
# The tuple(kw.items()) is because we can't use a dictionary
# or a list in a dictionary key.
self._extraListeners[(portType, args, tuple(
kw.items()))] = (reactor.listenWith(portType, *args, **kw))
for host, port, factory, ctxFactory, timeout, bindAddress in self.sslConnectors:
reactor.connectSSL(host, port, factory, ctxFactory, timeout,
bindAddress)
for host, port, factory, timeout, bindAddress in self.tcpConnectors:
reactor.connectTCP(host, port, factory, timeout, bindAddress)
for rhost, rport, protocol, lport, interface, size in self.udpConnectors:
reactor.connectUDP(rhost, rport, protocol, lport, interface,
size)
for address, factory, timeout in self.unixConnectors:
reactor.connectUNIX(address, factory, timeout)
for connectorType, args, kw in self.extraConnectors:
reactor.connectWith(connectorType, *args, **kw)
for service in self.services.values():
service.startService()
self.running = 1
def run(self, save=1, installSignalHandlers=1):
"""run(save=1, installSignalHandlers=1)
Run this application, running the main loop if necessary.
If 'save' is true, then when this Application is shut down, it
will be persisted to a pickle.
'installSignalHandlers' is passed through to reactor.run(), the
