def main():
global SERVER
try:
loop = trollius.get_event_loop()
coro = trollius.start_server(
handle_client,
host=None,
port=pagure.APP.config['EVENTSOURCE_PORT'],
loop=loop)
SERVER = loop.run_until_complete(coro)
log.info('Serving server at {}'.format(SERVER.sockets[0].getsockname()))
if pagure.APP.config.get('EV_STATS_PORT'):
stats_coro = trollius.start_server(
stats,
host=None,
port=pagure.APP.config.get('EV_STATS_PORT'),
loop=loop)
stats_server = loop.run_until_complete(stats_coro)
log.info('Serving stats at {}'.format(
stats_server.sockets[0].getsockname()))
loop.run_forever()
except KeyboardInterrupt:
pass
except trollius.ConnectionResetError:
pass
# Close the server
SERVER.close()
if pagure.APP.config.get('EV_STATS_PORT'):
stats_server.close()
log.info("End Connection")
loop.run_until_complete(server.wait_closed())
loop.close()
log.info("End")
def test_basic_requests(self):
proxy_http_client = Client(recorder=DebugPrintRecorder())
proxy_server = HTTPProxyServer(proxy_http_client)
proxy_socket, proxy_port = tornado.testing.bind_unused_port()
yield From(trollius.start_server(proxy_server, sock=proxy_socket))
connection_pool = HTTPProxyConnectionPool(('127.0.0.1', proxy_port))
http_client = Client(connection_pool=connection_pool,
recorder=DebugPrintRecorder())
for dummy in range(3):
with http_client.session() as session:
response = yield From(session.fetch(Request(self.get_url('/'))))
self.assertEqual(200, response.status_code)
file = io.BytesIO()
yield From(session.read_content(file=file))
data = file.getvalue().decode('ascii', 'replace')
self.assertTrue(data.endswith('</html>'))
with http_client.session() as session:
response = yield From(session.fetch(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.read_content(file=file))
data = file.getvalue().decode('ascii', 'replace')
self.assertEqual('Error', data)
def main():
global SERVER
try:
loop = trollius.get_event_loop()
coro = trollius.start_server(
handle_client,
host=None,
port=webapp.APP.config['EVENTSOURCE_PORT'],
loop=loop)
SERVER = loop.run_until_complete(coro)
log.info('Serving server at {}'.format(
SERVER.sockets[0].getsockname()))
loop.run_forever()
except KeyboardInterrupt:
pass
except trollius.ConnectionResetError as err:
log.exception("ERROR: ConnectionResetError in main")
except Exception:
log.exception("ERROR: Exception in main")
finally:
# Close the server
SERVER.close()
log.info("End Connection")
loop.run_until_complete(SERVER.wait_closed())
loop.close()
log.info("End")
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 setUp(self):
AsyncTestCase.setUp(self)
self.server = MockFTPServer()
self.sock = socket.socket()
self.sock.bind(('127.0.0.1', 0))
self.server_handle = self.event_loop.run_until_complete(
trollius.start_server(self.server, sock=self.sock)
)
def setUp(self):
AsyncTestCase.setUp(self)
self.server = MockFTPServer()
self.sock = socket.socket()
self.sock.bind(('127.0.0.1', 0))
self.server_handle = self.event_loop.run_until_complete(
trollius.start_server(self.server, sock=self.sock)
)
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 start_callback(self):
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
sock.close()
self.server = self.loop.run_until_complete(
asyncio.start_server(self.handle_client_callback,
host=addr[0], port=addr[1],
loop=self.loop))
return addr
def start_callback(self):
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
sock.close()
self.server = self.loop.run_until_complete(
asyncio.start_server(self.handle_client_callback,
host=addr[0],
port=addr[1],
loop=self.loop))
return addr
def listen_pickle(self):
"""
Listen for pickles over tcp
"""
@trollius.coroutine
def handle_pickles(reader, writer):
chunk = []
while True:
self.check_if_parent_is_alive()
try:
header = yield From(reader.readexactly(calcsize('!I')))
length, = Struct('!I').unpack(header)
body = yield From(reader.readexactly(length))
# Iterate and chunk each individual datapoint
for bunch in self.gen_unpickle(body):
for metric in bunch:
chunk.append(metric)
# Queue the chunk and empty the variable
if len(chunk) > settings.CHUNK_SIZE:
try:
self.q.put(list(chunk), block=False)
chunk[:] = []
# Drop chunk if queue is full
except Full:
logger.info('queue is full, dropping datapoints')
chunk[:] = []
except Exception as e:
logger.exception('Processing metrics')
raise
loop = trollius.get_event_loop()
server = loop.run_until_complete(trollius.start_server(handle_pickles,
self.ip, self.port, loop=loop))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close the server
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
def test_no_content(self):
http_client = Client(recorder=DebugPrintRecorder())
proxy = HTTPProxyServer(http_client)
proxy_socket, proxy_port = tornado.testing.bind_unused_port()
yield From(trollius.start_server(proxy, sock=proxy_socket))
_logger.debug('Proxy on port {0}'.format(proxy_port))
test_client = tornado.curl_httpclient.CurlAsyncHTTPClient()
request = tornado.httpclient.HTTPRequest(self.get_url('/no_content'),
proxy_host='localhost',
proxy_port=proxy_port)
response = yield From(
tornado_future_adapter(test_client.fetch(request)))
self.assertEqual(204, response.code)
def main():
try:
loop = trollius.get_event_loop()
coro = trollius.start_server(
handle_client, host=None, port=8080, loop=loop)
server = loop.run_until_complete(coro)
print('Serving on {}'.format(server.sockets[0].getsockname()))
loop.run_forever()
except KeyboardInterrupt:
pass
except trollius.ConnectionResetError:
pass
# Close the server
server.close()
log.info("End Connection")
loop.run_until_complete(server.wait_closed())
loop.close()
log.info("End")
def test_no_content(self):
http_client = Client(recorder=DebugPrintRecorder())
proxy = HTTPProxyServer(http_client)
proxy_socket, proxy_port = tornado.testing.bind_unused_port()
yield From(trollius.start_server(proxy, sock=proxy_socket))
_logger.debug('Proxy on port {0}'.format(proxy_port))
test_client = tornado.curl_httpclient.CurlAsyncHTTPClient()
request = tornado.httpclient.HTTPRequest(
self.get_url('/no_content'),
proxy_host='localhost',
proxy_port=proxy_port
)
response = yield From(tornado_future_adapter(test_client.fetch(request)))
self.assertEqual(204, response.code)
def test_basic(self):
cookie_jar = BetterMozillaCookieJar()
policy = DeFactoCookiePolicy(cookie_jar=cookie_jar)
cookie_jar.set_policy(policy)
cookie_jar_wrapper = CookieJarWrapper(cookie_jar)
http_client = Client(recorder=DebugPrintRecorder())
proxy = HTTPProxyServer(http_client)
proxy_socket, proxy_port = tornado.testing.bind_unused_port()
def request_callback(request):
print(request)
cookie_jar_wrapper.add_cookie_header(request)
def pre_response_callback(request, response):
print(response)
cookie_jar_wrapper.extract_cookies(response, request)
proxy.request_callback = request_callback
proxy.pre_response_callback = pre_response_callback
yield From(trollius.start_server(proxy, sock=proxy_socket))
_logger.debug('Proxy on port {0}'.format(proxy_port))
test_client = tornado.curl_httpclient.CurlAsyncHTTPClient()
request = tornado.httpclient.HTTPRequest(
self.get_url('/'),
proxy_host='localhost',
proxy_port=proxy_port,
)
response = yield From(
tornado_future_adapter(test_client.fetch(request)))
self.assertEqual(200, response.code)
self.assertIn(b'Hello!', response.body)
cookies = tuple(cookie_jar)
self.assertEqual('hi', cookies[0].name)
self.assertEqual('hello', cookies[0].value)
def _cmd_pasv(self):
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
def data_server_cb(data_reader, data_writer):
self.data_reader = data_reader
self.data_writer = data_writer
self.data_server = yield From(
trollius.start_server(data_server_cb, sock=sock))
port = sock.getsockname()[1]
big_port_num = port >> 8
small_port_num = port & 0xff
if 'bad_pasv_addr' in self.evil_flags:
self.writer.write(b'227 Now passive mode (127,0,0,WOW,SO,UNEXPECT)\r\n')
else:
self.writer.write('227 Now passive mode (127,0,0,1,{},{})\r\n'
.format(big_port_num, small_port_num)
.encode('utf-8'))
def _cmd_pasv(self):
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
def data_server_cb(data_reader, data_writer):
self.data_reader = data_reader
self.data_writer = data_writer
self.data_server = yield From(
trollius.start_server(data_server_cb, sock=sock))
port = sock.getsockname()[1]
big_port_num = port >> 8
small_port_num = port & 0xff
if 'bad_pasv_addr' in self.evil_flags:
self.writer.write(b'227 Now passive mode (127,0,0,WOW,SO,UNEXPECT)\r\n')
else:
self.writer.write('227 Now passive mode (127,0,0,1,{},{})\r\n'
.format(big_port_num, small_port_num)
.encode('utf-8'))
def test_basic(self):
cookie_jar = BetterMozillaCookieJar()
policy = DeFactoCookiePolicy(cookie_jar=cookie_jar)
cookie_jar.set_policy(policy)
cookie_jar_wrapper = CookieJarWrapper(cookie_jar)
http_client = Client(recorder=DebugPrintRecorder())
proxy = HTTPProxyServer(http_client)
proxy_socket, proxy_port = tornado.testing.bind_unused_port()
def request_callback(request):
print(request)
cookie_jar_wrapper.add_cookie_header(request)
def pre_response_callback(request, response):
print(response)
cookie_jar_wrapper.extract_cookies(response, request)
proxy.request_callback = request_callback
proxy.pre_response_callback = pre_response_callback
yield From(trollius.start_server(proxy, sock=proxy_socket))
_logger.debug('Proxy on port {0}'.format(proxy_port))
test_client = tornado.curl_httpclient.CurlAsyncHTTPClient()
request = tornado.httpclient.HTTPRequest(
self.get_url('/'),
proxy_host='localhost',
proxy_port=proxy_port,
)
response = yield From(tornado_future_adapter(test_client.fetch(request)))
self.assertEqual(200, response.code)
self.assertIn(b'Hello!', response.body)
cookies = tuple(cookie_jar)
self.assertEqual('hi', cookies[0].name)
self.assertEqual('hello', cookies[0].value)
loop = trollius.get_event_loop()
reader = trollius.StreamReader(loop=loop)
protocol = trollius.StreamReaderProtocol(reader, loop=loop)
transport, dummy = yield From(
loop.create_connection(lambda: protocol, sock=ssl_socket))
writer = trollius.StreamWriter(transport, protocol, reader, loop)
self._reader = reader
self._writer = writer
def _reject_request(self, message='Request Not Allowed'):
'''Send HTTP 501 and close the connection.'''
self._writer.write('HTTP/1.1 501 {}\r\n'.format(message).encode(
'ascii', 'replace'))
self._writer.write(b'\r\n')
self._writer.close()
if __name__ == '__main__':
from wpull.http.client import Client
logging.basicConfig(level=logging.DEBUG)
http_client = Client(recorder=ProgressRecorder())
proxy = HTTPProxyServer(http_client)
trollius.get_event_loop().run_until_complete(
trollius.start_server(proxy, port=8888))
trollius.get_event_loop().run_forever()
def echo_server():
yield From(asyncio.start_server(handle_connection, 'localhost', 8000))
message = data.decode()
addr = writer.get_extra_info('peername')
print("Received %r from %r" % (message, addr))
print("Send: %r" % message)
writer.write(message.encode())
yield trollius.From(writer.drain())
print("Close the client socket")
writer.close()
h = PrintHandler()
logging.getLogger("trollius").addHandler(h)
loop = trollius.get_event_loop()
coro = trollius.start_server(handle_echo, '0.0.0.0', 4567, 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()
def echo_server():
yield From(asyncio.start_server(handle_connection, 'localhost', 8000))
def setUp(self):
AsyncTestCase.setUp(self)
self.server = MockFTPServer()
self.sock = socket.socket()
self.sock.bind(('127.0.0.1', 0))
self.server_handle = self.event_loop.run_until_complete(
trollius.start_server(self.server, sock=self.sock)
)
def tearDown(self):
self.server_handle.close()
AsyncTestCase.tearDown(self)
def get_url(self, path, username='', password=''):
if username or password:
return 'ftp://{username}@{password}:127.0.0.1:{port}{path}' \
.format(path=path, port=self.server_port(),
username=username, password=password
)
else:
return 'ftp://127.0.0.1:{port}{path}'.format(
path=path, port=self.server_port())
if __name__ == '__main__':
server = MockFTPServer()
handle = trollius.get_event_loop().run_until_complete(
trollius.start_server(server, port=8020))
trollius.get_event_loop().run_forever()
def setUp(self):
AsyncTestCase.setUp(self)
self.server = MockFTPServer()
self.sock = socket.socket()
self.sock.bind(('127.0.0.1', 0))
self.server_handle = self.event_loop.run_until_complete(
trollius.start_server(self.server, sock=self.sock)
)
def tearDown(self):
self.server_handle.close()
AsyncTestCase.tearDown(self)
def get_url(self, path, username='', password=''):
if username or password:
return 'ftp://{username}@{password}:127.0.0.1:{port}{path}' \
.format(path=path, port=self.server_port(),
username=username, password=password
)
else:
return 'ftp://127.0.0.1:{port}{path}'.format(
path=path, port=self.server_port())
if __name__ == '__main__':
server = MockFTPServer()
handle = trollius.get_event_loop().run_until_complete(
trollius.start_server(server, port=8020))
trollius.get_event_loop().run_forever()
def run_slave(args):
server = yield From(trollius.start_server(slave_connection, port=args.port))
yield From(server.wait_closed())
raise trollius.ConnectionAbortedError('Could not start TLS')
loop = trollius.get_event_loop()
reader = trollius.StreamReader(loop=loop)
protocol = trollius.StreamReaderProtocol(reader, loop=loop)
transport, dummy = yield From(loop.create_connection(
lambda: protocol, sock=ssl_socket))
writer = trollius.StreamWriter(transport, protocol, reader, loop)
self._reader = reader
self._writer = writer
def _reject_request(self, message='Request Not Allowed'):
'''Send HTTP 501 and close the connection.'''
self._writer.write(
'HTTP/1.1 501 {}\r\n'.format(message).encode('ascii', 'replace')
)
self._writer.write(b'\r\n')
self._writer.close()
if __name__ == '__main__':
from wpull.http.client import Client
logging.basicConfig(level=logging.DEBUG)
http_client = Client(recorder=ProgressRecorder())
proxy = HTTPProxyServer(http_client)
trollius.get_event_loop().run_until_complete(trollius.start_server(proxy, port=8888))
trollius.get_event_loop().run_forever()
