def convert_response(result: RequestsResponse) -> Response:
"""
Utility function to convert a response for the requests library to our internal (Werkzeug based) Response object.
"""
if result is None:
return Response()
if isinstance(result, LambdaResponse):
headers = Headers(dict(result.headers))
for k, values in result.multi_value_headers.items():
for value in values:
headers.add(k, value)
else:
headers = dict(result.headers)
response = Response(status=result.status_code, headers=headers)
if isinstance(result.content, dict):
response.set_json(result.content)
elif isinstance(result.content, (str, bytes)):
response.data = result.content
else:
raise ValueError(f"Unhandled content type {type(result.content)}")
return response
def on_post(self, request: Request):
data = request.get_json(True, True)
if not data:
return Response("invalid request", 400)
# backdoor API to support restarting the instance
if data.get("action") in ["kill", "restart"]:
terminate_all_processes_in_docker()
SHUTDOWN_INFRA.set()
return Response("ok", 200)
def test_composite_handler_exception_calls_outer_exception_handlers(self):
def inner1(_chain: HandlerChain, request: RequestContext,
response: Response):
raise ValueError()
inner2 = mock.MagicMock()
outer1 = mock.MagicMock()
outer2 = mock.MagicMock()
exception_handler = mock.MagicMock()
response1 = mock.MagicMock()
chain = HandlerChain()
composite = CompositeHandler()
composite.handlers.append(inner1)
composite.handlers.append(inner2)
chain.request_handlers.append(outer1)
chain.request_handlers.append(composite)
chain.request_handlers.append(outer2)
chain.exception_handlers.append(exception_handler)
chain.response_handlers.append(response1)
chain.handle(RequestContext(), Response())
outer1.assert_called_once()
outer2.assert_not_called()
inner2.assert_not_called()
exception_handler.assert_called_once()
response1.assert_called_once()
def on_get(self, request):
from localstack.utils.aws.aws_stack import get_valid_regions
deploy_html_file = os.path.join(constants.MODULE_MAIN_PATH, "services",
"cloudformation", "deploy.html")
deploy_html = load_file(deploy_html_file)
req_params = request.values
params = {
"stackName": "stack1",
"templateBody": "{}",
"errorMessage": "''",
"regions": json.dumps(sorted(list(get_valid_regions()))),
}
download_url = req_params.get("templateURL")
if download_url:
try:
LOG.debug(
"Attempting to download CloudFormation template URL: %s",
download_url)
template_body = requests.get(download_url).text
template_body = parse_json_or_yaml(template_body)
params["templateBody"] = json.dumps(template_body)
except Exception as e:
msg = f"Unable to download CloudFormation template URL: {e}"
LOG.info(msg)
params["errorMessage"] = json.dumps(msg.replace("\n", " - "))
# using simple string replacement here, for simplicity (could be replaced with, e.g., jinja)
for key, value in params.items():
deploy_html = deploy_html.replace(f"<{key}>", value)
return Response(deploy_html, mimetype="text/html")
def test_composite_handler_stops_handler_chain(self):
def inner1(_chain: HandlerChain, request: RequestContext,
response: Response):
_chain.stop()
inner2 = mock.MagicMock()
outer1 = mock.MagicMock()
outer2 = mock.MagicMock()
response1 = mock.MagicMock()
chain = HandlerChain()
composite = CompositeHandler()
composite.handlers.append(inner1)
composite.handlers.append(inner2)
chain.request_handlers.append(outer1)
chain.request_handlers.append(composite)
chain.request_handlers.append(outer2)
chain.response_handlers.append(response1)
chain.handle(RequestContext(), Response())
outer1.assert_called_once()
outer2.assert_not_called()
inner2.assert_not_called()
response1.assert_called_once()
def __call__(self, environ: "WSGIEnvironment",
start_response: "StartResponse") -> Iterable[bytes]:
# create request from environment
LOG.debug(
"[%s] %s %s%s",
threading.current_thread().name,
environ["REQUEST_METHOD"],
environ.get("HTTP_HOST"),
environ["RAW_URI"],
)
request = Request(environ)
if "asgi.headers" in environ:
# restores raw headers from ASGI scope, which allows dashes in header keys
# see https://github.com/pallets/werkzeug/issues/940
request.headers = Headers(environ["asgi.headers"].raw_items())
else:
# by default, werkzeug requests from environ are immutable
request.headers = Headers(request.headers)
# prepare response
response = Response()
self.gateway.process(request, response)
return response(environ, start_response)
def invoke_rest_api(self, request: Request,
**url_params: Dict[str, Any]) -> Response:
if not url_params["api_id"] in API_REGIONS:
return Response(status=404)
invocation_context = to_invocation_context(request, url_params)
result = invoke_rest_api_from_request(invocation_context)
if result is not None:
return convert_response(result)
raise NotFound()
def test_composite_handler_continues_handler_chain(self):
inner1 = mock.MagicMock()
inner2 = mock.MagicMock()
outer1 = mock.MagicMock()
outer2 = mock.MagicMock()
response1 = mock.MagicMock()
chain = HandlerChain()
composite = CompositeHandler()
composite.handlers.append(inner1)
composite.handlers.append(inner2)
chain.request_handlers.append(outer1)
chain.request_handlers.append(composite)
chain.request_handlers.append(outer2)
chain.response_handlers.append(response1)
chain.handle(RequestContext(), Response())
outer1.assert_called_once()
outer2.assert_called_once()
inner1.assert_called_once()
inner2.assert_called_once()
response1.assert_called_once()
def handle_request(request: Request, region: str) -> Response:
if request.is_json:
# TODO: the response should be sent as JSON response
raise NotImplementedError
try:
response, operation = try_call_sqs(request, region)
del response["ResponseMetadata"]
return serializer.serialize_to_response(response, operation)
except UnknownOperationException:
return Response("<UnknownOperationException/>", 404)
except CommonServiceException as e:
# use a dummy operation for the serialization to work
op = service.operation_model(service.operation_names[0])
return serializer.serialize_error_to_response(e, op)
except Exception as e:
LOG.exception("exception")
op = service.operation_model(service.operation_names[0])
return serializer.serialize_error_to_response(
CommonServiceException(
"InternalError", f"An internal error ocurred: {e}", status_code=500
),
op,
)
def handler(_request: Request, arg1) -> Response: # invalid signature
return Response("ok")
def echo_json(request: Request, args) -> Response:
response = Response()
response.set_json(request.json)
return response
def handler_foo(_request: Request) -> Response:
return Response("ok")
def handler_bar(_request: Request, bar, baz) -> Dict[str, any]:
response = Response()
response.set_json({"bar": bar, "baz": baz})
return response
def user(self, _: Request, args):
# should be inherited
assert not args
return Response("user")
def user(_: Request, args):
assert not args
return Response("user")
def ep_all(_: Request, args) -> Response:
response = Response()
response.set_json(dict(method="all", **args))
return response
def ep_index2(_: Request, args) -> Response:
response = Response()
response.set_json(dict(method="2", **args))
return response
def index(_: Request, args) -> Response:
response = Response()
response.set_json(args)
return response
def users(_: Request, args) -> Response:
response = Response()
response.set_json(args)
return response
def __call__(self, request: Request, endpoint: E,
args: RequestArguments) -> Response:
self.requests.append((request, endpoint, args))
return Response()
def user_id(self, _: Request, args):
assert args
return Response(f"{args['user_id']}")
def index(_: Request, args) -> Response:
return Response(b"index")
def users(_: Request, args) -> Response:
return Response(b"users")
def noop(*args, **kwargs):
"""Test dispatcher that does nothing"""
return Response()
