def common_error_handler(exception):
"""
Generally, each route handler should be decorated with @dss_handler, which manages exceptions. The two cases
that fail are:
1. handlers that are not decorated.
2. handlers that return a code that is not in the swagger spec.
In both cases, the exception would be punted here, and we return this very generic error that also happens to
bypass all validation.
"""
problem = {
'status': requests.codes.server_error,
'code': "unhandled_exception",
'title': str(exception),
'stacktrace': traceback.format_exc(),
}
if isinstance(exception, (OAuthProblem, OAuthResponseProblem,
OAuthScopeProblem, Forbidden)):
problem['status'] = exception.code
problem['code'] = exception.__class__.__name__
problem['title'] = exception.description
return FlaskApi.get_response(
ConnexionResponse(
status_code=problem['status'],
mimetype="application/problem+json",
content_type="application/problem+json",
body=problem,
))
def _make_response(response):
from connexion.apis.flask_api import FlaskApi
mimetype = default_mimetype
if hasattr(request, 'prom_connexion_content_type'):
mimetype = request.prom_connexion_content_type
return FlaskApi.get_response(response, mimetype=mimetype)
def error_method_not_allowed(exception):
return FlaskApi.get_response(
problem(
status=exception.code,
title="Invalid input",
detail=exception.description,
headers={"Allow": "POST"},
))
def example_resolver(self, operation):
linked_responses = []
consumes = operation.consumes
request = FlaskApi.get_request()
if all_json(consumes):
request_body = request.json
elif consumes[0] in FORM_CONTENT_TYPES:
request_body = {sanitized(k): v for k, v in request.form.items()}
else:
request_body = request.body
try:
query = request.query.to_dict(flat=False)
except AttributeError:
query = dict(request.query.items())
content_type_header = request.headers.get('Content-Type')
content_type_header = content_type_header or request.headers.get(
'Accept', '*/*')
content_type_header = strip_charset(content_type_header)
# first priority - Request body
if request_body:
try:
operation_request_body = operation.request_body['content'][
content_type_header]
for item in operation_request_body.get('x-link-response'):
if dict(item.get('value')) == request_body:
linked_responses.append(item.get('x-response-id'))
except KeyError:
pass
# second priority - Query params
if query:
query_params = filter(lambda x: x.get('in') == 'query',
operation.parameters)
for param in query_params:
param_val = query.get(param.get('name'), None)
if param_val is not None:
for item in param.get('x-link-response'):
if item.get('value') in param_val:
linked_responses.append(item.get('x-response-id'))
# third priority - Headers
if content_type_header:
header_params = filter(lambda x: x.get('in') == 'header',
operation.parameters)
for param in header_params:
if param.get('name').lower() in ['accept', 'content-type']:
for item in param.get('x-link-response'):
if item.get('value') == content_type_header:
linked_responses.append(item.get('x-response-id'))
return linked_responses
def register(
self,
specification,
base_path=None,
arguments=None,
validate_responses=True,
strict_validation=True,
resolver=None,
auth_all_paths=False,
debug=False,
resolver_error_handler=None,
validator_map=None,
pythonic_params=False,
pass_context_arg_name=None,
options=dict(swagger_url="apidocs"),
):
"""Adds an API to the application based on a swagger file
"""
app = self.__app
logger.debug(f"Adding API: {specification}")
self.__api = api = FlaskApi(
specification=pathlib.Path(specification),
base_path=base_path,
arguments=arguments,
validate_responses=validate_responses,
strict_validation=strict_validation,
resolver=resolver,
auth_all_paths=auth_all_paths,
debug=app.debug,
resolver_error_handler=resolver_error_handler,
validator_map=validator_map,
pythonic_params=pythonic_params,
pass_context_arg_name=pass_context_arg_name,
options=options,
)
self.swagger_url = api.options.openapi_console_ui_path
app.register_blueprint(api.blueprint)
return api
def common_error_handler(exception=None):
"""
:type exception: Exception
"""
if isinstance(exception, ProblemException):
response = problem(
status=exception.status,
title=exception.title,
detail=exception.detail,
type=exception.type,
instance=exception.instance,
headers=exception.headers,
ext=exception.ext,
)
else:
if not isinstance(exception, HTTPException):
exception = InternalServerError()
response = problem(title=exception.name, detail=exception.description, status=exception.code, headers=exception.get_headers())
return FlaskApi.get_response(response)
def wrapper(request):
try:
return origwrapper(request)
except DSSBindingException as ex:
status = ex.status
code = ex.code
title = ex.message
stacktrace = traceback.format_exc()
return FlaskApi.get_response(
ConnexionResponse(
status_code=status,
mimetype="application/problem+json",
content_type="application/problem+json",
body={
'status': status,
'code': code,
'title': title,
'stacktrace': stacktrace,
},
))
def handle_offer_mgr_exception(exc) -> flask.Response:
response = connexion.problem(status=400, title=exc.message, detail=exc.detail)
return FlaskApi.get_response(response)
def verify_request_flask(self) -> Optional[Response]:
"""Verify request with token authentication and return a flask compatible response"""
res = self.verify_request()
if res:
return FlaskApi.get_response(res)
return None
