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 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
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