def __call__(self, environ, start_response):
content_type = get_content_type(environ.get('CONTENT_TYPE'))
if content_type == 'application/json' and 'wsgi.input' in environ:
body = environ['wsgi.input'].read()
if body:
arguments = []
body = to_string(body)
try:
body_json = loads(body)
for key, values in dict(body_json).items():
values = maybe_list(values)
for value in values:
if value is None:
arguments.append('%s=' % key)
else:
arguments.append('%s=%s' % (key, quote(dump_query_value(value))))
body = '&'.join(arguments)
except (ValueError, UnicodeEncodeError):
headers = [('Content-type', 'application/json')]
error = HTTPInvalidJSONPayload()
start_response(error.status, headers)
return format_error_response_to_json(error)
environ_add_POST(environ, body or '')
return self.application(environ, start_response)
def __call__(self, environ, start_response):
try:
for chunk in self.application(environ, start_response):
yield chunk
except (BaseException, Exception) as error:
# Save / log error
request = make_request(self.config, environ)
try:
small_message = '%s: %s' % (error.__class__.__name__, to_string(error))
except (BaseException, Exception):
small_message = error
print_message = True
if request.api is not None:
api_manager = self.settings.get('api_manager')
if api_manager is not None:
logging_api_name = api_manager.__api_name__
else:
logging_api_name = 'logging'
try:
getattr(request.api, logging_api_name).log_critical(
'internal_server_error',
str(small_message))
except (BaseException, Exception):
pass
else:
print_message = False
if print_message:
print(''.join(format_exception(*sys.exc_info())))
if isinstance(request.registry.config, APIConfigurator):
headers = [('Content-type', 'application/json')]
internal_server_error = HTTPInternalServerError()
start_response(internal_server_error.status, headers)
response = format_error_response_to_json(internal_server_error, request=request)
yield response
else:
return_default = False
error_view = self.config.settings.get('errors.interface.global_error_view')
if error_view is None:
return_default = True
else:
try:
response = error_view(error, request)
except Exception:
return_default = True
else:
start_response(response.status, response.headerlist)
yield response.body
if return_default:
internal_server_error = HTTPInternalServerError()
for response in internal_server_error(environ, start_response):
yield response
def __call__(self, environ, start_response):
not_found = HTTPNotFound()
accept = environ.get('HTTP_ACCEPT', '')
if accept and 'json' in accept:
not_found.body = format_error_response_to_json(not_found)
not_found.content_type = 'application/json'
return not_found(environ, start_response)
def __call__(self, environ, start_response):
http_origin = environ.get('HTTP_ORIGIN')
if not self.allow_all_origins and http_origin not in self.allowed_origins:
return self.application(environ, start_response)
http_method = environ.get('REQUEST_METHOD')
if http_method not in self.allowed_methods:
method_not_allowed = HTTPMethodNotAllowed()
start_response(
method_not_allowed.status,
[('Content-type', 'application/json')])
return format_error_response_to_json(method_not_allowed)
cors_headers = []
if self.allow_all_origins:
cors_headers.append(('Access-Control-Allow-Origin', '*'))
else:
cors_headers.append(('Access-Control-Allow-Origin', to_string(http_origin)))
if http_method == 'OPTIONS':
methods = environ.get('HTTP_ACCESS_CONTROL_REQUEST_METHOD')
if methods:
cors_headers.append(('Access-Control-Allow-Methods', to_string(methods)))
http_headers = environ.get('HTTP_ACCESS_CONTROL_REQUEST_HEADERS')
if http_headers:
cors_headers.append(('Access-Control-Allow-Headers', to_string(http_headers)))
if self.max_age is not None:
cors_headers.append(('Access-Control-Max-Age', to_string(self.max_age)))
start_response(HTTPNoContent().status, cors_headers)
return []
else:
def start_response_decorator(status, headers, exc_info=None):
headers.extend(cors_headers)
return start_response(status, headers, exc_info)
return self.application(environ, start_response_decorator)
