def test_unused_port_factory_fixture(unused_tcp_port_factory, loop): """Test the unused TCP port factory fixture.""" @asyncio.coroutine def closer(_, writer): writer.close() port1, port2, port3 = (unused_tcp_port_factory(), unused_tcp_port_factory(), unused_tcp_port_factory()) server1 = yield from asyncio.start_server(closer, host='localhost', port=port1, loop=loop) server2 = yield from asyncio.start_server(closer, host='localhost', port=port2, loop=loop) server3 = yield from asyncio.start_server(closer, host='localhost', port=port3, loop=loop) for port in port1, port2, port3: with pytest.raises(IOError): yield from asyncio.start_server(closer, host='localhost', port=port, loop=loop) server1.close() yield from server1.wait_closed() server2.close() yield from server2.wait_closed() server3.close() yield from server3.wait_closed()
def main(): #logging.basicConfig(level=logging.DEBUG) loop = asyncio.get_event_loop() #loop.set_debug(True) log = LogManager( name='scootr', min_synced_followers=1, ) #feed_server = FeedServer(log) #log.updated_cb = feed_server.log_updated_cb #loop.run_until_complete(log.open('/dev/null')) loop.run_until_complete(log.open()) master_coro = asyncio.start_server( functools.partial(Master.connection_handler, log), '127.0.0.1', 8888, loop=loop) follower_coro = asyncio.start_server( functools.partial(FollowerHandler.connection_handler, log), '127.0.0.1', 8889, loop=loop) start_monitor(loop, log) asyncio.async(master_coro) asyncio.async(follower_coro) #loop.run_until_complete(coro) loop.run_forever() loop.close() return
def run(self): logger.debug('service app starting...') self.running = True self.template_filename = pkConfig['paths']['event_template'] self.make_folders() # build folder structure to store photos self.clients = list() loop = asyncio.get_event_loop() camera = get_camera() # arduino # serial_device = AsyncSerial() # serial_device = SelectSerial() # board = Board(serial_device) board = None # ExitStack is used to gracefully close the camera and other services we open with ExitStack() as stack: stack.enter_context(camera) for service_info in load_services_from_config(): context = zc_service_context(service_info) stack.enter_context(context) # TODO: unify this board trigger and the packet trigger if board: task = loop.create_task( self.wait_for_trigger(board.wait_for_packet(), camera)) self.running_tasks.append(task) # the servers defined below will not keep asyncio.wait from # thinking they are done. meaning, without this pause, # aysncio will happily kill the server before any clients # have connected. # this delay task is added to prevent the app from closing before # clients have connected. # TODO: let servers wait indefinitely. # WARNING: this line will cause the program to eventually close task = loop.create_task(asyncio.sleep(26000)) self.running_tasks.append(task) # serve previews in highly inefficient manner # asyncio streaming protocol # https://docs.python.org/3/library/asyncio-stream.html func = partial(self.camera_preview_threaded_queue, camera) coro = asyncio.start_server(func, '127.0.0.1', 22222, loop=loop) task = loop.create_task(coro) self.running_tasks.append(task) # wait for a camera trigger in highly inefficient manner func = partial(self.wait_for_socket_open_trigger, camera) coro = asyncio.start_server(func, '127.0.0.1', 22223, loop=loop) task = loop.create_task(coro) self.running_tasks.append(task) try: loop.run_until_complete(asyncio.wait(self.running_tasks)) except asyncio.CancelledError: logger.critical('cancellation error was raised') pass
def run_module(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) if self.options.SSL: sc = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sc.load_cert_chain(self.options.CERT_PATH, self.options.KEY_PATH) self.server = self.loop.run_until_complete(asyncio.start_server(self.client_connected_handler, self.options.IP, self.options.PORT, ssl=sc)) else: self.server = self.loop.run_until_complete(asyncio.start_server(self.client_connected_handler, self.options.IP, self.options.PORT)) asyncio.async(self.cancel_tasks()) # send server and call stop if not isrunning() try: self.loop.run_forever() except KeyboardInterrupt: pass finally: self.stopper.set() self.loop.run_until_complete(self.cancel_tasks()) self.server.close() self.loop.run_until_complete(server.wait_closed()) self.loop.stop() self.loop.close()
def main(): host, port = settings.PROXY_RAW_ADDR yield from asyncio.start_server(client_connected, host=host, port=port) host, port = settings.PROXY_WS_ADDR yield from websockets.serve(ws_client_connected, host, port) host, port = settings.PROXY_HTTP_ADDR yield from asyncio.start_server(http_client_connected, host=host, port=port)
def start(self): if isinstance(self._listener, socket.socket): coro = asyncio.start_server(self._handler, loop=self._loop, sock=self._listener) else: host, port = self._listener coro = asyncio.start_server(self._handler, host, port, loop=self._loop) self._server = self._loop.run_until_complete(coro) self._listener = self._server.sockets[0].getsockname() log.info("start server on %s", self._listener) activated_func = getattr(self._app, "_activated", None) if activated_func: activated_func(self._listener)
def test_vnc_authentication(self): async def vnc_auth(): reader, writer = await asyncio.open_connection('127.0.0.1', 8888, loop=self.loop) # server rfb version _ = await reader.readline() writer.write(RFB_VERSION) # available auth methods _ = await reader.read(1024) writer.write(VNC_AUTH) # challenge _ = await reader.read(1024) # Pretending, that we encrypt received challenge with DES and send back the result. client_response = os.urandom(16) writer.write(client_response) # security result _ = await reader.read(1024) options = {'enabled': 'True', 'port': 8888, 'timeout': 30} capability = Vnc(options, self.loop) server_coro = asyncio.start_server(capability.handle_session, '0.0.0.0', 8888, loop=self.loop) self.server = self.loop.run_until_complete(server_coro) self.loop.run_until_complete(vnc_auth())
def _start_console(self): """ Start streaming the console via telnet """ class InputStream: def __init__(self): self._data = b"" def write(self, data): self._data += data @asyncio.coroutine def drain(self): if not self.ws.closed: self.ws.send_bytes(self._data) self._data = b"" output_stream = asyncio.StreamReader() input_stream = InputStream() telnet = AsyncioTelnetServer(reader=output_stream, writer=input_stream, echo=True) self._telnet_servers.append((yield from asyncio.start_server(telnet.run, self._manager.port_manager.console_host, self.console))) self._console_websocket = yield from self.manager.websocket_query("containers/{}/attach/ws?stream=1&stdin=1&stdout=1&stderr=1".format(self._cid)) input_stream.ws = self._console_websocket output_stream.feed_data(self.name.encode() + b" console is now available... Press RETURN to get started.\r\n") asyncio.async(self._read_console_output(self._console_websocket, output_stream))
def main(): if (len(sys.argv) < 3): print_usage_and_exit() try: local_address_port_list = map(parse_addr_port_string, sys.argv[1:-1]) (remote_address, remote_port) = parse_addr_port_string(sys.argv[-1]) except: print_usage_and_exit() def handle_client(client_reader, client_writer): asyncio.ensure_future(accept_client( client_reader = client_reader, client_writer = client_writer, remote_address = remote_address, remote_port = remote_port)) loop = asyncio.get_event_loop() for (local_address, local_port) in local_address_port_list: try: server = loop.run_until_complete( asyncio.start_server( handle_client, host = local_address, port = local_port)) except Exception as e: logger.error('Bind error: {}'.format(e)) sys.exit(1) for s in server.sockets: logger.info('listening on {}'.format(s.getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass
def run(self, host, port): loop = asyncio.get_event_loop() loop.run_until_complete( asyncio.start_server(self._on_client_connect, host=host, port=port) ) logger.info('Waiting for hangups to connect...') loop.run_until_complete(self._hangups.connect())
def test_invalid_login(self): """Tests if mysql server responds correctly to a invalid login attempt.""" def mysql_login(): try: pymysql.connect(host="0.0.0.0", port=8306, user="******", password="******", db="testdb") except pymysql.err.OperationalError as e: return e return None options = {'enabled': 'True', 'port': 8306} mysql_cap = mysql.MySQL(options, self.loop) server_coro = asyncio.start_server( mysql_cap.handle_session, '0.0.0.0', 8306, loop=self.loop) self.server = self.loop.run_until_complete(server_coro) mysql_task = self.loop.run_in_executor(None, mysql_login) login_exception = self.loop.run_until_complete(mysql_task) self.assertIsInstance(login_exception, pymysql.err.OperationalError) self.assertEqual( str(login_exception), '(1045, "Access denied for user \'tuser\'@\'127.0.0.1\' (using password: YES)")' )
def start(self, host=None, port=0, **kw): """ :py:func:`asyncio.coroutine` Start server. :param host: ip address to bind for listening. :type host: :py:class:`str` :param port: port number to bind for listening. :type port: :py:class:`int` :param kw: keyword arguments, they passed to :py:func:`asyncio.start_server` """ self.connections = {} self.server_host = host self.server_port = port self.server = yield from asyncio.start_server( self.dispatcher, host, port, loop=self.loop, **kw ) for sock in self.server.sockets: if sock.family == socket.AF_INET: host, port = sock.getsockname() message = str.format("serving on {}:{}", host, port) common.logger.info(add_prefix(message))
def run_module(self): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) self.loop = asyncio.get_event_loop() self.server = self.loop.run_until_complete(asyncio.start_server(self.client_connected_handler, self.options.IP, self.options.PORT)) asyncio.async(self.cancel_tasks()) # send server and call stop if not isrunning() try: self.loop.run_forever() except KeyboardInterrupt: pass finally: self.stopper.set() loop.run_until_complete(self.cancel_tasks()) self.server.close() loop.run_until_complete(server.wait_closed()) loop.stop() loop.close()
def test_login(self): """Testing different login combinations""" async def pop3_login(): login_sequences = [ # invalid login, invalid password (('USER wakkwakk', b'+OK User accepted'), ('PASS wakkwakk', b'-ERR Authentication failed.')), # PASS without user (('PASS bond', b'-ERR No username given.'),), # Try to run a TRANSACITON state command in AUTHORIZATION state (('RETR', b'-ERR Unknown command'),), ] for sequence in login_sequences: reader, writer = await asyncio.open_connection('127.0.0.1', 8888, loop=self.loop) # skip banner await reader.readline() for pair in sequence: writer.write(bytes(pair[0] + "\r\n", 'utf-8')) response = await reader.readline() self.assertEqual(response.rstrip(), pair[1]) options = {'port': 110, 'protocol_specific_data': {'max_attempts': 3}, 'users': {'james': 'bond'}} sut = Pop3(options, self.loop) server_coro = asyncio.start_server(sut.handle_session, '0.0.0.0', 8888, loop=self.loop) self.server = self.loop.run_until_complete(server_coro) self.loop.run_until_complete(pop3_login())
def startup(self): """Run the server loop and begin accepting connections.""" # TODO: Move host:port to an argument? coroutine = asyncio.start_server( self._create_client_connection, '127.0.0.1', 8888, loop=self._loop) self.server = self._loop.run_until_complete(coroutine) super().startup()
def test_show_server(event_loop, unused_tcp_port): cs = CredentialServer() coro = asyncio.start_server(cs.handle_cmd, '127.0.0.1', unused_tcp_port, loop=event_loop) event_loop.create_task(coro) (G, g, h, o) = cs.params # User creates a public / private key pair keypair = cred_UserKeyge(cs.params) # User packages credentials LT_user_ID = o.random() timeout = 100 key = 200 value = 300 public_attr = [ key, value, timeout ] private_attr = [ LT_user_ID ] resp = event_loop.run_until_complete(issue_client('127.0.0.1', unused_tcp_port, cs.params, cs.ipub, keypair, public_attr, private_attr, event_loop)) mac, user_token, cred = resp pub, EGenc, sig_u = user_token u, EncE, sig_s = cred Service_name = b"TestService" resp = event_loop.run_until_complete(show_client('127.0.0.1', unused_tcp_port, cs.params, cs.ipub, mac, sig_s, public_attr, private_attr, Service_name, event_loop)) assert resp == "SUCCESS"
def test_LOGIN(self): """Testing different login combinations using simple login auth mechanism.""" def imap_login(): login_sequences = [ ('kajoj_admin', 'thebestpassword'), ('\"kajoj_admin\"', 'the best password') ] imap_obj = imaplib.IMAP4('127.0.0.1', port=8888) for sequence in login_sequences: with self.assertRaises(imaplib.IMAP4.error) as error: imap_obj.login(sequence[0], sequence[1]) imap_exception = error.exception self.assertEqual(imap_exception.args[0], b'Authentication failed') imap_obj.logout() options = {'enabled': 'True', 'port': 143, 'timeout': 30, 'protocol_specific_data': {'max_attempts': 3, 'banner': '* OK IMAP4rev1 Server Ready'}} capability = Imap(options, self.loop) server_coro = asyncio.start_server(capability.handle_session, '0.0.0.0', 8888, loop=self.loop) self.server = self.loop.run_until_complete(server_coro) imap_task = self.loop.run_in_executor(None, imap_login) self.loop.run_until_complete(imap_task)
def test_forward_remote_specific_port(self): """Test forwarding of a specific remote port""" server = yield from asyncio.start_server(echo, None, 0, family=socket.AF_INET) server_port = server.sockets[0].getsockname()[1] sock = socket.socket() sock.bind(('', 0)) remote_port = sock.getsockname()[1] sock.close() with (yield from self.connect()) as conn: listener = yield from conn.forward_remote_port('', remote_port, '', server_port) yield from self._check_local_connection(listener.get_port()) listener.close() yield from listener.wait_closed() yield from conn.wait_closed() server.close() yield from server.wait_closed()
def main(): args = _parse_arguments() logging.basicConfig(level=args.loglevel.upper()) loop = asyncio.get_event_loop() def root_factory(req): return StaticRootResource(args.root) req_cb = HttpRequestCB(root_factory) conn_cb = HttpConnectionCB(req_cb) starter = asyncio.start_server(conn_cb, args.bind, args.port, backlog=args.backlog, reuse_address=True, loop=loop) server = loop.run_until_complete(starter) if args.bind == '': logger().info('Server serving at <all interfaces>:{}'.format(args.port)) else: logger().info('Server serving at {}:{}'.format(args.bind, args.port)) try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def run(self): if not self.upstream_ip or not self.upstream_port or not \ self.listen_ip or not self.listen_port or not self.users: raise PipecastError('set_upstream() and set_listen() must be called' ' and at least one add_user() must be added ' ' created before calling run()') log.info('Starting up pipecast...') loop = asyncio.get_event_loop() try: coro = asyncio.start_server(self.client_connected, host=self.listen_ip, port=self.listen_port) server = loop.run_until_complete(coro) except Exception as e: s = 'Unable to listen on {}:{}: {}' log.error(s.format(self.listen_ip, self.listen_port, e)) sys.exit(1) lh, lp = server.sockets[0].getsockname() log.info('Listening on {}:{}'.format(lh, lp)) log.info('Starting main loop, use ^C to stop') try: loop.run_forever() except KeyboardInterrupt: log.info('Caught ^C, stopping') log.info('Terminating pipecast')
def connect(self, from_, session_id, device=None, port=None): """ """ print(datetime.datetime.now(),' - driver.connect called:') #print('\n\targs: ',locals(),'\n') self.connected_info = {'from':from_,'session_id':session_id} self.the_loop = asyncio.get_event_loop() #asyncio.async(serial.aio.create_serial_connection(self.the_loop, Output, '/dev/ttyUSB0', baudrate=115200)) callbacker = Output(self) try: if self.the_loop.is_running(): self.the_loop.stop() print(self.simulation) if self.simulation: print(simulator) server = self.the_loop.run_until_complete(asyncio.start_server(simulator,'0.0.0.0',3334)) self.the_loop.run_until_complete(self.the_loop.create_connection(lambda: callbacker, host='0.0.0.0', port=3334)) #yield from server.wait_closed() else: smoothie_host=os.environ.get('SMOOTHIE_HOST', '0.0.0.0') smoothie_port=int(os.environ.get('SMOOTHIE_PORT', '3333')) asyncio.async(self.the_loop.create_connection( lambda: callbacker, host=smoothie_host, port=smoothie_port)) except: print(datetime.datetime.now(),' - error:driver.connects\n\r',sys.exc_info())
def __init__(self, info: ServerInfo, network_structure: List[List[ServerInfo]], loop, data: Data): super().__init__() self.client_request_info = None self.quorum_requester_info = None # the guy who requested quorum self.is_top_node = False self.temp_data = None # field to contain data until it can be written self.network_structure = network_structure """ a network structure contains information about which groups the given node belongs to and is of the form [ [a,d,e], [a,b,c] ] where last element of the outer list is its actual bottom level group and the first elements of the outer list are the virtual groupings. ___________________a____ ... | | _______a_________ ... | | | __a__ __d__ __e__ | | | | | | | | | a b c . . . . . . """ self.level_quorum_count = self.create_empty_quorum_count(network_structure) self.loop = loop # reference to the asyncio eventloop self.info = info # address information for current node self.data = data # replicated data file server_task = asyncio.start_server( self.handle_msg, info.ip, info.port, loop=loop) self.server = loop.run_until_complete(server_task)
def start_interactive_server(factory=code.AsynchronousConsole, host='localhost', port=8000, banner=None, *, loop=None): callback = lambda reader, writer: handle_connect( reader, writer, factory, banner) server = yield from asyncio.start_server(callback, host, port, loop=loop) return server
def test_basic_requests(self): proxy_http_client = Client() proxy_server = HTTPProxyServer(proxy_http_client) proxy_socket, proxy_port = tornado.testing.bind_unused_port() yield from asyncio.start_server(proxy_server, sock=proxy_socket) connection_pool = HTTPProxyConnectionPool(('127.0.0.1', proxy_port)) http_client = Client(connection_pool=connection_pool) for dummy in range(3): with http_client.session() as session: response = yield from session.start(Request(self.get_url('/'))) self.assertEqual(200, response.status_code) file = io.BytesIO() yield from session.download(file=file) data = file.getvalue().decode('ascii', 'replace') self.assertTrue(data.endswith('</html>')) with http_client.session() as session: response = yield from session.start(Request( self.get_url('/always_error'))) self.assertEqual(500, response.status_code) self.assertEqual('Dragon In Data Center', response.reason) file = io.BytesIO() yield from session.download(file=file) data = file.getvalue().decode('ascii', 'replace') self.assertEqual('Error', data)
def start(self): sock = socket.socket() sock.bind(("127.0.0.1", 0)) self.server = self.loop.run_until_complete( asyncio.start_server(self.handle_client, sock=sock, loop=self.loop) ) return sock.getsockname()
def test_tcp_handle_abort_in_connection_made(self): async def server(reader, writer): try: await reader.read() finally: writer.close() class Proto(asyncio.Protocol): def connection_made(self, tr): tr.abort() srv = self.loop.run_until_complete(asyncio.start_server( server, '127.0.0.1', 0, family=socket.AF_INET, loop=self.loop)) async def runner(): tr, pr = await asyncio.wait_for( self.loop.create_connection( Proto, *srv.sockets[0].getsockname()), timeout=1.0, loop=self.loop) # Asyncio would return a closed socket, which we # can't do: the transport was aborted, hence there # is no FD to attach a socket to (to make # get_extra_info() work). self.assertIsNone(tr.get_extra_info('socket')) tr.close() self.loop.run_until_complete(runner()) srv.close() self.loop.run_until_complete(srv.wait_closed())
def start_forwarding(host, port, handler_type, bind_address='0.0.0.0', server_port=0, loop=None): if loop is None: loop = asyncio.get_event_loop() # GIOP handler if handler_type != HandlerType.ZMQ: # Make handler key = host, port, bind_address handler_dict = { HandlerType.DB: handle_db_client, HandlerType.DS: handle_ds_client} handler = partial(handler_dict[handler_type], key=key) # Start server server = yield from asyncio.start_server( handler, bind_address, server_port, family=socket.AF_INET, loop=loop) bind_address, server_port = server.sockets[0].getsockname() # ZMQ handler else: # Make translater address = bind_address, loop.server_port translater = make_translater(address, loop.tango_host) # Start server coro = zmqforward.pubsub_forwarding( host, port, translater, bind_address, server_port, loop=loop) server, bind_address, server_port = yield from coro # Print and return msg = "Forwarding {} traffic on {} port {} to {} port {}" msg = msg.format(handler_type.name, bind_address, server_port, host, port) logger.info(msg) return server, bind_address, server_port
def start_warp_server(host, port): try: yield from asyncio.start_server(accept_client, host=host, port=port) except error as e: logger.critical('!!! Fail to bind server at [%s:%d]: %s' % (host, port, e.args[1])) return 1 logger.info('Server bound at [%s:%d].' % (host, port))
def run(self): server_coroutine = asyncio.start_server(self.handle_client_connection, LISTEN, PORT, loop=self.event_loop) tcp_server = self.event_loop.run_until_complete(server_coroutine) print('Serving on {}'.format(tcp_server.sockets[0].getsockname())) return tcp_server
def test_tcp_handle_unclosed_gc(self): fut = self.loop.create_future() async def server(reader, writer): writer.transport.abort() fut.set_result(True) async def run(): addr = srv.sockets[0].getsockname() await asyncio.open_connection(*addr, loop=self.loop) await fut srv.close() await srv.wait_closed() srv = self.loop.run_until_complete(asyncio.start_server( server, '127.0.0.1', 0, family=socket.AF_INET, loop=self.loop)) if self.loop.get_debug(): rx = r'unclosed resource <TCP.*; ' \ r'object created at(.|\n)*test_tcp_handle_unclosed_gc' else: rx = r'unclosed resource <TCP.*' with self.assertWarnsRegex(ResourceWarning, rx): self.loop.create_task(run()) self.loop.run_until_complete(srv.wait_closed()) gc.collect() self.loop.run_until_complete(asyncio.sleep(0.1)) # Since one TCPTransport handle wasn't closed correctly, # we need to disable this check: self.skip_unclosed_handles_check()
send_file[0:2]+[send_file[2].format(op_code[2]).encode('utf8')]+[send_file[3].format(op_code[3]).encode('utf8')]+[b'\r\n'] ) elif op_code[4]:#如果是文本 #print("2") writer.writelines( send_file[0:2] + [send_file[2].format(op_code[2]).encode('utf8')] + [send_file[3].format(op_code[3]).encode('utf8')] + [b'\r\n'] + [('<xmp>'+op_code[1].read()+'</'+'xmp>').encode("utf8")] + [b'\r\n'] ) else: #print("3") writer.writelines( send_file[0:2] + [send_file[2].format(op_code[2]).encode('utf8')] + [send_file[3].format(op_code[3]).encode('utf8')] + [b'\r\n']+[op_code[1].read()]+[b'\r\n'] ) #print(send_file[0:2] + [send_file[2].format(op_code[2]).encode('utf8')] + [send_file[3].format(op_code[3]).encode('utf8')] + [b'\r\n']+[op_code[1].read()]+[b'\r\n']) await writer.drain() writer.close() if __name__ == '__main__': loop = asyncio.get_event_loop() coro = asyncio.start_server(dispatch,'127.0.0.1',8080,loop=loop) server = loop.run_until_complete(coro) print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_close()) loop.close
buf = Buffer(provenance) while True: data = yield from reader.read(BLOCKSIZE) for pkt in buf.eat(data): writer.write(packet.encode(pkt, provenance=provenance)) sys.stdout.write('{} {}\n'.format(tag, pkt)) sys.stdout.flush() @asyncio.coroutine def handle_p2c(client_reader, client_writer): server_reader, server_writer = yield from asyncio.open_connection( args.address, args.port, loop=loop) asyncio. async (transit(client_reader, server_writer, provenance=packet.PacketProvenance.client, tag='[C>S]'), loop=loop) asyncio. async (transit(server_reader, client_writer, provenance=packet.PacketProvenance.server, tag='[C<S]'), loop=loop) svr = asyncio.start_server(handle_p2c, '127.0.0.1', args.proxy_port, loop=loop) server = loop.run_until_complete(svr) loop.run_forever()
if (result == b"failed" or result == b"success"): self.init() break print('------------client --------') except Exception as e: print('------------Exception occure --------') traceback.print_exc() finally: writer.close() self.init() loop = asyncio.get_event_loop() init_app() coro = asyncio.start_server(RsaFtpVar.file_trans_protocal, SERVER_URL, SERVER_PORT, loop=loop) server = loop.run_until_complete(coro) print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass # Close the server server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def main(): global user_stats global ip_stats if len(sys.argv) < 2: config_path = "./config.py" elif len(sys.argv) == 2: config_path = sys.argv[1] else: print("Usage: mtprotoproxy [path/to/config.py]") if not load_config(globals(), config_path): return try: setup_uvloop() except: pass try: setup_fd_limit() except Exception as exc: print_err("Failed to increase file limit:", exc) try: setup_debug() except: pass init_ip_info() print_tg_info() user_stats = {} ip_stats = {} if sys.platform == "win32": loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(loop) loop = asyncio.get_event_loop() loop.set_exception_handler(loop_exception_handler) loop.run_until_complete(INIT_HOOK(HookAPI(USERS, user_stats, ip_stats))) stats_printer_task = asyncio.Task(stats_printer()) asyncio.ensure_future(stats_printer_task) if USE_MIDDLE_PROXY: middle_proxy_updater_task = asyncio.Task(update_middle_proxy_info()) asyncio.ensure_future(middle_proxy_updater_task) reuse_port = hasattr(socket, "SO_REUSEPORT") task_v4 = asyncio.start_server(handle_client_wrapper, '0.0.0.0', PORT, limit=TO_TG_BUFSIZE, reuse_port=reuse_port, loop=loop) server_v4 = loop.run_until_complete(task_v4) if socket.has_ipv6: task_v6 = asyncio.start_server(handle_client_wrapper, '::', PORT, limit=TO_TG_BUFSIZE, reuse_port=reuse_port, loop=loop) server_v6 = loop.run_until_complete(task_v6) try: loop.run_forever() except KeyboardInterrupt: pass stats_printer_task.cancel() server_v4.close() loop.run_until_complete(server_v4.wait_closed()) if socket.has_ipv6: server_v6.close() loop.run_until_complete(server_v6.wait_closed()) loop.close()
def start(self): return asyncio.start_server(self.handle_client, port=self._listen_port)
response = json.dumps(mapfile) elif req['arg'] == 'tokens': response = json.dumps(tokens) else: response = 'err' elif req['op'] == 'set': if req['arg'] == 'place_token': token_name = req['data']['name'] row = req['data']['row'] col = req['data']['col'] img = req['data']['img'] tokens[token_name] = {'row': row, 'col': col, 'img': img} response = 'ack' elif req['op'] == 'admin': print(req) if req['arg'] == 'set_map': mapfile = req['data'] tokens = {} response = 'ack' else: response = 'err' resp_len = len(response.encode('utf8')) writer.write(((u'%08d' % resp_len) + response).encode('utf8')) await writer.drain() writer.close() loop = asyncio.get_event_loop() loop.create_task(asyncio.start_server(handle_client, HOST, PORT)) loop.run_forever()
@asyncio.coroutine def hello(self, *args): """ Hello world This command accept arguments: hello tutu will display tutu """ @asyncio.coroutine def world(): yield from asyncio.sleep(2) if len(args): return ' '.join(args) else: return 'world\n' return (yield from world()) # Demo using telnet shell = Demo(welcome_message="Welcome!\n") server = create_telnet_shell(shell, loop=loop) coro = asyncio.start_server(server.run, '127.0.0.1', 4444, loop=loop) s = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass # Demo using stdin # loop.run_until_complete(create_stdin_shell(Demo())) # loop.close()
def main(): parser = argparse.ArgumentParser(description='asyncio lcx.') parser.add_argument('-m', dest='mode', required=True, help='mode, slave or listen') parser.add_argument('-p', dest='port', required=True, type=int, help='RemoteListen port or Need it open port') parser.add_argument('-u', dest='user', required=True, help='user username:password') parser.add_argument('-r', dest='RL_address', required=True, help='RemoteListen listen address:port') parser.add_argument('-l', dest='LS_address', required=True, help='LocalServer listen address:port') print('=' * 77) if 'listen' in sys.argv: if '-p' in sys.argv: index = sys.argv.index('-p') try: global users, port1, loop # global tasks port1 = int(sys.argv[index + 1]) allusers = str(sys.argv[index + 3]) users = allusers.split(',') loop = asyncio.get_event_loop() # asyncio.start_server()会产生一对writer和reader,与所连接的客户端通信 # 开启Remote Listen 127.0.0.1:8000 coro = asyncio.start_server(tcpRemoteListen, '127.0.0.1', port1, loop=loop) server = loop.run_until_complete(coro) print('RemoteListen serving on {}'.format( server.sockets[0].getsockname())) loop.run_forever() server.close() loop.run_until_complete(server.wait_closed()) loop.close() except: print("Something Wrong") else: print("Input Wrong") elif 'slave' in sys.argv: if '-r' in sys.argv: index = sys.argv.index('-r') try: address1 = str(sys.argv[index + 1]) ip1 = address1.split(':', 2) user = str(sys.argv[index + 3]) port = str(sys.argv[index + 5]) address2 = str(sys.argv[index + 7]) ip2 = address2.split(':', 2) loop = asyncio.get_event_loop() loop.run_until_complete(tcpslave(user, ip1, port, ip2, loop)) loop.close() except: print("Something Wrong") else: print("Input Wrong")
async def tcpRemoteListen(reader, writer): # rid S L R<C 连接请求id # 当 S L>R C 连接时,R产生一对reader和writer和L通信,转给slave和listen global listen, slave, lport, rid, ConnectionID, L_Rconnection, ConnectionidQueue listen = reader slave = writer salt = ''.join(random.sample(string.ascii_letters + string.digits, 15)) packet = PackChapsalt(salt) writer.write(packet) await writer.drain() print("S L<R C chap_salt : send salt") message = await reader.readexactly(3) ml, c = struct.unpack("!hb", message) if c != 2: raise printException("Remote Listen do not receive chaphash") message = await reader.readexactly(ml - 3) username, rmd5 = UnpackChaphash(ml, message) print("S L>R C chap_salt : received salt") for user in users: un = user.split(':') if username.decode() == un[0]: password = un[1] else: print("S L<>R C chap_result : chap authentication failed") break m = hashlib.md5() pas = password.encode() str = salt.encode() + pas m.update(str) md5 = m.hexdigest() if md5 == rmd5.decode(): packet = PackChapresult(1) writer.write(packet) await writer.drain() print("S L<R C chap_result : send result") print("S L<R C chap_result : authentication succeed") message = await reader.readexactly(3) ml, c = struct.unpack("!hb", message) if c != 4: raise printException( 'S L>R C bind_request : Remote Listen do not received bindrequest' ) message = await reader.readexactly(4) print('S L>R C bind_request : received bindrequest') rid, lport = UnpackBindrequest(message) if lport == "0": lport = random.randint(1, 65535) try: # Remote Listen 开启监听端口8001 等RemoteClient连接 await asyncio.ensure_future( asyncio.start_server(RemoteClient_handle, '127.0.0.1', lport, loop=loop)) result = 1 packet = PackBindresponse(rid, result, lport) writer.write(packet) print("S L<R C bind_response : send response") print("S L<>R C bind : bind succeed") while True: message = await reader.readexactly(3) ml, c = struct.unpack("!hb", message) if c == 7: #connect response message = await reader.readexactly(5) rid, result, cid = UnpackConnectresponse(message) print( "S L>R C connect_response : received response from request ID is %d and connection ID is %d" % (rid, cid)) if result == 0: raise printException( "S L>R C connect_response : Remote Listen do not received response" ) # 连接成功,把cid放入ConnectionidQueue队列中 ConnectionidQueue.put(cid) ConnectionID = cid elif c == 8: # data message = await reader.readexactly(ml - 3) cid, data = UnpackData(ml, message) dflag = 1 while dflag: await asyncio.sleep(0.01) if len(L_Rconnection) > cid: for client in ClientWriter: if client.get_extra_info( 'peername') == L_Rconnection[cid]: client.write(data) dflag = 0 break elif c == 9: # disconnect message = await reader.readexactly(2) cid = UnpackDisconnect(message)[0] for client in ClientWriter: if client.get_extra_info( 'peername') == L_Rconnection[cid]: client.close() print( "S L R<>C disconnect : the disconnect ID is %d" % (cid)) else: message = await reader.readexactly(ml - 3) except: print("Listen Port Failed!") result = 0 packet = PackBindresponse(rid, result, lport) writer.write(packet) exit() else: packet = PackChapresult(0) writer.write(packet) loop.stop()
avg_util['flash'] < UTIL_FLASH_LOWER_LIMIT: # remove a node with the lowest network utilization datanodeip_port = datanode_usage['net'].idxmin() print("Datanode with lowest net or cpu usage is: ", datanodeip_port) datanode_alloc.at[datanodeip_port, 'blacklisted'] = 1 datanode_usage.at[datanodeip_port, 'blacklisted'] = 1 datanode_provisioned.at[datanodeip_port, 'blacklisted'] = 1 ''' if __name__ == '__main__': loop = asyncio.get_event_loop() # Start server listening for register/deregister job connections #address = ("localhost", 4321) address = (CONTROLLER_IP, 4321) coro = asyncio.start_server(handle_jobs, *address) server = loop.run_until_complete(coro) print('Listening at {}'.format(address)) # Initialize routine to periodically send metadata_socket = ioctlcmd.connect_until_succeed(NAMENODE_IP, NAMENODE_PORT) asyncio. async (get_capacity_stats_periodically(metadata_socket)) # Periodically check avg utilization and run autoscale algorithm logfile = open("resource_util.log", "w+") print("time", "net_usedMbps", "avg_cpu", "dram_usedGB", "net_allocMbps",
unix = True addr = args.addr[5:] if os.path.exists(addr): os.remove(addr) else: addr = args.addr.split(':') addr[1] = int(addr[1]) addr = tuple(addr) print('readline performance test') print('serving on: {}'.format(addr)) print('using asyncio/streams') if unix: coro = asyncio.start_unix_server(echo_client_streams, addr, loop=loop, limit=256000) else: coro = asyncio.start_server(echo_client_streams, *addr, loop=loop, limit=256000) srv = loop.run_until_complete(coro) try: loop.run_forever() finally: if hasattr(loop, 'print_debug_info'): gc.collect() print(chr(27) + "[2J") loop.print_debug_info() loop.close()
dataInRaw = await reader.read(1024) dataIn = dataInRaw.decode().strip() ## 使用strip()移除首尾空白字符 ## 得到套接字的远程地址 print("Received %s from %s" % (dataIn, addr)) writer.write(dataInRaw) ## 刷新writer缓冲区 await writer.drain() if dataIn == 'exit': break writer.close() print('客户端 %s 断开', addr) ## 创建异步socket服务器, 对每个客户端连接都使用echoHandler处理. serverCoro = asyncio.start_server(echoHandler, host = '0.0.0.0', port = 6379) try: server = loop.run_until_complete(serverCoro) loop.run_forever() except KeyboardInterrupt: print('user entered Ctrl + C...') server.close() # server.wait_closed返回一个 future # 调用loop.run_until_complete 方法,运行 future loop.run_until_complete(server.wait_closed()) # 终止事件循环 loop.close() ## 以下使用create_task() + run_forever(), 也是正确的做法 ## try:
def start_server(self, *args: Any, **kwargs: Any) -> Any: return asyncio.start_server(self.accept_handler, *args, **kwargs)
'reply': reply from the nmt 'function': reply_nmt 'channel' channel for watbot to reply into } """ async def soc_handle(reader, writer): print("message received") command = await reader.read() command = pickle.loads(command) command['reply'] = process_message(command['message']) await send_to_watbot(command) loop = asyncio.get_event_loop() coro = asyncio.start_server(soc_handle, '127.0.0.1', 8888, loop=loop) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass # Close the server server.close() loop.run_until_complete(server.wait_closed()) loop.close()
remote_reader, remote_writer = await asyncio.open_connection(host, port) except OSError as exc: if exc.args[0] == errno.ETIMEDOUT: writer.close() elapsed('REMOTE TIMEDOUT', time.time()) return raise elapsed('REMOTE elapsed %f', tm_remote) # -- # PIPE TIME tm_pipe = time.time() writer.write(b'\x05\x00\x00\x01\x00\x00\x00\x00\x10\x10') await writer.drain() loop.create_task(pipe(reader, remote_writer)) loop.create_task(pipe(remote_reader, writer)) elapsed('PIPE CREATE elapsed %f', tm_pipe) # PIPE TIME if __name__ == '__main__': loop = asyncio.get_event_loop() bind_listen = asyncio.start_server(socks5_handle, host='0.0.0.0', port=20000) server = loop.run_until_complete(bind_listen) try: loop.run_forever() finally: loop.close() server.close()
# -*- coding: utf-8 -*- import asyncio async def echo(reader, writer): while True: data = await reader.readline() if not data: break print(data) writer.write(data) await writer.drain() writer.close() if __name__ == '__main__': loop = asyncio.get_event_loop() coro = asyncio.start_server(echo, '127.0.0.1', 2333) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass # Close the server server.close() loop.run_until_complete(server.wait_closed()) loop.close()
ssl_context = SSL.Context(SSL.SSLv23_METHOD) tls_start.ssl_conn = SSL.Connection(ssl_context) tls_start.ssl_conn.set_connect_state() if tls_start.context.client.sni is not None: tls_start.ssl_conn.set_tlsext_host_name( tls_start.context.client.sni.encode()) await SimpleConnectionHandler( reader, writer, opts, { "next_layer": next_layer, "request": request, "tls_start_client": tls_start_client, "tls_start_server": tls_start_server, }).handle_client() coro = asyncio.start_server(handle, '127.0.0.1', 8080, loop=loop) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed assert server.sockets print( f"Serving on {human.format_address(server.sockets[0].getsockname())}") try: loop.run_forever() except KeyboardInterrupt: pass # Close the server server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def run(self): loop = asyncio.get_event_loop() loop.create_task(asyncio.start_server(self.handler, '0.0.0.0', 5555)) self.election_task = loop.create_task(self.become_candidate()) loop.run_forever()
writer.writelines(content) except: writer.writelines(sorry) except FileNotFoundError: writer.writelines(err404) await writer.drain() writer.close() # while True: # data = await reader.readline() # message = data.decode().split(' ') # print(data) # if data == b'\r\n': # break if __name__ == '__main__': loop = asyncio.get_event_loop() coro = asyncio.start_server(browser, '127.0.0.1', 8080, loop=loop) server = loop.run_until_complete(coro) print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_closed()) loop.close()
upload_name_binary = await reader.read(length) upload_name = upload_name_binary.decode('utf-8') upload_path = os.path.join(UPLOAD_DIR, upload_name) i = 0 if os.path.exists(upload_path): os.remove(upload_path) print('Uploading... {} started at {}'.format(upload_name, datetime.datetime.now())) while True: data = await reader.read(1024) if not data: break with open(upload_path, 'ab') as fup: fup.write(data) uploaded_size = i * 1024 upload_percentage = struct.pack('f', uploaded_size / size * 100) writer.write(upload_percentage) await writer.drain() i += 1 writer.close() print('Upload of {} complete at {}'.format(upload_name, datetime.datetime.now())) loop = asyncio.get_event_loop() coro = asyncio.start_server(handle_request, HOST, PORT, loop=loop) server = loop.run_until_complete(coro) print('Server started on {}'.format(server.sockets[0].getsockname())) loop.run_forever() server.close() loop.run_until_complete(server.wait_closed()) loop.close()
# so if user is at /A/B, we must force redirect user to /A/B/ (with the last '/'). # The last '/' really matters!!!!!!!!!! writer.writelines([b'<meta http-equiv="Refresh" content="0;url=' + fields[1].encode() + b'/">']) writer.writelines([ b'</head><body>\r\n', b'<h1>Index of ' + bytes(dest) + b'</h1><hr><pre>\r\n' ]) if fields[1] != '/': # if current dir is not root dir, then add a link to allow users to go to the upper level. writer.writelines([b'<a href="../">..(upper level)</a></br>']) writer.writelines(generate_index(dest)) # generate_index() generates index and returns a list of HTML links. writer.writelines([ # end of HTML b'</pre></hr></body></html>\r\n', b'\r\n' ]) await writer.drain() # break operation writer.close() if __name__ == '__main__': loop = asyncio.get_event_loop() listener = asyncio.start_server(dispatch, host='0.0.0.0', port=8080, loop=loop) # listen on 8080 server = loop.run_until_complete(listener) print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() # start server except Exception as e: print(str(e)) server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def _event_loop_run(io_handle, url, port): event_loop = asyncio.get_event_loop() async_start = asyncio.start_server(io_handle, url, port, loop=event_loop) event_loop.run_until_complete(async_start) event_loop.run_forever()
def start(self): """ Start the broker to serve with the given configuration Start method opens network sockets and will start listening for incoming connections. This method is a *coroutine*. """ try: self._sessions = dict() self._subscriptions = dict() self._retained_messages = dict() self.transitions.start() self.logger.debug("Broker starting") except (MachineError, ValueError) as exc: # Backwards compat: MachineError is raised by transitions < 0.5.0. self.logger.warning("[WARN-0001] Invalid method call at this moment: %s" % exc) raise BrokerException("Broker instance can't be started: %s" % exc) yield from self.plugins_manager.fire_event(EVENT_BROKER_PRE_START) try: # Start network listeners for listener_name in self.listeners_config: listener = self.listeners_config[listener_name] if 'bind' not in listener: self.logger.debug("Listener configuration '%s' is not bound" % listener_name) else: # Max connections try: max_connections = listener['max_connections'] except KeyError: max_connections = -1 # SSL Context sc = None # accept string "on" / "off" or boolean ssl_active = listener.get('ssl', False) if isinstance(ssl_active, str): ssl_active = ssl_active.upper() == 'ON' if ssl_active: try: sc = ssl.create_default_context( ssl.Purpose.CLIENT_AUTH, cafile=listener.get('cafile'), capath=listener.get('capath'), cadata=listener.get('cadata') ) sc.load_cert_chain(listener['certfile'], listener['keyfile']) sc.verify_mode = ssl.CERT_OPTIONAL except KeyError as ke: raise BrokerException("'certfile' or 'keyfile' configuration parameter missing: %s" % ke) except FileNotFoundError as fnfe: raise BrokerException("Can't read cert files '%s' or '%s' : %s" % (listener['certfile'], listener['keyfile'], fnfe)) address, s_port = listener['bind'].split(':') port = 0 try: port = int(s_port) except ValueError as ve: raise BrokerException("Invalid port value in bind value: %s" % listener['bind']) if listener['type'] == 'tcp': cb_partial = partial(self.stream_connected, listener_name=listener_name) instance = yield from asyncio.start_server(cb_partial, address, port, ssl=sc, loop=self._loop) self._servers[listener_name] = Server(listener_name, instance, max_connections, self._loop) elif listener['type'] == 'ws': cb_partial = partial(self.ws_connected, listener_name=listener_name) instance = yield from websockets.serve(cb_partial, address, port, ssl=sc, loop=self._loop, subprotocols=['mqtt']) self._servers[listener_name] = Server(listener_name, instance, max_connections, self._loop) self.logger.info("Listener '%s' bind to %s (max_connections=%d)" % (listener_name, listener['bind'], max_connections)) self.transitions.starting_success() yield from self.plugins_manager.fire_event(EVENT_BROKER_POST_START) #Start broadcast loop self._broadcast_task = asyncio.async(self._broadcast_loop(), loop=self._loop) self.logger.debug("Broker started") except Exception as e: self.logger.error("Broker startup failed: %s" % e) self.transitions.starting_fail() raise BrokerException("Broker instance can't be started: %s" % e)
import asyncio @asyncio.coroutine def echo_client(reader, writer): print("Client starting") while True: line = yield from reader.readline() if not line: break resp = b'Got:' + line writer.write(resp) print("Client closed") writer.close() loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.start_server(echo_client, host='', port=25000)) loop.run_forever()
data = await reader.read(n=100) print('reader:', reader) print('writer:', writer) print('transport:', writer.transport) message = data.decode() addr = writer.get_extra_info('peername') print("Received %r from %r" % (message, addr)) print("Send: %r" % message) writer.write(data) await writer.drain() print("Close the client socket") writer.close() if __name__ == '__main__': loop = asyncio.get_event_loop() coro = asyncio.start_server(handle_echo, '127.0.0.1', 8888, loop=loop) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass # Close the server server.close() loop.run_until_complete(server.wait_closed()) loop.close()
try: if await proof(l, r, w): await chall(l, r, w) except Exception as e: print(e) pass finally: w.write_eof() w.close() with ProcessPoolExecutor() as executor: loop = asyncio.get_event_loop() loop.set_default_executor(executor) coro = asyncio.start_server(partial(handle, loop), '0.0.0.0', 1254, loop=loop) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed try: loop.run_forever() except KeyboardInterrupt: pass # Close the server server.close() loop.run_until_complete(server.wait_closed()) loop.close()
dest='shut_mode', required=True, help='Shut mode, c:client s:server') parser.add_argument('-t', dest='test_times', type=int, default=10, help='Times for remote-client connect remote-listen') args = parser.parse_args() log.info('=' * 77) loop = asyncio.get_event_loop() coro = asyncio.start_server(server_do_slave, '0.0.0.0', args.server_port, loop=loop) server = loop.run_until_complete(coro) log.info('S:L R C bind {:5}'.format(args.server_port)) bind_host, bind_port = args.bind_addr.split(':', 1) # task_list = [] # for t in range(args.test_times): # task = loop.create_task(client_do_listen(bind_host, bind_port)) # task_list.append(task) # loop.run_until_complete(asyncio.wait([client_do_listen(bind_host, bind_port) for i in range(args.test_times)])) loop.run_until_complete( asyncio.gather(*[
response = None text = '' received = received.replace('<<CLASSIFY>>', '') lines = received.split("\n") for l in lines: if ('CLASSIFIER=' in l): classifier = l.split('=')[1] elif ('LANGHINT=' in l): langhint = l.split('=')[1] else: text += l # print("classify "+text) if (classifier == 'cld2'): if (langhint): isReliable, textBytesFound, details = cld2.detect( text, bestEffort=True, hintLanguage=langhint) else: isReliable, textBytesFound, details = cld2.detect(text, bestEffort=True) response = str((details[0][1], isReliable, details)) else: response = str(identifier.classify(text)) writer.write(response.encode('utf8')) loop = asyncio.get_event_loop() loop.create_task(asyncio.start_server(handle_client, 'localhost', 15555)) loop.run_forever()
writer.write( b"You successfully paid the order. Your secret is: %s\r\n" % (c.fetchone()[0]).encode()) break else: writer.write( b"Wrong coupon code. Try again. You have %s attempts remaining\r\n" % str(attempts).encode()) attempts -= 1 else: raise ValueError except ValueError: writer.write(b"Not a valid order ID or already paid\r\n") loop = asyncio.get_event_loop() coro = asyncio.start_server(main_loop, '0.0.0.0', 8888, loop=loop) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed print('Serving on {}'.format(server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass # Close the server server.close() loop.run_until_complete(server.wait_closed()) loop.close()
protocol.Hello: handle_hello, protocol.BulkPacket: handle_bulk } if __name__ == "__main__": import argparse parser = argparse.ArgumentParser() parser.add_argument("-v", "--verbose", action="store_true") parser.add_argument("-p", "--port", type=int, default=7766) parser.add_argument("-b", "--bind", type=str, default="127.0.0.1") args = parser.parse_args() logging.basicConfig( level=(logging.DEBUG if args.verbose else logging.INFO)) loop = asyncio.get_event_loop() coro = asyncio.start_server(CDCServer.make_instance, args.bind, args.port, loop=loop) handle = loop.run_until_complete(coro) log.info("Serving on {}".format(handle.sockets[0].getsockname())) try: loop.run_forever() finally: handle.close() loop.run_until_complete(handle.wait_closed()) loop.close()