def test_max_content_length(self, max_length): # start server port = get_free_tcp_port() host = "127.0.0.1" thread = run_server( port=port, bind_address=host, asynchronous=True, max_content_length=max_length, handler=lambda *args: None, ) wait_for_port_open(port) # test successful request result = requests.post(f"http://localhost:{port}", data="0" * max_length) assert result.status_code == 200 # test unsuccessful request result = requests.post(f"http://localhost:{port}", data="0" * (max_length + 1)) assert result.status_code == 413 # payload too large # clean up thread.stop() wait_for_port_closed(port)
def start_proxy_server(port, bind_address=None, forward_url=None, use_ssl=None, update_listener=None, quiet=False, params=None, asynchronous=True): bind_address = bind_address if bind_address else BIND_HOST def handler(request, data): parsed_url = urlparse(request.url) path_with_params = path_from_url(request.url) method = request.method headers = request.headers headers[HEADER_LOCALSTACK_REQUEST_URL] = str(request.url) request_handler = Mock() request_handler.proxy = Mock() request_handler.proxy.port = port response = modify_and_forward(method=method, path=path_with_params, data_bytes=data, headers=headers, forward_base_url=forward_url, listeners=[update_listener], request_handler=None, client_address=request.remote_addr, server_address=parsed_url.netloc) return response ssl_creds = (None, None) if use_ssl: _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert(serial_number=port) ssl_creds = (cert_file_name, key_file_name) return http2_server.run_server(port, bind_address, handler=handler, asynchronous=asynchronous, ssl_creds=ssl_creds)
def run_proxy_server_http2(port, listener=None, forward_url=None, asynchronous=True, use_ssl=None): def handler(request, data): parsed_url = urlparse(request.url) path_with_params = path_from_url(request.url) method = request.method headers = request.headers class T: pass request_handler = T() request_handler.proxy = T() request_handler.proxy.port = port response = modify_and_forward(method=method, path=path_with_params, data_bytes=data, headers=headers, forward_base_url=forward_url, listeners=[listener], request_handler=None, client_address=request.remote_addr, server_address=parsed_url.netloc) return response ssl_creds = (None, None) if use_ssl: _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert(serial_number=port) ssl_creds = (cert_file_name, key_file_name) return http2_server.run_server(port, handler=handler, asynchronous=asynchronous, ssl_creds=ssl_creds)
def start_proxy_server( port, bind_address=None, forward_url=None, use_ssl=None, update_listener=None, quiet=False, params=None, # TODO: not being used - should be investigated/removed asynchronous=True, check_port=True, ): bind_address = bind_address if bind_address else BIND_HOST def handler(request, data): parsed_url = urlparse(request.url) path_with_params = path_from_url(request.url) method = request.method headers = request.headers headers[HEADER_LOCALSTACK_REQUEST_URL] = str(request.url) response = modify_and_forward( method=method, path=path_with_params, data_bytes=data, headers=headers, forward_base_url=forward_url, listeners=[update_listener], client_address=request.remote_addr, server_address=parsed_url.netloc, ) return response ssl_creds = (None, None) if use_ssl: install_predefined_cert_if_available() _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert( serial_number=port) ssl_creds = (cert_file_name, key_file_name) result = http2_server.run_server(port, bind_address, handler=handler, asynchronous=asynchronous, ssl_creds=ssl_creds) if asynchronous and check_port: wait_for_port_open(port, sleep_time=0.2, retries=12) return result
def test_run_and_stop_server(self): port = get_free_tcp_port() host = "127.0.0.1" LOG.info("%.2f starting server on port %d", time.time(), port) thread = run_server(port=port, bind_address=host, asynchronous=True) try: url = f"http://{host}:{port}" assert poll_condition( lambda: is_port_open(url, http_path="/"), timeout=15), f"gave up waiting for port {port}" finally: LOG.info("%.2f stopping server on port %d", time.time(), port) thread.stop() LOG.info("%.2f waiting on server to shut down", time.time()) thread.join(timeout=15) assert not is_port_open(port), "port is still open after stop" LOG.info("%.2f port stopped %d", time.time(), port)
def test_run_and_stop_server_from_different_threads(self): port = get_free_tcp_port() host = "127.0.0.1" LOG.info("%.2f starting server on port %d", time.time(), port) thread = run_server(port=port, bind_address=host, asynchronous=True) try: url = f"http://{host}:{port}" self.assertTrue( poll_condition(lambda: is_port_open(url, http_path="/"), timeout=15), "gave up waiting for port %d " % port, ) finally: LOG.info("%.2f stopping server on port %d", time.time(), port) threading.Thread(target=thread.stop).start() LOG.info("%.2f waiting on server to shut down", time.time()) thread.join(timeout=15) self.assertFalse(is_port_open(port), "port is still open after stop") LOG.info("%.2f port stopped %d", time.time(), port)
def http_server(handler, host="127.0.0.1", port=None) -> str: """ Create a temporary http server on a random port (or the specified port) with the given handler for the duration of the context manager. Example usage: def handler(request, data): print(request.method, request.path, data) with testutil.http_server(handler) as url: requests.post(url, json={"message": "hello"}) """ from localstack.utils.server.http2_server import run_server host = host port = port or get_free_tcp_port() thread = run_server(port, [host], handler=handler, asynchronous=True) url = f"http://{host}:{port}" assert poll_condition(lambda: is_port_open(port), timeout=5), f"server on port {port} did not start" yield url thread.stop()
def start_proxy_server( port, bind_address: Union[str, List[str]] = None, forward_url=None, use_ssl=None, update_listener: Optional[Union[ProxyListener, List[ProxyListener]]] = None, quiet=False, asynchronous=True, check_port=True, max_content_length: int = None, send_timeout: int = None, ): if bind_address: bind_addresses = bind_address if isinstance(bind_address, List) else [bind_address] else: bind_addresses = [BIND_HOST] if update_listener is None: listeners = [] elif isinstance(update_listener, list): listeners = update_listener else: listeners = [update_listener] def handler(request, data): parsed_url = urlparse(request.url) path_with_params = get_full_raw_path(request) method = request.method headers = request.headers headers[HEADER_LOCALSTACK_REQUEST_URL] = str(request.url) headers[HEADER_LOCALSTACK_AUTHORIZATION] = headers.get( "Authorization", "") return modify_and_forward( method=method, path=path_with_params, data_bytes=data, headers=headers, forward_base_url=forward_url, listeners=listeners, client_address=request.remote_addr, server_address=parsed_url.netloc, ) ssl_creds = (None, None) if use_ssl: install_predefined_cert_if_available() _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert( serial_number=port) ssl_creds = (cert_file_name, key_file_name) result = http2_server.run_server( port, bind_addresses=bind_addresses, handler=handler, asynchronous=asynchronous, ssl_creds=ssl_creds, max_content_length=max_content_length, send_timeout=send_timeout, ) if asynchronous and check_port: wait_for_port_open(port, sleep_time=0.2, retries=12) return result