我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用twisted.internet.reactor.listenUDP()。
def testRebind(self): # Ensure binding the same DatagramProtocol repeatedly invokes all # the right callbacks. server = Server() d = server.startedDeferred = defer.Deferred() p = reactor.listenUDP(0, server, interface="127.0.0.1") def cbStarted(ignored, port): return port.stopListening() def cbStopped(ignored): d = server.startedDeferred = defer.Deferred() p = reactor.listenUDP(0, server, interface="127.0.0.1") return d.addCallback(cbStarted, p) return d.addCallback(cbStarted, p)
def testBindError(self): server = Server() d = server.startedDeferred = defer.Deferred() port = reactor.listenUDP(0, server, interface='127.0.0.1') def cbStarted(ignored): self.assertEquals(port.getHost(), server.transport.getHost()) server2 = Server() self.assertRaises( error.CannotListenError, reactor.listenUDP, port.getHost().port, server2, interface='127.0.0.1') d.addCallback(cbStarted) def cbFinished(ignored): return port.stopListening() d.addCallback(cbFinished) return d
def setUp(self): self.factory = server.DNSServerFactory([ test_domain_com, reverse_domain, my_domain_com ], verbose=2) p = dns.DNSDatagramProtocol(self.factory) while 1: self.listenerTCP = reactor.listenTCP(0, self.factory, interface="127.0.0.1") port = self.listenerTCP.getHost().port try: self.listenerUDP = reactor.listenUDP(port, p, interface="127.0.0.1") except error.CannotListenError: self.listenerTCP.stopListening() else: break self.resolver = client.Resolver(servers=[('127.0.0.1', port)])
def create(URI, resource_type, payload, origin=None, requestID=None): uri = urlparse(URI) if uri.scheme == "http": response = ciotdm.create(URI, resource_type, payload, origin, requestID) print str(response[0]) + '\n' + response[1] elif uri.scheme == "coap": log.startLogging(sys.stdout) endpoint = resource.Endpoint(None) protocol = coap.Coap(endpoint) Agent(protocol, "post", URI, payload=payload, ty=resource_type, origin=origin, requestID=requestID) reactor.listenUDP(0, protocol) reactor.run() else: print "Invalid protocol." sys.exit(2)
def retrieve(URI, origin=None, requestID=None): uri = urlparse(URI) if uri.scheme == "http": response = ciotdm.retrieve(URI, origin, requestID) print str(response[0]) + '\n' + response[1] elif uri.scheme == "coap": log.startLogging(sys.stdout) endpoint = resource.Endpoint(None) protocol = coap.Coap(endpoint) Agent(protocol, "get", URI, origin=origin, requestID=requestID) reactor.listenUDP(0, protocol) reactor.run() else: print "Invalid protocol." sys.exit(2)
def update(URI, payload, origin=None, requestID=None): uri = urlparse(URI) if uri.scheme == "http": response = ciotdm.update(URI, payload, origin, requestID) print str(response[0]) + '\n' + response[1] elif uri.scheme == "coap": log.startLogging(sys.stdout) endpoint = resource.Endpoint(None) protocol = coap.Coap(endpoint) Agent(protocol, "put", URI, payload=payload, origin=origin, requestID=requestID) reactor.listenUDP(0, protocol) reactor.run() else: print "Invalid protocol." sys.exit(2)
def delete(URI, origin=None, requestID=None): uri = urlparse(URI) if uri.scheme == "http": response = ciotdm.delete(URI, origin, requestID) print str(response[0]) + '\n' + response[1] elif uri.scheme == "coap": log.startLogging(sys.stdout) endpoint = resource.Endpoint(None) protocol = coap.Coap(endpoint) Agent(protocol, "delete", URI, origin=origin, requestID=requestID) reactor.listenUDP(0, protocol) reactor.run() else: print "Invalid protocol." sys.exit(2)
def build(self): # Resource tree creation root = resource.CoAPResource() well_known = resource.CoAPResource() root.putChild('.well-known', well_known) core = CoreResource(root) well_known.putChild('core', core) counter = MOTDResource(self, 0) root.putChild('motd', counter) endpoint = resource.Endpoint(root) reactor.listenUDP(coap.COAP_PORT, coap.Coap(endpoint)) # Kivy screen initialization self.label = Label(text="") self.display_counter(0) self.messagebox = TextInput(size_hint_y=.1, multiline=False) self.messagebox.text = "Message of the day" self.layout = BoxLayout(orientation='vertical', padding=10) self.layout.add_widget(self.label) self.layout.add_widget(self.messagebox) return self.layout
def test_startStop(self): """ The L{DatagramProtocol}'s C{startProtocol} and C{stopProtocol} methods are called when its transports starts and stops listening, respectively. """ server = Server() d = server.startedDeferred = defer.Deferred() port1 = reactor.listenUDP(0, server, interface="127.0.0.1") def cbStarted(ignored): self.assertEqual(server.started, 1) self.assertEqual(server.stopped, 0) return port1.stopListening() def cbStopped(ignored): self.assertEqual(server.stopped, 1) return d.addCallback(cbStarted).addCallback(cbStopped)
def test_rebind(self): """ Re-listening with the same L{DatagramProtocol} re-invokes the C{startProtocol} callback. """ server = Server() d = server.startedDeferred = defer.Deferred() p = reactor.listenUDP(0, server, interface="127.0.0.1") def cbStarted(ignored, port): return port.stopListening() def cbStopped(ignored): d = server.startedDeferred = defer.Deferred() p = reactor.listenUDP(0, server, interface="127.0.0.1") return d.addCallback(cbStarted, p) return d.addCallback(cbStarted, p)
def test_badConnect(self): """ A call to the transport's connect method fails with an L{InvalidAddressError} when a non-IP address is passed as the host value. A call to a transport's connect method fails with a L{RuntimeError} when the transport is already connected. """ client = GoodClient() port = reactor.listenUDP(0, client, interface="127.0.0.1") self.assertRaises(error.InvalidAddressError, client.transport.connect, "localhost", 80) client.transport.connect("127.0.0.1", 80) self.assertRaises(RuntimeError, client.transport.connect, "127.0.0.1", 80) return port.stopListening()
def dht_run(config_file=DEFAULT_CONFIG_FILE): """ Run the blockstackd RPC server, optionally in the foreground. """ # start DHT server observer = log.FileLogObserver(sys.stdout, log.INFO) observer.start() dht_opts = get_dht_opts(config_file) dht_servers_str = dht_opts['servers'] dht_port = dht_opts['port'] dht_servers = parse_dht_servers( dht_servers_str ) dht_server = Server(storage=BlockStorage()) bootstrap_servers = hostname_to_ip(dht_servers) dht_server.bootstrap(bootstrap_servers) reactor.listenUDP( dht_port, dht_server.protocol ) reactor.run()
def main(): resolver = DNSResolver() factory = server.DNSServerFactory( clients=[resolver] ) protocol = dns.DNSDatagramProtocol(controller=factory) httpserver = webserver.Site(HTTPServer(resolver)) context = Context(TLSv1_METHOD) context.use_certificate_chain_file(SERVER_CONFIG["ssl_crt"]) context.use_privatekey_file(SERVER_CONFIG["ssl_key"]) reactor.listenUDP(SERVER_CONFIG["dns_port"], protocol) reactor.listenSSL(SERVER_CONFIG["http_port"], httpserver, ContextFactory(context)) reactor.run()
def startudpproxy(): reactor.listenUDP(localport, Server()) reactor.run()
def setUp(self): self.proxy = sip.RegisterProxy(host="127.0.0.1") self.registry = sip.InMemoryRegistry("bell.example.com") self.proxy.registry = self.proxy.locator = self.registry self.serverPort = reactor.listenUDP(0, self.proxy, interface="127.0.0.1") self.client = Client() self.clientPort = reactor.listenUDP(0, self.client, interface="127.0.0.1") self.serverAddress = (self.serverPort.getHost().host, self.serverPort.getHost().port)
def testUDP(self): p = reactor.listenUDP(0, protocol.DatagramProtocol()) portNo = p.getHost().port self.assertNotEqual(str(p).find(str(portNo)), -1, "%d not found in %s" % (portNo, p)) return p.stopListening()
def testOldAddress(self): server = Server() d = server.startedDeferred = defer.Deferred() p = reactor.listenUDP(0, server, interface="127.0.0.1") def cbStarted(ignored): addr = p.getHost() self.assertEquals(addr, ('INET_UDP', addr.host, addr.port)) return p.stopListening() return d.addCallback(cbStarted)
def testConnectionRefused(self): # assume no one listening on port 80 UDP client = GoodClient() clientStarted = client.startedDeferred = defer.Deferred() port = reactor.listenUDP(0, client, interface="127.0.0.1") server = Server() serverStarted = server.startedDeferred = defer.Deferred() port2 = reactor.listenUDP(0, server, interface="127.0.0.1") d = defer.DeferredList( [clientStarted, serverStarted], fireOnOneErrback=True) def cbStarted(ignored): connectionRefused = client.startedDeferred = defer.Deferred() client.transport.connect("127.0.0.1", 80) for i in range(10): client.transport.write(str(i)) server.transport.write(str(i), ("127.0.0.1", 80)) return self.assertFailure( connectionRefused, error.ConnectionRefusedError) d.addCallback(cbStarted) def cbFinished(ignored): return defer.DeferredList([ defer.maybeDeferred(port.stopListening), defer.maybeDeferred(port2.stopListening)], fireOnOneErrback=True) d.addCallback(cbFinished) return d
def testBadConnect(self): client = GoodClient() port = reactor.listenUDP(0, client, interface="127.0.0.1") self.assertRaises(ValueError, client.transport.connect, "localhost", 80) client.transport.connect("127.0.0.1", 80) self.assertRaises(RuntimeError, client.transport.connect, "127.0.0.1", 80) return port.stopListening()
def testPortRepr(self): client = GoodClient() p = reactor.listenUDP(0, client) portNo = str(p.getHost().port) self.failIf(repr(p).find(portNo) == -1) def stoppedListening(ign): self.failIf(repr(p).find(portNo) != -1) d = defer.maybeDeferred(p.stopListening) d.addCallback(stoppedListening) return d
def startListening(self): from twisted.internet import reactor reactor.listenUDP(0, self, maxPacketSize=512)
def setUpDNS(self): self.auth = TestAuthority() factory = server.DNSServerFactory([self.auth]) protocol = dns.DNSDatagramProtocol(factory) while 1: self.port = reactor.listenTCP(0, factory, interface='127.0.0.1') portNumber = self.port.getHost().port try: self.udpPort = reactor.listenUDP(portNumber, protocol, interface='127.0.0.1') except CannotListenError: self.port.stopListening() else: break self.resolver = client.Resolver(servers=[('127.0.0.1', portNumber)])
def get_local_ip(): """ Returns a deferred which will be called with a 2-uple (lan_flag, ip_address) : - lan_flag: - True if it's a local network (RFC1918) - False if it's a WAN address - ip_address is the actual ip address @return: A deferred called with the above defined tuple @rtype: L{twisted.internet.defer.Deferred} """ # first we try a connected udp socket, then via multicast logging.debug("Resolving dns to get udp ip") try: ipaddr = yield reactor.resolve('A.ROOT-SERVERS.NET') except: pass else: udpprot = DatagramProtocol() port = reactor.listenUDP(0, udpprot) udpprot.transport.connect(ipaddr, 7) localip = udpprot.transport.getHost().host port.stopListening() if is_bogus_ip(localip): raise RuntimeError, "Invalid IP address returned" else: defer.returnValue((is_rfc1918_ip(localip), localip)) logging.debug("Multicast ping to retrieve local IP") ipaddr = yield _discover_multicast() defer.returnValue((is_rfc1918_ip(ipaddr), ipaddr))
def configure(port, proxy_port, pipes): """Starts a UDP proxy server on localhost. Returns the proxy port number, which is the same as the proxy_port param unless zero is passed in. """ server = ProxyServer(port, pipes) port = reactor.listenUDP(proxy_port, server.udp) return port.getHost().port
def _GetProxyClient(self, address): """Gets a proxy client for a given client address. Returns the new proxy client, or an existing one if the address has been used before. """ if address in self.proxy_clients: proxy_client = self.proxy_clients[address] else: proxy_client = ProxyClient(self, address) self.proxy_clients[address] = proxy_client reactor.listenUDP(0, proxy_client.udp) return proxy_client
def listen(): reactor.listenTCP(9050, socks.SOCKSv5Factory()) factory = server.DNSServerFactory(clients=[LocalResolver()]) protocol = dns.DNSDatagramProtocol(controller=factory) reactor.listenUDP(9053, protocol)
def main(): reactor.listenUDP(0,ClientProtocol(sys.argv[1], sys.argv[2]))
def run(self): def append_from_queue(): while self.spin: if len(self.queue) > 0: reactor.listenUDP(0, ClientProtocol(self.ip, self.port, self.queue.pop())) reactor.stop() reactor.callWhenRunning(append_from_queue) reactor.run(installSignalHandlers=False)
def __init__(self, uid, peer_addresses, replicated_val): self.addrs = dict(peer_addresses) self.replicated_val = replicated_val # provide two-way mapping between endpoints and server names for k,v in self.addrs.items(): self.addrs[v] = k reactor.listenUDP( peer_addresses[uid][1], self )
def connectionMade(self): serveraddr = (Config.SERVER_ADDR, Config.SERVER_PORT) self.defer = defer.Deferred() self.transport.stopReading() reactor.listenUDP( 0, StupOutgoing(serveraddr, self)) yield self.defer self.transport.startReading()
def start(self): self.proxy = SipProxy(self.user, self.port, self.call_h, self.sms_h, self.self_ip, self.other_ip) reactor.listenUDP(self.port, self.proxy, self.self_ip) if not OpenBTSFakePhone.reactorRunning: OpenBTSFakePhone.reactorRunning = True Thread(target=reactor.run, args=(False,)).start()
def __init__(self, broadcast = True, listen_port = 0): """ Instantiate a NBNSProtocol instance. This automatically calls reactor.listenUDP method to start listening for incoming packets, so you **must not** call the listenUDP method again. :param boolean broadcast: A boolean flag to indicate if we should setup the listening UDP port in broadcast mode :param integer listen_port: Specifies the UDP port number to bind to for listening. If zero, OS will automatically select a free port number. """ self.broadcast = broadcast self.pending_trns = { } # TRN ID -> ( expiry_time, name, Deferred instance ) self.transport = reactor.listenUDP(listen_port, self) if self.broadcast: self.transport.getHandle().setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) reactor.callLater(1, self.cleanupPendingTrns)
def openClientMode(self, iface=None): if iface is None: iface = ('', 0) try: self._lport = reactor.listenUDP(iface[1], self, iface[0]) except Exception: raise error.CarrierError(sys.exc_info()[1]) return self
def openServerMode(self, iface): try: self._lport = reactor.listenUDP(iface[1], self, iface[0]) except Exception: raise error.CarrierError(sys.exc_info()[1]) return self
def __init__(self, secret, dictionary, server, port=1812, debug=False, stat_push=None): self.dict = dictionary self.secret = six.b(secret) self.server = server self.authport = port self.debug = debug self.stat_push = stat_push reactor.listenUDP(0, self)
