c2cgeoportal-geoportal 2.5.0.100__py2.py3-none-any.whl → 2.7.1.156__py2.py3-none-any.whl

c2cgeoportal_geoportal/lib/checker.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2020, Camptocamp SA
+# Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -32,17 +30,21 @@ import logging
 import os
 import subprocess
 from time import sleep
-from typing import Dict
+from typing import Any, Dict, List, Mapping, Optional, Union, cast
 from urllib.parse import urljoin
 
 import c2cwsgiutils.health_check
+import pyramid.config
+import pyramid.request
 import requests
 
 LOG = logging.getLogger(__name__)
 
 
-def build_url(name, path, request, headers=None):
-    """ Build an URL and headers for the checkers """
+def build_url(
+    name: str, path: str, request: pyramid.request.Request, headers: Optional[Dict[str, str]] = None
+) -> Dict[str, Union[str, Dict[str, str]]]:
+    """Build an URL and headers for the checkers."""
     base_internal_url = request.registry.settings["checker"]["base_internal_url"]
     url = urljoin(base_internal_url, path)
 
@@ -55,7 +57,9 @@ def build_url(name, path, request, headers=None):
     return {"url": url, "headers": headers}
 
 
-def _build_headers(request, headers=None):
+def _build_headers(
+    request: pyramid.request.Request, headers: Optional[Dict[str, str]] = None
+) -> Dict[str, str]:
     if headers is None:
         headers = {}
     headers["Cache-Control"] = "no-cache"
@@ -67,45 +71,43 @@ def _build_headers(request, headers=None):
     return headers
 
 
