def _fallback_view(request):
# Maybe we failed to match any definitions for the request method?
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
raise response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
for method, _, args in service.definitions:
if method != request.method:
continue
if 'accept' in args:
acceptable.extend(
service.get_acceptable(method, filter_callables=True))
if 'acceptable' in request.info:
for content_type in request.info['acceptable']:
if content_type not in acceptable:
acceptable.append(content_type)
# Now check if that was actually the source of the problem.
if not request.accept.best_match(acceptable):
response = HTTPNotAcceptable()
response.content_type = "application/json"
response.body = json.dumps(acceptable)
raise response
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
raise PredicateMismatch(service.name)
def _fallback_view(request):
# Maybe we failed to match any definitions for the request method?
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
return response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
for method, _, args in service.definitions:
if method != request.method:
continue
if 'accept' in args:
acceptable.extend(
service.get_acceptable(method, filter_callables=True))
if 'acceptable' in request.info:
for content_type in request.info['acceptable']:
if content_type not in acceptable:
acceptable.append(content_type)
# Now check if that was actually the source of the problem.
if not request.accept.best_match(acceptable):
response = HTTPNotAcceptable()
response.content_type = "application/json"
response.body = json.dumps(acceptable)
return response
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
raise PredicateMismatch(service.name)
def _fallback_view(request):
# Maybe we failed to match any definitions for the request method?
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
raise response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
supported_contenttypes = []
for method, _, args in service.definitions:
if method != request.method:
continue
if 'accept' in args:
acceptable.extend(
service.get_acceptable(method, filter_callables=True))
acceptable.extend(
request.info.get('acceptable', []))
acceptable = list(set(acceptable))
# Now check if that was actually the source of the problem.
if not request.accept.acceptable_offers(offers=acceptable):
request.errors.add(
'header', 'Accept',
'Accept header should be one of {0}'.format(
acceptable).encode('ascii'))
request.errors.status = HTTPNotAcceptable.code
error = service.error_handler(request)
raise error
if 'content_type' in args:
supported_contenttypes.extend(
service.get_contenttypes(method,
filter_callables=True))
supported_contenttypes.extend(
request.info.get('supported_contenttypes', []))
supported_contenttypes = list(set(supported_contenttypes))
# Now check if that was actually the source of the problem.
if not content_type_matches(request, supported_contenttypes):
request.errors.add(
'header', 'Content-Type',
'Content-Type header should be one of {0}'.format(
supported_contenttypes).encode('ascii'))
request.errors.status = HTTPUnsupportedMediaType.code
error = service.error_handler(request)
raise error
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
# After "custom predicates" feature has been added there is no need in
# this line. Instead requests will be filtered by "custom predicates"
# feature filter and exception "404 Not found" error will be raised. In
# order to avoid unpredictable cases, we left this line in place and
# excluded it from coverage.
raise PredicateMismatch(service.name) # pragma: no cover
def _fallback_view(request):
# Maybe we failed to match any definitions for the request method?
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
raise response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
supported_contenttypes = []
for method, _, args in service.definitions:
if method != request.method:
continue
if 'accept' in args:
acceptable.extend(
service.get_acceptable(method, filter_callables=True))
acceptable.extend(
request.info.get('acceptable', []))
acceptable = list(set(acceptable))
# Now check if that was actually the source of the problem.
if not request.accept.best_match(acceptable):
request.errors.add(
'header', 'Accept',
'Accept header should be one of {0}'.format(
acceptable).encode('ascii'))
request.errors.status = HTTPNotAcceptable.code
error = service.error_handler(request)
raise error
if 'content_type' in args:
supported_contenttypes.extend(
service.get_contenttypes(method,
filter_callables=True))
supported_contenttypes.extend(
request.info.get('supported_contenttypes', []))
supported_contenttypes = list(set(supported_contenttypes))
# Now check if that was actually the source of the problem.
if not content_type_matches(request, supported_contenttypes):
request.errors.add(
'header', 'Content-Type',
'Content-Type header should be one of {0}'.format(
supported_contenttypes).encode('ascii'))
request.errors.status = HTTPUnsupportedMediaType.code
error = service.error_handler(request)
raise error
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
# After "custom predicates" feature has been added there is no need in
# this line. Instead requests will be filtered by "custom predicates"
# feature filter and exception "404 Not found" error will be raised. In
# order to avoid unpredictable cases, we left this line in place and
# excluded it from coverage.
raise PredicateMismatch(service.name) # pragma: no cover
def _fallback_view(request):
# Maybe we failed to match any definitions for the request method?
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
raise response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
supported_contenttypes = []
for method, _, args in service.definitions:
if method != request.method:
continue
if 'accept' in args:
acceptable.extend(
service.get_acceptable(method, filter_callables=True))
acceptable.extend(
request.info.get('acceptable', []))
acceptable = list(set(acceptable))
# Now check if that was actually the source of the problem.
if not request.accept.best_match(acceptable):
request.errors.add(
'header', 'Accept',
'Accept header should be one of {0}'.format(
acceptable).encode('ascii'))
request.errors.status = HTTPNotAcceptable.code
error = service.error_handler(request.errors)
raise error
if 'content_type' in args:
supported_contenttypes.extend(
service.get_contenttypes(method,
filter_callables=True))
supported_contenttypes.extend(
request.info.get('supported_contenttypes', []))
supported_contenttypes = list(set(supported_contenttypes))
# Now check if that was actually the source of the problem.
if not content_type_matches(request, supported_contenttypes):
request.errors.add(
'header', 'Content-Type',
'Content-Type header should be one of {0}'.format(
supported_contenttypes).encode('ascii'))
request.errors.status = HTTPUnsupportedMediaType.code
error = service.error_handler(request.errors)
raise error
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
raise PredicateMismatch(service.name)
def _fallback_view(request):
# Maybe we failed to match any definitions for the request method?
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
raise response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
supported_contenttypes = []
for method, _, args in service.definitions:
if method != request.method:
continue
if 'accept' in args:
acceptable.extend(
service.get_acceptable(method, filter_callables=True))
acceptable.extend(
request.info.get('acceptable', []))
acceptable = list(set(acceptable))
# Now check if that was actually the source of the problem.
if not request.accept.best_match(acceptable):
request.errors.add(
'header', 'Accept',
'Accept header should be one of {0}'.format(
acceptable).encode('ascii'))
request.errors.status = HTTPNotAcceptable.code
error = service.error_handler(request.errors)
raise error
if 'content_type' in args:
supported_contenttypes.extend(
service.get_contenttypes(method,
filter_callables=True))
supported_contenttypes.extend(
request.info.get('supported_contenttypes', []))
supported_contenttypes = list(set(supported_contenttypes))
# Now check if that was actually the source of the problem.
if not content_type_matches(request, supported_contenttypes):
request.errors.add(
'header', 'Content-Type',
'Content-Type header should be one of {0}'.format(
supported_contenttypes).encode('ascii'))
request.errors.status = HTTPUnsupportedMediaType.code
error = service.error_handler(request.errors)
raise error
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
raise PredicateMismatch(service.name)
def _notfound(request):
match = request.matchdict
# the route exists, raising a 405
if match is not None:
pattern = request.matched_route.pattern
service = request.registry['cornice_services'].get(pattern)
if service is not None:
res = HTTPMethodNotAllowed()
res.allow = service.defined_methods
return res
# 404
return HTTPNotFound()
def cornice_tween(request):
response = handler(request)
service = get_service(request)
if service is not None:
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
else:
# get the filters for this call
kwargs = service.definitions[request.method]
for _filter in kwargs.get('filters', []):
response = _filter(response)
return response
def _notfound(request):
match = request.matchdict
# the route exists, raising a 405
if match is not None:
pattern = request.matched_route.pattern
service = request.registry['cornice_services'].get(pattern)
if service is not None:
res = HTTPMethodNotAllowed()
res.allow = service.defined_methods
return res
# 404
return HTTPNotFound()
def cornice_tween(request):
response = handler(request)
if request.matched_route is not None:
# do some sanity checking on the response using filters
pattern = request.matched_route.pattern
service = request.registry['cornice_services'].get(pattern)
if service is not None:
if request.method not in service.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = service.defined_methods
else:
# get the filters for this call
kwargs = service.definitions[request.method]
for _filter in kwargs.get('filters', []):
response = _filter(response)
return response
def _fallback_view(self, request):
"""Fallback view for this service, called when nothing else matches.
This method provides the view logic to be executed when the request
does not match any explicitly-defined view. Its main responsibility
is to produce an accurate error response, such as HTTPMethodNotAllowed
or HTTPNotAcceptable.
"""
# Maybe we failed to match any definitions for the request method?
if request.method not in self.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = self.defined_methods
return response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
for api_kwargs in self.definitions:
if api_kwargs['request_method'] != request.method:
continue
if 'accept' in api_kwargs:
accept = to_list(api_kwargs.get('accept'))
acceptable.extend(a for a in accept if not callable(a))
if 'acceptable' in request.info:
for content_type in request.info['acceptable']:
if content_type not in acceptable:
acceptable.append(content_type)
# Now check if that was actually the source of the problem.
if not request.accept.best_match(acceptable):
response = HTTPNotAcceptable()
response.content_type = "application/json"
response.body = json.dumps(acceptable)
return response
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
raise PredicateMismatch(self.name)
def _fallback_view(self, request):
"""Fallback view for this service, called when nothing else matches.
This method provides the view logic to be executed when the request
does not match any explicitly-defined view. Its main responsibility
is to produce an accurate error response, such as HTTPMethodNotAllowed
or HTTPNotAcceptable.
"""
# Maybe we failed to match any definitions for the request method?
if request.method not in self.defined_methods:
response = HTTPMethodNotAllowed()
response.allow = self.defined_methods
return response
# Maybe we failed to match an acceptable content-type?
# First search all the definitions to find the acceptable types.
# XXX: precalculate this like the defined_methods list?
acceptable = []
for api_kwargs in self.definitions:
if api_kwargs["request_method"] != request.method:
continue
if "accept" in api_kwargs:
accept = to_list(api_kwargs.get("accept"))
acceptable.extend(a for a in accept if not callable(a))
if "acceptable" in request.info:
for content_type in request.info["acceptable"]:
if content_type not in acceptable:
acceptable.append(content_type)
# Now check if that was actually the source of the problem.
if not request.accept.best_match(acceptable):
response = HTTPNotAcceptable()
response.content_type = "application/json"
response.body = json.dumps(acceptable)
return response
# In the absence of further information about what went wrong,
# let upstream deal with the mismatch.
raise PredicateMismatch(self.name)
