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