-def _routes(settings, health_check):
+def _routes(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     routes_settings = settings["routes"]
     for route in routes_settings["routes"]:
         if route.get("checker_name", route["name"]) not in routes_settings["disable"]:
             name = "checker_routes_" + route.get("checker_name", route["name"])
 
             class GetRequest:
-                """
-                Get the request information about the current route name
-                """
+                """Get the request information about the current route name."""
 
-                def __init__(self, route_name, type_):
+                def __init__(self, route_name: str, type_: str) -> None:
                     self.route_name = route_name
                     self.type = type_
 
-                def __call__(self, request):
+                def __call__(self, request: pyramid.request.Request) -> Union[str, Dict[str, str]]:
                     return build_url("route", request.route_path(self.route_name), request)[self.type]
 
             health_check.add_url_check(
-                url=GetRequest(route["name"], "url"),
+                url=GetRequest(route["name"], "url"),  # type: ignore
                 name=name,
                 params=route.get("params", None),
-                headers=GetRequest(route["name"], "headers"),
+                headers=GetRequest(route["name"], "headers"),  # type: ignore
                 level=route["level"],
                 timeout=30,
             )
 
 
-def _pdf3(settings, health_check):
+def _pdf3(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     print_settings = settings["print"]
     if "spec" not in print_settings:
         return
 
-    def check(request):
+    def check(request: pyramid.request.Request) -> None:
         path = request.route_path("printproxy_report_create", format="pdf")
         url_headers = build_url("Check the printproxy request (create)", path, request)
 
         session = requests.session()
-        resp = session.post(json=print_settings["spec"], timeout=30, **url_headers)
+        resp = session.post(json=print_settings["spec"], timeout=30, **url_headers)  # type: ignore
         resp.raise_for_status()
 
         job = resp.json()
@@ -115,44 +117,44 @@ def _pdf3(settings, health_check):
         done = False
         while not done:
             sleep(1)
-            resp = session.get(timeout=30, **url_headers)
+            resp = session.get(timeout=30, **url_headers)  # type: ignore
             resp.raise_for_status()
 
             status = resp.json()
             if "error" in status:
-                raise Exception("Failed to do the printing: {0!s}".format(status["error"]))
+                raise Exception(f"Failed to do the printing: {status['error']}")
             done = status["done"]
 
         path = request.route_path("printproxy_report_get", ref=job["ref"])
         url_headers = build_url("Check the printproxy pdf retrieve", path, request)
-        resp = session.get(timeout=30, **url_headers)
+        resp = session.get(timeout=30, **url_headers)  # type: ignore
         resp.raise_for_status()
 
     health_check.add_custom_check(name="checker_print", check_cb=check, level=print_settings["level"])
 
 
-def _fts(settings, health_check):
+def _fts(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     fts_settings = settings["fulltextsearch"]
     if fts_settings.get("disable", False):
         return
 
-    def get_both(request):
+    def get_both(request: pyramid.request.Request) -> Dict[str, Union[str, Dict[str, str]]]:
         return build_url("Check the fulltextsearch", request.route_path("fulltextsearch"), request)
 
-    def check(_request, response):
+    def check(_request: pyramid.request.Request, response: pyramid.response.Response) -> None:
         assert response.json()["features"], "No result"
 
     health_check.add_url_check(
         name="checker_fulltextsearch",
-        url=lambda r: get_both(r)["url"],
-        headers=lambda r: get_both(r)["headers"],
+        url=lambda r: get_both(r)["url"],  # type: ignore
+        headers=lambda r: get_both(r)["headers"],  # type: ignore
         params={"query": fts_settings["search"], "limit": "1"},
         check_cb=check,
         level=fts_settings["level"],
     )
 
 
-def _themes_errors(settings, health_check):
+def _themes_errors(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
     from c2cgeoportal_commons.models.main import Interface  # pylint: disable=import-outside-toplevel
 
@@ -160,7 +162,7 @@ def _themes_errors(settings, health_check):
     default_params = themes_settings.get("params", {})
     interfaces_settings = themes_settings["interfaces"]
 
-    def check(request):
+    def check(request: pyramid.request.Request) -> None:
         path = request.route_path("themes")
         session = requests.session()
         for (interface,) in DBSession.query(Interface.name).all():
@@ -171,52 +173,51 @@ def _themes_errors(settings, health_check):
 
             interface_url_headers = build_url("checker_themes " + interface, path, request)
 
-            response = session.get(params=params, timeout=120, **interface_url_headers)
+            response = session.get(params=params, timeout=120, **interface_url_headers)  # type: ignore
             response.raise_for_status()
 
             result = response.json()
             if result["errors"]:
                 raise c2cwsgiutils.health_check.JsonCheckException(
-                    "Interface '{}' has error in Theme.".format(interface), result["errors"]
+                    f"Interface '{interface}' has error in Theme.", result["errors"]
                 )
 
     health_check.add_custom_check(name="checker_themes", check_cb=check, level=themes_settings["level"])
 
 
-def _lang_files(global_settings, settings, health_check):
+def _lang_files(
+    global_settings: Dict[str, Any],
+    settings: Dict[str, Any],
+    health_check: c2cwsgiutils.health_check.HealthCheck,
+) -> None:
     lang_settings = settings["lang"]
     available_locale_names = global_settings["available_locale_names"]
 
     default_name = global_settings["default_locale_name"]
-    assert (
-        default_name in available_locale_names
-    ), "default_locale_name '{}' not in available_locale_names: {}".format(
-        default_name, ", ".join(available_locale_names)
+    assert default_name in available_locale_names, (
+        f"default_locale_name '{default_name}' not in available_locale_names: "
+        f"{', '.join(available_locale_names)}"
     )
 
     for type_ in lang_settings.get("files", []):
         for lang in available_locale_names:
             if type_ == "ngeo":
-                url = "/etc/geomapfish/static/{lang}.json"
+                url = f"/etc/geomapfish/static/{lang}.json"
             else:
-                raise Exception(
-                    "Your language type value '%s' is not valid, " "available values [ngeo]" % type_
-                )
+                raise Exception(f"Your language type value '{type_}' is not valid, available values [ngeo]")
 
-            name = "checker_lang_{}_{}".format(type_, lang)
+            name = f"checker_lang_{type_}_{lang}"
 
             class GetRequest:
-                """
-                Get the request information about the current route name
-                """
+                """Get the request information about the current route name."""
 
-                def __init__(self, name, url, lang, type_):
+                def __init__(self, name: str, url: str, lang: str, type_: str) -> None:
                     self.name = name
                     self.url = url
                     self.lang = lang
                     self.type = type_
 
-                def __call__(self, request):
+                def __call__(self, request: pyramid.request.Request) -> Union[str, Mapping[str, str]]:
                     return build_url(
                         self.name,
                         request.static_path(
@@ -227,27 +228,27 @@ def _lang_files(global_settings, settings, health_check):
 
             health_check.add_url_check(
                 name=name,
-                url=GetRequest(name, url, lang, "url"),
-                headers=GetRequest(name, url, lang, "headers"),
+                url=GetRequest(name, url, lang, "url"),  # type: ignore
+                headers=GetRequest(name, url, lang, "headers"),  # type: ignore
                 level=lang_settings["level"],
             )
 
 
-def _phantomjs(settings, health_check):
+def _phantomjs(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     phantomjs_settings = settings["phantomjs"]
     for route in phantomjs_settings["routes"]:
         if route.get("checker_name", route["name"]) in phantomjs_settings["disable"]:
             continue
 
         class _Check:
-            def __init__(self, route):
+            def __init__(self, route: Dict[str, Any]) -> None:
                 self.route = route
 
-            def __call__(self, request):
+            def __call__(self, request: pyramid.request.Request) -> None:
                 path = request.route_path(self.route["name"], _query=self.route.get("params", {}))
-                url = build_url("Check", path, request)["url"]
+                url: str = cast(str, build_url("Check", path, request)["url"])
 
-                cmd = ["node", "/usr/bin/check-example.js", url]
+                cmd: List[str] = ["node", "/usr/bin/check-example.js", url]
                 env = dict(os.environ)
                 for name, value in self.route.get("environment", {}).items():
                     if isinstance(value, (list, dict)):
@@ -260,26 +261,23 @@ def _phantomjs(settings, health_check):
                     subprocess.check_output(cmd, env=env, timeout=70)
                 except subprocess.CalledProcessError as exception:
                     raise Exception(
-                        "{} exit with code: {}\n{}".format(
-                            " ".join(exception.cmd), exception.returncode, exception.output.decode("utf-8")
-                        )
-                    )
+                        f"{' '.join(exception.cmd)} exit with code: {exception.returncode}\n"
+                        f"{exception.output.decode('utf-8')[:10000]}"
+                    ) from exception
                 except subprocess.TimeoutExpired as exception:
                     raise Exception(
-                        """Timeout:
-command: {}
+                        f"""Timeout:
+command: {' '.join(exception.cmd)}
 output:
-{}""".format(
-                            " ".join(exception.cmd), exception.output.decode("utf-8")
-                        )
-                    )
+{exception.output.decode('utf-8')}"""
+                    ) from exception
 
         name = "checker_phantomjs_" + route.get("checker_name", route["name"])
         health_check.add_custom_check(name=name, check_cb=_Check(route), level=route["level"])
 
 
-def init(config, health_check):
-    """ Init the ckeckers """
+def init(config: pyramid.config.Configurator, health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
+    """Initialize the checkers."""
     global_settings = config.get_settings()
     if "checker" not in global_settings:
         return

c2cgeoportal_geoportal/lib/common_headers.py

@@ -0,0 +1,170 @@
+# Copyright (c) 2012-2021, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import logging
+from enum import Enum
+from typing import Any, Dict, List, Optional, cast
+
+import pyramid.request
+import pyramid.response
+
+from c2cgeoportal_geoportal.lib import is_intranet
+
+_LOG = logging.getLogger(__name__)
+
+
+class Cache(Enum):
+    """Enumeration for the possible cache values."""
+
+    # For responses that do not depend on authentication
+    PUBLIC = 0
+    # For responses that do not depends on authentication
+    # We use a small cache (e.g. 10s) instead of no cache to protect the service against too high traffic.
+    PUBLIC_NO = 1
+    # For responses that can depend on authentication
+    PRIVATE = 2
+    # See PUBLIC_NO and PRIVATE
+    PRIVATE_NO = 3
+
+
+CORS_METHODS = "HEAD, GET, POST, PUT, DELETE"
+
+
+def _set_cors_headers(
+    request: pyramid.request.Request,
+    response: pyramid.response.Response,
+    service_name: str,
+    service_headers_settings: Dict[str, Any],
+    credentials: bool,
+) -> None:
+    """Handle CORS requests, as specified in https://www.w3.org/TR/cors/."""
+    response.vary = (response.vary or ()) + ("Origin",)
+
+    if "Origin" not in request.headers:
+        return  # Not a CORS request if this header is missing
+    origin = request.headers["Origin"]
+
+    if request.method == "OPTIONS" and "Access-Control-Request-Method" not in request.headers:
+        _LOG.warning("CORS preflight query missing the Access-Control-Request-Method header")
+        return
+
+    allowed_origins = cast(List[str], service_headers_settings.get("access_control_allow_origin", []))
+    if origin not in allowed_origins:
+        if "*" in allowed_origins:
+            origin = "*"
+            credentials = False  # Force no credentials
+        else:
+            _LOG.warning("CORS query not allowed for origin=%s, service=%s", origin, service_name)
+            return
+
+    response.headers.update(
+        {"Access-Control-Allow-Origin": origin, "Access-Control-Allow-Methods": CORS_METHODS}
+    )
+
+    max_age = service_headers_settings.get("access_control_max_age", 3600)
+    response.headers["Access-Control-Max-Age"] = str(max_age)
+
+    if credentials:
+        response.headers["Access-Control-Allow-Credentials"] = "true"
+
+    if request.method != "OPTIONS":
+        return
+
+    response.cache_control.max_age = max_age
+
+    if not service_headers_settings or "access_control_allow_origin" not in service_headers_settings:
+        _LOG.warning("CORS query not configured for service=%s", service_name)
+        return
+
+    requested_headers = request.headers.get("Access-Control-Request-Headers", False)
+    if requested_headers:
+        # For the moment, we allow all requested headers
+        response.headers["Access-Control-Allow-Headers"] = requested_headers
+
+    # If we start using headers in responses, we'll have to add
+    # Access-Control-Expose-Headers
+
+
+def _set_common_headers(
+    request: pyramid.request.Request,
+    response: pyramid.response.Response,
+    service_headers_settings: Dict[str, Dict[str, str]],
+    cache: Cache,
+    content_type: Optional[str],
+) -> pyramid.response.Response:
+    """Set the common headers."""
+
+    response.headers.update(service_headers_settings.get("headers", {}))
+
+    if cache in (Cache.PRIVATE, Cache.PRIVATE_NO):
+        response.vary = (response.vary or ()) + ("Cookie",)
+
+    maxage = (
+        service_headers_settings.get("cache_control_max_age", 3600)
+        if cache in (Cache.PUBLIC, Cache.PRIVATE)
+        else service_headers_settings.get("cache_control_max_age_nocache", 10)
+    )
+    response.cache_control.max_age = maxage
+    if maxage == 0:
+        response.cache_control.no_cache = True
+        response.cache_control.no_store = True
+    elif cache in (Cache.PUBLIC, Cache.PUBLIC_NO):
+        response.cache_control.public = True
+    elif cache in (Cache.PRIVATE, Cache.PRIVATE_NO):
+        if hasattr(request, "user") and request.user is not None or is_intranet(request):
+            response.cache_control.private = True
+        else:
+            response.cache_control.public = True
+    else:
+        raise Exception("Invalid cache type")
+
+    if content_type is not None:
+        response.content_type = content_type
+
+    return response
+
+
+def set_common_headers(
+    request: pyramid.request.Request,
+    service_name: str,
+    cache: Cache,
+    response: pyramid.response.Response = None,
+    credentials: bool = True,
+    content_type: Optional[str] = None,
+) -> pyramid.response.Response:
+    """Set the common headers."""
+    if response is None:
+        response = request.response
+
+    headers_settings = request.registry.settings.get("headers", {})
+    service_headers_settings = headers_settings.get(service_name, {})
+
+    _set_cors_headers(request, response, service_name, service_headers_settings, credentials)
+    if request.method == "OPTIONS":
+        return response
+    return _set_common_headers(request, response, service_headers_settings, cache, content_type)