def custom_feeder(input, coro=None): def write_proc(fin, pipe, coro=None): while True: data = yield os.read(fin.fileno(), 8*1024) if not data: break n = yield pipe.write(data, full=True) assert n == len(data) fin.close() pipe.stdin.close() def read_proc(pipe, coro=None): # output from sha1sum is small, so read until EOF data = yield pipe.stdout.read() pipe.stdout.close() raise StopIteration(data) if platform.system() == 'Windows': # asyncfile.Popen must be used instead of subprocess.Popen pipe = asyncoro.asyncfile.Popen([r'\cygwin64\bin\sha1sum.exe'], stdin=subprocess.PIPE, stdout=subprocess.PIPE) else: pipe = subprocess.Popen(['sha1sum'], stdin=subprocess.PIPE, stdout=subprocess.PIPE) async_pipe = asyncoro.asyncfile.AsyncPipe(pipe) reader = asyncoro.Coro(read_proc, async_pipe) writer = asyncoro.Coro(write_proc, open(input), async_pipe) stdout = yield reader.finish() print(' feeder sha1sum: %s' % stdout)
def client_proc(coro=None): channel = asyncoro.Channel('sum_prod') sum_coro = asyncoro.Coro(seqsum) prod_coro = asyncoro.Coro(seqprod) yield channel.subscribe(sum_coro) yield channel.subscribe(prod_coro) for x in range(4): r = random.uniform(0.5, 3) channel.send(r) print('sent %f' % r) channel.send(None) yield channel.unsubscribe(sum_coro) yield channel.unsubscribe(prod_coro)
def __init__(self, node_port=51348, listen_port=0, scheduler_node=None, scheduler_port=51347): if not listen_port: listen_port = node_port self.node_port = node_port self.listen_port = listen_port self.scheduler_port = scheduler_port self.scheduler_ip_addrs = list( filter(lambda ip: bool(ip), [dispy._node_ipaddr(scheduler_node)])) self.listen_udp_coro = asyncoro.Coro(self.listen_udp_proc) self.listen_tcp_coro = asyncoro.Coro(self.listen_tcp_proc) self.sched_udp_coro = asyncoro.Coro(self.sched_udp_proc)
def AppDemo(args): if not args.srv_host or not args.uuidfile: print make_argument_parser().parse_args(['-h']) exit(1) errlog = ErrLog('AppDemo') statlog = StatLog('AppDemo') errworker = WorkerThread( errqueue, errlog, ) errworker.start() statworker = WorkerThread(statqueue, statlog) statworker.start() uulist = [] host = () try: d = args.srv_host.index(':') host = (args.srv_host[:d], int(args.srv_host[d:])) except: host = (args.srv_host, 3478) ulist = read_uuid_file(args.uuidfile) #bind = args.b_count if args.b_count < len(ulist) else len(ulist) bind = 1 tbuf = ulist #ucount = len(ulist) for uid in ulist: asyncoro.Coro(AppSocket, host, uid) time.sleep(0.3)
def DevDemo(args): if not args.srv_host or not args.uuidfile: print make_argument_parser().parse_args(['-h']) exit(1) errlog = ErrLog('DevDemo') statlog = StatLog('DevDemo') et = WorkerThread(errqueue, errlog) et.daemon = True et.start() st = WorkerThread(statqueue, statlog) st.daemon = True st.start() try: d = args.srv_host.index(':') host = (args.srv_host[:d], int(args.srv_host[d:])) except: host = (args.srv_host, 3478) uulist = read_uuid_file(args.uuidfile) for uid in uulist: asyncoro.Coro(DevSocket, host, uid) time.sleep(0.3) while True: cmd = sys.stdin.readline().strip().lower() if cmd == 'exit' or cmd == 'quit': break
def server_proc(host, port, coro=None): global count1 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock = asyncoro.AsyncSocket(sock) try: yield sock.bind((host, port)) except socket.error as msg: print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1] sys.exit() print 'Socket bind complete' sock.listen(1280) print 'Socket now listening' count1 = 0 while True: conn, addr = yield sock.accept() print 'Connected with ' + addr[0] + ':' + str(addr[1]) if count1 == 0: #rt1 = currenttime() rt1 = time.time() print rt1 count1 += 1 asyncoro.Coro(process, conn, addr, sock) sock.close()
def listen_tcp_proc(self, coro=None): coro.set_daemon() tcp_sock = asyncoro.AsyncSocket( socket.socket(socket.AF_INET, socket.SOCK_STREAM)) tcp_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) tcp_sock.bind(('', self.listen_port)) tcp_sock.listen(8) auth_len = len(dispy.auth_code('', '')) def tcp_task(conn, addr, coro=None): conn.settimeout(5) try: msg = yield conn.recvall(auth_len) msg = yield conn.recv_msg() except: logger.debug(traceback.format_exc()) logger.debug('Ignoring invalid TCP message from %s:%s' % (addr[0], addr[1])) raise StopIteration finally: conn.close() logger.debug('Ping message from %s (%s)', addr[0], addr[1]) try: info = asyncoro.unserialize(msg[len('PING:'.encode()):]) if info['version'] != __version__: logger.warning( 'Ignoring %s due to version mismatch: %s / %s', info['ip_addrs'], info['version'], __version__) raise StopIteration # TODO: since dispynetrelay is not aware of computations # closing, if more than one client sends ping, nodes will # respond to different clients self.scheduler_ip_addrs = info['ip_addrs'] + [addr[0]] self.scheduler_port = info['port'] except: logger.debug('Ignoring ping message from %s (%s)', addr[0], addr[1]) logger.debug(traceback.format_exc()) raise StopIteration if info.get('relay', None): logger.debug('Ignoring ping back (from %s)', addr[0]) raise StopIteration logger.debug('relaying ping from %s / %s' % (info['ip_addrs'], addr[0])) if self.node_port == self.listen_port: info[ 'relay'] = 'y' # 'check if this message loops back to self bc_sock = asyncoro.AsyncSocket( socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) bc_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) yield bc_sock.sendto('PING:'.encode() + asyncoro.serialize(info), ('<broadcast>', self.node_port)) bc_sock.close() while 1: conn, addr = yield tcp_sock.accept() asyncoro.Coro(tcp_task, conn, addr)
def client_proc(coro=None): # create channel channel = asyncoro.Channel('sum_prod') # create coroutines to compute sum and product of numbers sent sum_coro = asyncoro.Coro(seqsum) prod_coro = asyncoro.Coro(seqprod) # subscribe coroutines to channel so they receive messages yield channel.subscribe(sum_coro) yield channel.subscribe(prod_coro) # send 4 numbers to channel for x in range(4): r = random.uniform(0.5, 3) channel.send(r) print('sent %f' % r) # send None to indicate end of data channel.send(None) yield channel.unsubscribe(sum_coro) yield channel.unsubscribe(prod_coro)
def server(host, port, coro=None): coro.set_daemon() sock = asyncoro.AsyncSocket(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((host, port)) sock.listen(5000) while True: conn, addr = yield sock.accept() asyncoro.Coro(process, conn)
def init_features(self): """ Load features of the room, eg thread for walking :return: """ print("topkappa") # Fill map with points which aren't availiable self.room_mapping.regenerate_collision_map() # Start thread for room tasks self.cycle = asyncoro.Coro(self.room_tasks.start_cycle)
def __init__(self, ip_addr=None, node_port=51348, listen_port=0, scheduler_node=None, scheduler_port=51347): self.addrinfo = dispy.node_addrinfo(ip_addr) if not listen_port: listen_port = node_port self.node_port = node_port self.listen_port = listen_port self.scheduler_port = scheduler_port self.scheduler_ip_addrs = list( filter(lambda ip: bool(ip), [dispy._node_ipaddr(scheduler_node)])) self.listen_udp_coro = asyncoro.Coro(self.listen_udp_proc) self.listen_tcp_coro = asyncoro.Coro(self.listen_tcp_proc) self.sched_udp_coro = asyncoro.Coro(self.sched_udp_proc) if self.addrinfo[0] == socket.AF_INET: self._broadcast = '<broadcast>' if netifaces: for iface in netifaces.interfaces(): for link in netifaces.ifaddresses(iface).get( netifaces.AF_INET, []): if link['addr'] == self.addrinfo[4][0]: self._broadcast = link.get('broadcast', '<broadcast>') break else: continue break else: # self.sock_family == socket.AF_INET6 self._broadcast = 'ff02::1' addrinfo = socket.getaddrinfo(self._broadcast, None)[0] self.mreq = socket.inet_pton(addrinfo[0], addrinfo[4][0]) self.mreq += struct.pack('@I', self.addrinfo[4][-1]) logger.info('version %s started', dispy._dispy_version)
def EpollServer(errqueue, statqueue, coro=None): coro.set_daemon() mstore.srvsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) mstore.srvsocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) mstore.srvsocket.setsockopt(socket.SOL_SOCKET, socket.TCP_NODELAY, 1) mstore.srvsocket.setsockopt(socket.SOL_SOCKET, socket.TCP_QUICKACK, 1) mstore.srvsocket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) mstore.srvsocket.setsockopt(socket.SOL_SOCKET, socket.SO_DEBUG, 0) mstore.srvsocket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, 6) mstore.srvsocket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, 60) mstore.srvsocket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, 120) mstore.srvsocket = asyncoro.AsyncSocket(mstore.srvsocket) mstore.srvsocket.bind(('0.0.0.0', 3478)) mstore.srvsocket.listen(1024) mstore.errqueue = errqueue mstore.statqueue = statqueue mstore.db_engine = QueryDB().get_engine() mstore.execute = mstore.db_engine.connect().execute [setattr(mstore, x, {}) for x in store] mstore.prefunc = { STUN_METHOD_ALLOCATE: handle_allocate_request, # 小机登录方法 STUN_METHOD_CHECK_USER: handle_chkuser_request, STUN_METHOD_REGISTER: handle_register_request, STUN_METHOD_BINDING: handle_app_login_request # app端登录方法 } #认证后的处理 mstore.postfunc = { STUN_METHOD_CHANNEL_BIND: handle_app_bind_device, # APP 绑定小机的命令 #STUN_METHOD_REFRESH:mstore.handle_refresh_request, STUN_METHOD_MODIFY: handle_modify_bind_item, #修改绑定的信息 STUN_METHOD_DELETE: handle_delete_bind_item, #删除现有的绑定 STUN_METHOD_PULL: handle_app_pull } while True: try: nsock, addr = yield mstore.srvsocket.accept() nf = nsock.fileno() mstore.clients[nf] = nsock mstore.hosts[nf] = addr mstore.requests[nf] = '' asyncoro.Coro(handle_new_accept, nsock) #mstore.gpool.spawn_n(mstore.handle_new_accept,nsock) except (SystemExit, KeyboardInterrupt): print "Server exit" break
def chat(host='localhost', port=1234, coro=None): coro.set_daemon() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock = asyncoro.AsynCoroSocket(sock) sock.bind((host, port)) sock.listen(128) asyncoro.logger.debug('server at %s', str(sock.getsockname())) clients = set() try: while True: conn, addr = yield sock.accept() clients.add(conn) asyncoro.Coro(client_send, clients, conn) except: for client in clients: asyncoro.logger.debug('closing %s', client._fileno) client.shutdown(socket.SHUT_RDWR) client.close() raise
def full_gradient(coro=None): result = 0 while True: msg = yield coro.receive() print('recieved') if msg is None: break result += msg final = result / 4 channel = asyncoro.Channel('gradient_calc') server_coro = asyncoro.Coro(server_proc) yield channel.subscribe(server_coro) channel.send(final) channel.send(None) yield channel.unsubscribe(server_coro)
asyncoro.logger.setLevel(asyncoro.Logger.DEBUG) # host name or IP address of this node is arg1 if len(sys.argv) > 1: host = sys.argv[1] else: host = '127.0.0.1' # port to use is arg2 if len(sys.argv) > 2: port = int(sys.argv[2]) else: port = 9987 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((host, port)) sock.listen(128) asyncoro.logger.info('server at %s', str(sock.getsockname())) server = asyncoro.Coro(server_worker) try: while True: conn, addr = sock.accept() # each connection is handled by a coroutine asyncoro.Coro(client_worker, conn, addr, server) except: pass server.send(('terminate'.encode(), None))
x = x_tilde + 0.9 * (a - x_tilde) return x msg_id = 0 def client_proc(server, n, coro=None): global msg_id a = yield coro.receive() full_grad = grad(x_tilde, range(n)) for x in range(3): yield coro.suspend(random.uniform(0.5, 3)) msg_id += 1 server.send('%s' % (full_grad)) b = yield coro.receive() s_gd = grad(x_tilde, idx) for x in range(3): yield coro.suspend(random.uniform(0.5, 3)) msg_id += 1 print('%s' % sgd) server = asyncoro.Coro(server_proc) for i in range(4): asyncoro.Coro(client_proc, server, i)
asyncoro.logger.setLevel(asyncoro.Logger.DEBUG) # host name or IP address of server is arg1 if len(sys.argv) > 1: host = sys.argv[1] else: host = '' # port used by server is arg2 if len(sys.argv) > 2: port = int(sys.argv[2]) else: port = 1234 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((host, port)) asyncoro.Coro(client_recv, sock) # wrap it with asyncoro's synchronous socket so 'send_msg' can be # used conn = asyncoro.AsyncSocket(sock, blocking=True) if sys.version_info.major > 2: read_input = input else: read_input = raw_input while True: try: line = read_input().strip() if line.lower() in ('quit', 'exit'): break if not line: continue
print('%s: sending %s' % (coro, i)) server.send(i) i += 1 yield coro.sleep(random.uniform(1, 3)) def swap(func_name, file_name, coro, *args, **kwargs): try: exec(open(file_name).read()) func = locals()[func_name] coro.hot_swap(func, *args, **kwargs) except: print('failed to load "%s" from "%s"' % (func_name, file_name)) if __name__ == '__main__': asyncoro.logger.setLevel(asyncoro.Logger.DEBUG) server = asyncoro.Coro(server_proc) client = asyncoro.Coro(client_proc, server) if sys.version_info.major > 2: read_input = input else: read_input = raw_input while True: try: cmd = read_input().strip().lower() if cmd.startswith('client'): swap('client_proc2', 'hotswap_funcs.py', client, server) elif cmd.startswith('server'): swap('server_proc2', 'hotswap_funcs.py', server, random.choice(['log', 'sqrt'])) elif cmd in ('quit', 'exit'): break except:
sender.terminate() break print(line.decode()) def client_send(conn, coro=None): thread_pool = asyncoro.AsyncThreadPool(1) if sys.version_info.major > 2: read_input = input else: read_input = raw_input while True: try: line = yield thread_pool.async_task(read_input) line = line.strip() if line in ('quit', 'exit'): break except: break yield conn.send_msg(line.encode()) if __name__ == '__main__': sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(('localhost', 1234)) conn = asyncoro.AsynCoroSocket(sock) sender = asyncoro.Coro(client_send, conn) recvr = asyncoro.Coro(client_recv, conn, sender) sender.value() recvr.terminate()
#!/usr/bin/env python # client program for sending requests to server (tut_sock_server.py) # with sockets (asynchronous network programming); # see http://asyncoro.sourceforge.net/tutorial.html for details. import sys, socket, random import asyncoro def client(host, port, n, coro=None): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock = asyncoro.AsyncSocket(sock) yield sock.connect((host, port)) msg = '%d: ' % n + '-' * random.randint(100, 300) + '/' msg = msg.encode() yield sock.sendall(msg) sock.close() # run 10 client coroutines n = 10 if len(sys.argv) < 2 else int(sys.argv[1]) for i in range(n): asyncoro.Coro(client, '127.0.0.1', 8010, i)
fin.close() pipe.stdin.close() def read_proc(pipe, coro=None): # output from sha1sum is small, so read until EOF data = yield pipe.stdout.read() pipe.stdout.close() raise StopIteration(data) if platform.system() == 'Windows': # asyncfile.Popen must be used instead of subprocess.Popen pipe = asyncoro.asyncfile.Popen([r'\cygwin64\bin\sha1sum.exe'], stdin=subprocess.PIPE, stdout=subprocess.PIPE) else: pipe = subprocess.Popen(['sha1sum'], stdin=subprocess.PIPE, stdout=subprocess.PIPE) async_pipe = asyncoro.asyncfile.AsyncPipe(pipe) reader = asyncoro.Coro(read_proc, async_pipe) writer = asyncoro.Coro(write_proc, open(input), async_pipe) stdout = yield reader.finish() print(' feeder sha1sum: %s' % stdout) # asyncoro.logger.setLevel(asyncoro.Logger.DEBUG) # simpler version using 'communicate' coro = asyncoro.Coro(communicate, sys.argv[1] if len(sys.argv) > 1 else sys.argv[0]) coro.value() # wait for it to finish # alternate version with custom read and write processes asyncoro.Coro(custom_feeder, sys.argv[1] if len(sys.argv) > 1 else sys.argv[0])
def seqprod(coro=None): # compute product of numbers received over channel result = 1 while True: msg = yield coro.receive() if msg is None: break result *= msg print('prod: %f' % result) def client_proc(coro=None): # create channel channel = asyncoro.Channel('sum_prod') # create coroutines to compute sum and product of numbers sent sum_coro = asyncoro.Coro(seqsum) prod_coro = asyncoro.Coro(seqprod) # subscribe coroutines to channel so they receive messages yield channel.subscribe(sum_coro) yield channel.subscribe(prod_coro) # send 4 numbers to channel for x in range(4): r = random.uniform(0.5, 3) channel.send(r) print('sent %f' % r) # send None to indicate end of data channel.send(None) yield channel.unsubscribe(sum_coro) yield channel.unsubscribe(prod_coro) asyncoro.Coro(client_proc)
div2[j] = div2[j] + (div1[i]-counter) else: div2[j] = div2[j] - (counter-div1[i]) div3.append(0) for z in range(0,len(div2)): if z == 0: div3.append(div2[0]) else: div3.append(div3[z]+div2[z]) print div2 print div3 for n in xrange(0, numconn): if n%numpaths == 0: asyncoro.Coro(client, ip1, port, n) print "sending", n if n+1 < numconn: asyncoro.Coro(client, ip2, port, n+1) print "sending", n+1 if n+2 < numconn: asyncoro.Coro(client, ip3, port, n+2) print "sending", n+2 port +=1
clients = set() try: while True: conn, addr = yield sock.accept() clients.add(conn) asyncoro.Coro(client_send, clients, conn) except: for client in clients: asyncoro.logger.debug('closing %s', client._fileno) client.shutdown(socket.SHUT_RDWR) client.close() raise if __name__ == '__main__': asyncoro.logger.setLevel(asyncoro.Logger.debug) asyncoro.Coro(chat) if sys.version_info.major > 2: read_input = input else: read_input = raw_input while True: try: cmd = read_input() if cmd.strip().lower() in ('quit', 'exit'): break except: break
asyncoro.logger.setLevel(asyncoro.Logger.DEBUG) # host name or IP address of server is arg1 if len(sys.argv) > 1: host = sys.argv[1] else: host = '127.0.0.1' # port used by server is arg2 if len(sys.argv) > 2: port = int(sys.argv[2]) else: port = 9987 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((host, port)) asyncoro.Coro(client_worker, sock) # wrap it with asyncoro's synchronous socket so 'send_msg' can be # used conn = asyncoro.AsyncSocket(sock, blocking=True) if sys.version_info.major > 2: read_input = input else: read_input = raw_input("raw_input: ") while True: try: line = read_input().strip() if line.lower() in ('quit', 'exit'): break if not line:
def server_proc(host, port, coro=None): global count1 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock = asyncoro.AsyncSocket(sock) try: yield sock.bind((host, port)) except socket.error as msg: print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1] sys.exit() print 'Socket bind complete' sock.listen(1280) print 'Socket now listening' count1 = 0 while True: conn, addr = yield sock.accept() print 'Connected with ' + addr[0] + ':' + str(addr[1]) if count1 == 0: #rt1 = currenttime() rt1 = time.time() print rt1 count1 += 1 asyncoro.Coro(process, conn, addr, sock) sock.close() asyncoro.Coro(server_proc, '', 8012)
if data[-1] == eol: break conn.close() n += 1 print('recieved: %s' % data) def server(host, port, coro=None): coro.set_daemon() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock = asyncoro.AsyncSocket(sock) # sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((host, port)) sock.listen(128) while True: conn, addr = yield sock.accept() asyncoro.Coro(process, conn) n = 0 asyncoro.Coro(server, '127.0.0.1', 8010) if sys.version_info.major > 2: read_input = input else: read_input = raw_input while True: cmd = read_input().strip().lower() if cmd == 'exit' or cmd == 'quit': break print('n = %d' % n)
CREATE TABLE account_status ( uname character varying(255) NOT NULL , is_login boolean NOT NULL DEFAULT false, last_login_time timestamp with time zone DEFAULT now(), chost bigint[] NOT NULL DEFAULT '{0,0}'::bigint[], CONSTRAINT account_status_uname_fkey FOREIGN KEY (uname) REFERENCES account (uname) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ) ''') errqueue = Queue() statqueue = Queue() errlog = ErrLog('epoll_mt_srv') statlog = StatLog('epoll_mt_srv') errworker = WorkerThread( errqueue, errlog, ) errworker.daemon = True errworker.start() statworker = WorkerThread(statqueue, statlog) statworker.daemon = True statworker.start() srv = asyncoro.Coro(EpollServer, errqueue, statqueue) while True: cmd = sys.stdin.readline().strip().lower() if cmd == 'exit' or cmd == 'quit': break
#!/usr/bin/env python # program for creating coroutines (asynchronous concurrent # programming); see http://asyncoro.sourceforge.net/tutorial.html for # details. import sys, random, time import asyncoro def coro_proc(n, coro=None): s = random.uniform(0.5, 3) print('%f: coroutine %d sleeping for %f seconds' % (time.time(), n, s)) yield coro.sleep(s) print('%f: coroutine %d terminating' % (time.time(), n)) # create 10 clients for i in range(10): asyncoro.Coro(coro_proc, i)
if __name__ == '__main__': asyncoro.logger.setLevel(logging.DEBUG) # host name or IP address of this node is arg1 if len(sys.argv) > 1: host = sys.argv[1] else: host = '' # port to use is arg2 if len(sys.argv) > 2: port = int(sys.argv[2]) else: port = 1234 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((host, port)) sock.listen(128) asyncoro.logger.info('server at %s', str(sock.getsockname())) server = asyncoro.Coro(server_proc) try: while True: conn, addr = sock.accept() # each connection is handled by a coroutine asyncoro.Coro(client_proc, conn, addr, server) except KeyboardInterrupt: pass server.send(('terminate', None))