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
