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