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