[wip] update code to use cornice/colander validators as expected (relates to #615)

Author: fmigneault

weaver/processes/constants.py

@@ -295,14 +295,20 @@ class JobInputsOutputsSchema(Constants):
         CWL_RequirementToolTimeLimitType,
         CWL_RequirementWorkReuseType,
     ]
-    ProcessSchemaType = Literal["OGC", "ogc", "OLD", "old", "WPS", "wps"]
-    JobInputsOutputsSchemaType = Literal[
-        "ogc+strict",
-        "OGC+STRICT",
-        "old+strict",
-        "OLD+STRICT",
-        "ogc",
-        "OGC",
-        "old",
-        "OLD",
+    ProcessSchemaType = Union[
+        ProcessSchema,
+        Literal["OGC", "ogc", "OLD", "old", "WPS", "wps"]
+    ]
+    JobInputsOutputsSchemaType = Union[
+        JobInputsOutputsSchema,
+        Literal[
+            "ogc+strict",
+            "OGC+STRICT",
+            "old+strict",
+            "OLD+STRICT",
+            "ogc",
+            "OGC",
+            "old",
+            "OLD",
+        ]
     ]

weaver/tweens.py

@@ -1,8 +1,9 @@
-import colander
 import logging
 import sys
 from typing import TYPE_CHECKING
 
+import colander
+from cornice.renderer import JSONError
 from pyramid.httpexceptions import (
     HTTPException,
     HTTPInternalServerError,
@@ -80,26 +81,23 @@ def validate_format(request):
 def http_apply_response_format_tween_factory(handler, registry):    # noqa: F811
     # type: (ViewHandler, Registry) -> Callable[[PyramidRequest], AnyViewResponse]
     """
-    Tween factory that applies the response ``Content-Type`` according to the requested format.
+    Tween factory that applies the request ``Accept`` header according to the requested format.
 
-    Format can be provided by ``Accept`` header or ``format`` query.
+    Format can be provided by ``Accept`` header or ``format`` query. The resulting request will unify the format
+    under the ``Accept`` header, such that a single reference can be considered by the following code.
 
-    The target ``Content-Type`` is expected to have been validated by :func:`validate_accept_header_tween` beforehand
-    to handle not-acceptable errors. If an invalid format is detected at this stage, JSON is used by default.
-    This can be the case for example for :func:`validate_accept_header_tween` itself that raises the error about
-    the invalid ``Accept`` header or ``format`` query, but detects these inadequate parameters from incoming request.
+    If validation of allowed ``Accept`` header values must be done, it is expected to be validated by
+    :func:`cornice.validators.colander_headers_validator` or :func:`cornice.validators.colander_validator`
+    with the relevant `validators` definition applied onto the :class:`cornice.service.Service` decorating
+    the specific view.
 
-    The tween also ensures that additional request metadata extracted from :func:`get_request_info` is applied to
-    the response body if not already provided by a previous operation.
+    Since browsers will typically inject :term:`HTML`-related media-types in the ``Accept` header, specific
+    combinations of browser ``User-Agent`` will ignore those values to provide :term:`JSON` by default, unless
+    an explicit ``text/html`` or ``f=html`` is specified. In the case of non-browser ``User-Agent``, headers will
+    be interpreted normally.
     """
     def apply_format(request):
         # type: (PyramidRequest) -> HTTPException
-        """
-        Validates the specified request according to its ``Accept`` header, ignoring UI related routes that request more
-        content-types than the ones supported by the application for display purposes (styles, images etc.).
-
-        Alternatively, if no ``Accept`` header is found, look for equivalent value provided via query parameter.
-        """
         content_type = guess_target_format(request)
         # NOTE:
         # enforce the accept header in case it was specified with format query, since some renderer implementations
@@ -123,77 +121,6 @@ def apply_format(request):
     return apply_format
 
 
-# def generate_response_http_format(http_class, http_kwargs, content, content_type=None):
-#     # type: (Type[HTTPException], Optional[Dict[str, Any]], Union[JSON, str], Optional[str]) -> HTTPException
-#     """
-#     Formats the HTTP response content according to desired ``content_type`` using provided HTTP code and content.
-#
-#     :param http_class: `HTTPException` derived class to use for output (code, generic title/explanation, etc.)
-#     :param http_kwargs: additional keyword arguments to pass to `http_class` when called
-#     :param content: formatted JSON content or literal string content providing additional details for the response
-#     :param content_type: One of the supported types by the application.
-#     :return: `http_class` instance with requested information and content type if creation succeeds
-#     :raises: `HTTPInternalServerError` instance details about requested information and content type if creation fails
-#     """
-#     content = str(content) if not isinstance(content, six.string_types) else content
-#
-#     # adjust additional keyword arguments and try building the http response class with them
-#     http_kwargs = {} if http_kwargs is None else http_kwargs
-#     http_headers = http_kwargs.get("headers", {})
-#     # omit content-type and related headers that we override
-#     for header in dict(http_headers):
-#         if header.lower().startswith("content-"):
-#             http_headers.pop(header, None)
-#
-#     try:
-#         # Pass down Location if it is provided and should be given as input parameter for this HTTP class.
-#         # Omitting this step would inject a (possibly extra) empty Location that defaults to the current application.
-#         # When resolving HTTP redirects, injecting this extra Location when the requested one is not the current
-#         # application will lead to redirection failures because all locations are appended in the header as CSV list.
-#         if issubclass(http_class, HTTPRedirection):
-#             location = get_header("Location", http_headers, pop=True)
-#             if location and "location" not in http_kwargs:
-#                 http_kwargs["location"] = location
-#
-#         # directly output json
-#         if content_type == ContentType.APP_JSON:
-#             content_type = "{}; charset=UTF-8".format(CONTENT_TYPE_JSON)
-#             http_response = http_class(body=content, content_type=content_type, **http_kwargs)
-#
-#         # otherwise json is contained within the html <body> section
-#         elif content_type == ContentType.TEXT_HTML:
-#             if http_class is HTTPOk:
-#                 http_class.explanation = "Operation successful."
-#             if not http_class.explanation:
-#                 http_class.explanation = http_class.title  # some don't have any defined
-#             # add preformat <pre> section to output as is within the <body> section
-#             html_status = "Exception" if http_class.code >= 400 else "Response"
-#             html_header = "{}<br><h2>{} Details</h2>".format(http_class.explanation, html_status)
-#             html_template = "<pre style='word-wrap: break-word; white-space: pre-wrap;'>{}</pre>"
-#             content_type = "{}; charset=UTF-8".format(CONTENT_TYPE_HTML)
-#             if json_content:
-#                 html_body = html_template.format(json.dumps(json_content, indent=True, ensure_ascii=False))
-#             else:
-#                 html_body = html_template.format(content)
-#             html_body = html_header + html_body
-#             http_response = http_class(body_template=html_body, content_type=content_type, **http_kwargs)
-#
-#         elif content_type in [CONTENT_TYPE_APP_XML, CONTENT_TYPE_TXT_XML]:
-#             xml_body = OutputFormat.convert(json_content, ContentType.APP_XML, item_root="response")
-#             http_response = http_class(body=xml_body, content_type=CONTENT_TYPE_TXT_XML, **http_kwargs)
-#
-#         # default back to plain text
-#         else:
-#             http_response = http_class(body=content, content_type=CONTENT_TYPE_PLAIN, **http_kwargs)
-#
-#         return http_response
-#     except Exception as exc:  # pylint: disable=W0703
-#         raise HTTPInternalServerError(json={
-#             "detail": "Failed to build HTTP response",
-#             "cause": repr(exc),
-#             "value": str(content_type),
-#         })
-
 # FIXME:
 #   https://github.com/crim-ca/weaver/issues/215
 #   define common Exception classes that won't require this type of conversion
@@ -208,7 +135,12 @@ def error_repr(http_err):
     if not isinstance(http_err, (HTTPException, OWSException)):
         return f"({err_type}) {http_err!s}"
     err_code = getattr(http_err, "code", getattr(http_err, "status_code", 500))
-    err_repr = str(http_err)
+    # in some cases, cornice will wrap HTTPError incorrectly without 'detail'
+    # (see https://github.com/Cornices/cornice/issues/586)
+    try:
+        err_repr = str(http_err)
+    except (AttributeError, NameError):
+        err_repr = err_type
     try:
         # FIXME: handle colander invalid directly in tween (https://github.com/crim-ca/weaver/issues/112)
         #        specific cleanup in case of string representation of colander.Invalid to help debug logged errors
@@ -301,7 +233,7 @@ def handle_ows_tween(request):
 # names must differ to avoid conflicting configuration error
 OWS_RESPONSE_EXCVIEW = fully_qualified_name(ows_response_tween_factory_excview)
 OWS_RESPONSE_INGRESS = fully_qualified_name(ows_response_tween_factory_ingress)
-HTTP_FORMAT_VALIDATE = fully_qualified_name(http_validate_response_format_tween_factory)
+#HTTP_FORMAT_VALIDATE = fully_qualified_name(http_validate_response_format_tween_factory)
 HTTP_FORMAT_RESPONSE = fully_qualified_name(http_apply_response_format_tween_factory)
 
 
@@ -312,7 +244,7 @@ def includeme(config):
     config.add_tween(OWS_RESPONSE_INGRESS, under=INGRESS)
 
     # intermediate tweens to modify the request/response
-    config.add_tween(HTTP_FORMAT_VALIDATE, over=MAIN)
+    #config.add_tween(HTTP_FORMAT_VALIDATE, over=MAIN)
     config.add_tween(HTTP_FORMAT_RESPONSE, over=OWS_RESPONSE_EXCVIEW)
 
     # using 'EXCVIEW' to run over any other 'valid' exception raised to adjust formatting and log