c2cwsgiutils 6.1.0.dev105__py3-none-any.whl → 6.1.7.dev4__py3-none-any.whl

c2cwsgiutils/acceptance/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
-    "commander": "12.0.0",
-    "puppeteer": "22.3.0"
+    "commander": "12.1.0",
+    "puppeteer": "23.5.3"
   },
   "type": "module"
 }

c2cwsgiutils/acceptance/print.py

@@ -7,7 +7,7 @@ import requests
 
 from c2cwsgiutils.acceptance import connection, utils
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 class PrintConnection(connection.Connection):
@@ -30,9 +30,11 @@ class PrintConnection(connection.Connection):
         utils.retry_timeout(functools.partial(self.get_capabilities, app=app), timeout=timeout)
 
     def get_capabilities(self, app: str) -> Any:
+        """Get the capabilities for the given application."""
         return self.get_json(app + "/capabilities.json", cache_expected=connection.CacheExpected.YES)
 
     def get_example_requests(self, app: str) -> dict[str, Any]:
+        """Get the example requests for the given application."""
         samples = self.get_json(app + "/exampleRequest.json", cache_expected=connection.CacheExpected.YES)
         out = {}
         for name, value in samples.items():
@@ -40,12 +42,13 @@ class PrintConnection(connection.Connection):
         return out
 
     def get_pdf(self, app: str, request: dict[str, Any], timeout: int = 60) -> requests.Response:
+        """Create a report and wait for it to be ready."""
         create_report = self.post_json(app + "/report.pdf", json=request)
-        LOG.debug("create_report=%s", create_report)
+        _LOG.debug("create_report=%s", create_report)
         ref = create_report["ref"]
 
         status = utils.retry_timeout(functools.partial(self._check_completion, ref), timeout=timeout)
-        LOG.debug("status=%s", repr(status))
+        _LOG.debug("status=%s", repr(status))
         assert status["status"] == "finished"
 
         report = self.get_raw("report/" + ref)
@@ -59,4 +62,5 @@ class PrintConnection(connection.Connection):
         return None
 
     def get_apps(self) -> Any:
+        """Get the list of available applications."""
         return self.get_json("apps.json", cache_expected=connection.CacheExpected.YES)

c2cwsgiutils/acceptance/utils.py

@@ -29,12 +29,10 @@ def retry_timeout(what: Callable[[], Any], timeout: float = _DEFAULT_TIMEOUT, in
     Retry the function until the timeout.
 
     Arguments:
-
         what: the function to try
         timeout: the timeout to get a success
         interval: the interval between try
     """
-
     timeout = time.perf_counter() + timeout
     while True:
         error = ""
@@ -58,7 +56,7 @@ def approx(struct: Any, **kwargs: Any) -> Any:
 
     See pytest.approx
     """
-    import boltons.iterutils
+    import boltons.iterutils  # pylint: disable=import-outside-toplevel
 
     if isinstance(struct, float):
         return pytest.approx(struct, **kwargs)

c2cwsgiutils/auth.py

@@ -11,21 +11,21 @@ from requests_oauthlib import OAuth2Session
 
 from c2cwsgiutils.config_utils import config_bool, env_or_config, env_or_settings
 
-COOKIE_AGE = 7 * 24 * 3600
+_COOKIE_AGE = 7 * 24 * 3600
 SECRET_PROP = "c2c.secret"  # nosec  # noqa
 SECRET_ENV = "C2C_SECRET"  # nosec  # noqa
-GITHUB_REPOSITORY_PROP = "c2c.auth.github.repository"
-GITHUB_REPOSITORY_ENV = "C2C_AUTH_GITHUB_REPOSITORY"
-GITHUB_ACCESS_TYPE_PROP = "c2c.auth.github.access_type"
-GITHUB_ACCESS_TYPE_ENV = "C2C_AUTH_GITHUB_ACCESS_TYPE"
+_GITHUB_REPOSITORY_PROP = "c2c.auth.github.repository"
+_GITHUB_REPOSITORY_ENV = "C2C_AUTH_GITHUB_REPOSITORY"
+_GITHUB_ACCESS_TYPE_PROP = "c2c.auth.github.access_type"
+_GITHUB_ACCESS_TYPE_ENV = "C2C_AUTH_GITHUB_ACCESS_TYPE"
 GITHUB_AUTH_URL_PROP = "c2c.auth.github.auth_url"
 GITHUB_AUTH_URL_ENV = "C2C_AUTH_GITHUB_AUTH_URL"
 GITHUB_TOKEN_URL_PROP = "c2c.auth.github.token_url"  # nosec
 GITHUB_TOKEN_URL_ENV = "C2C_AUTH_GITHUB_TOKEN_URL"  # nosec
 GITHUB_USER_URL_PROP = "c2c.auth.github.user_url"
 GITHUB_USER_URL_ENV = "C2C_AUTH_GITHUB_USER_URL"
-GITHUB_REPO_URL_PROP = "c2c.auth.github.repo_url"
-GITHUB_REPO_URL_ENV = "C2C_AUTH_GITHUB_REPO_URL"
+_GITHUB_REPO_URL_PROP = "c2c.auth.github.repo_url"
+_GITHUB_REPO_URL_ENV = "C2C_AUTH_GITHUB_REPO_URL"
 GITHUB_CLIENT_ID_PROP = "c2c.auth.github.client_id"
 GITHUB_CLIENT_ID_ENV = "C2C_AUTH_GITHUB_CLIENT_ID"
 GITHUB_CLIENT_SECRET_PROP = "c2c.auth.github.client_secret"  # nosec # noqa
@@ -44,7 +44,7 @@ USE_SESSION_PROP = "c2c.use_session"
 USE_SESSION_ENV = "C2C_USE_SESSION"
 
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 class AuthConfig(TypedDict, total=False):
@@ -87,14 +87,16 @@ def _is_auth_secret(request: pyramid.request.Request) -> bool:
 
     if secret_hash is not None:
         if secret_hash == "" or secret == "":  # nosec
-            # logout
+            # Logout
             request.response.delete_cookie(SECRET_ENV)
             return False
         if secret_hash != _hash_secret(expected):
             return False
-        # login or refresh the cookie
-        request.response.set_cookie(SECRET_ENV, secret_hash, max_age=COOKIE_AGE, httponly=True)
-        # since this could be used from outside c2cwsgiutils views, we cannot set the path to c2c
+        # Login or refresh the cookie
+        request.response.set_cookie(
+            SECRET_ENV, secret_hash, max_age=_COOKIE_AGE, httponly=True, secure=True, samesite="Strict"
+        )
+        # Since this could be used from outside c2cwsgiutils views, we cannot set the path to c2c
         return True
     return False
 
@@ -125,7 +127,7 @@ def _is_auth_user_github(request: pyramid.request.Request) -> tuple[bool, UserDe
                 ),
             )
         except jwt.exceptions.InvalidTokenError as e:
-            LOG.warning("Error on decoding JWT token: %s", e)
+            _LOG.warning("Error on decoding JWT token: %s", e)
     return False, {}
 
 
@@ -179,11 +181,11 @@ def auth_type(settings: Optional[Mapping[str, Any]]) -> Optional[AuthenticationT
     has_client_secret = (
         env_or_settings(settings, GITHUB_CLIENT_SECRET_ENV, GITHUB_CLIENT_SECRET_PROP, "") != ""
     )
-    has_repo = env_or_settings(settings, GITHUB_REPOSITORY_ENV, GITHUB_REPOSITORY_PROP, "") != ""
+    has_repo = env_or_settings(settings, _GITHUB_REPOSITORY_ENV, _GITHUB_REPOSITORY_PROP, "") != ""
     secret = env_or_settings(settings, GITHUB_AUTH_SECRET_ENV, GITHUB_AUTH_SECRET_PROP, "")
     has_secret = len(secret) >= 16
     if secret and not has_secret:
-        LOG.error(
+        _LOG.error(
             "You set a too short secret (length: %i) to protect the admin page, it should have "
             "at lease a length of 16",
             len(secret),
@@ -203,10 +205,11 @@ def check_access(
 
     If the authentication type is not GitHub, this function is equivalent to is_auth.
 
-    `repo` is the repository to check access to (<organization>/<repository>).
-    `access_type` is the type of access to check (admin|push|pull).
+    Arguments:
+        request: is the request object.
+        repo: is the repository to check access to (<organization>/<repository>).
+        access_type: is the type of access to check (admin|push|pull).
     """
-
     if not is_auth(request):
         return False
 
@@ -220,8 +223,8 @@ def check_access(
             "github_repository": (
                 env_or_settings(
                     settings,
-                    GITHUB_REPOSITORY_ENV,
-                    GITHUB_REPOSITORY_PROP,
+                    _GITHUB_REPOSITORY_ENV,
+                    _GITHUB_REPOSITORY_PROP,
                     "",
                 )
                 if repo is None
@@ -230,8 +233,8 @@ def check_access(
             "github_access_type": (
                 env_or_settings(
                     settings,
-                    GITHUB_ACCESS_TYPE_ENV,
-                    GITHUB_ACCESS_TYPE_PROP,
+                    _GITHUB_ACCESS_TYPE_ENV,
+                    _GITHUB_ACCESS_TYPE_PROP,
                     "pull",
                 )
                 if access_type is None
@@ -243,7 +246,6 @@ def check_access(
 
 def check_access_config(request: pyramid.request.Request, auth_config: AuthConfig) -> bool:
     """Check if the user has access to the resource."""
-
     auth, user = is_auth_user(request)
     if not auth:
         return False
@@ -259,8 +261,8 @@ def check_access_config(request: pyramid.request.Request, auth_config: AuthConfi
 
     repo_url = env_or_settings(
         settings,
-        GITHUB_REPO_URL_ENV,
-        GITHUB_REPO_URL_PROP,
+        _GITHUB_REPO_URL_ENV,
+        _GITHUB_REPO_URL_PROP,
         "https://api.github.com/repos",
     )
     repository = oauth.get(f"{repo_url}/{auth_config.get('github_repository')}").json()

c2cwsgiutils/broadcast/__init__.py

@@ -10,9 +10,9 @@ import pyramid.config
 from c2cwsgiutils import config_utils, redis_utils
 from c2cwsgiutils.broadcast import interface, local, redis
 
-LOG = logging.getLogger(__name__)
-BROADCAST_ENV_KEY = "C2C_BROADCAST_PREFIX"
-BROADCAST_CONFIG_KEY = "c2c.broadcast_prefix"
+_LOG = logging.getLogger(__name__)
+_BROADCAST_ENV_KEY = "C2C_BROADCAST_PREFIX"
+_BROADCAST_CONFIG_KEY = "c2c.broadcast_prefix"
 
 _broadcaster: Optional[interface.BaseBroadcaster] = None
 
@@ -29,38 +29,37 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
 
     Otherwise, fall back to a fake local implementation.
     """
-    global _broadcaster
+    global _broadcaster  # pylint: disable=global-statement
     broadcast_prefix = config_utils.env_or_config(
-        config, BROADCAST_ENV_KEY, BROADCAST_CONFIG_KEY, "broadcast_api_"
+        config, _BROADCAST_ENV_KEY, _BROADCAST_CONFIG_KEY, "broadcast_api_"
     )
     master, slave, _ = redis_utils.get(config.get_settings() if config else None)
     if _broadcaster is None:
         if master is not None and slave is not None:
             _broadcaster = redis.RedisBroadcaster(broadcast_prefix, master, slave)
-            LOG.info("Broadcast service setup using Redis implementation")
+            _LOG.info("Broadcast service setup using Redis implementation")
         else:
             _broadcaster = local.LocalBroadcaster()
-            LOG.info("Broadcast service setup using local implementation")
+            _LOG.info("Broadcast service setup using local implementation")
     elif isinstance(_broadcaster, local.LocalBroadcaster) and master is not None and slave is not None:
-        LOG.info("Switching from a local broadcaster to a Redis broadcaster")
+        _LOG.info("Switching from a local broadcaster to a Redis broadcaster")
         prev_broadcaster = _broadcaster
         _broadcaster = redis.RedisBroadcaster(broadcast_prefix, master, slave)
         _broadcaster.copy_local_subscriptions(prev_broadcaster)
 
 
 def _get(need_init: bool = False) -> interface.BaseBroadcaster:
-    global _broadcaster
+    global _broadcaster  # pylint: disable=global-statement
     if _broadcaster is None:
         if need_init:
-            LOG.error("Broadcast functionality used before it is setup")
+            _LOG.error("Broadcast functionality used before it is setup")
         _broadcaster = local.LocalBroadcaster()
     return _broadcaster
 
 
 def cleanup() -> None:
     """Cleanup the broadcaster to force to reinitialize it."""
-
-    global _broadcaster
+    global _broadcaster  # pylint: disable=global-statement
     _broadcaster = None
 
 
@@ -96,21 +95,21 @@ def broadcast(
 
 # We can also templatise the argument with Python 3.10
 # See: https://www.python.org/dev/peps/pep-0612/
-_DECORATOR_RETURN = TypeVar("_DECORATOR_RETURN")
+_DecoratorReturn = TypeVar("_DecoratorReturn")
 
 
 def decorator(
     channel: Optional[str] = None, expect_answers: bool = False, timeout: float = 10
-) -> Callable[[Callable[..., _DECORATOR_RETURN]], Callable[..., Optional[list[_DECORATOR_RETURN]]]]:
+) -> Callable[[Callable[..., _DecoratorReturn]], Callable[..., Optional[list[_DecoratorReturn]]]]:
     """
     Decorate function will be called through the broadcast functionality.
 
     If expect_answers is set to True, the returned value will be a list of all the answers.
     """
 
-    def impl(func: Callable[..., _DECORATOR_RETURN]) -> Callable[..., Optional[list[_DECORATOR_RETURN]]]:
+    def impl(func: Callable[..., _DecoratorReturn]) -> Callable[..., Optional[list[_DecoratorReturn]]]:
         @functools.wraps(func)
-        def wrapper(**kwargs: Any) -> Optional[list[_DECORATOR_RETURN]]:
+        def wrapper(**kwargs: Any) -> Optional[list[_DecoratorReturn]]:
             return broadcast(_channel, params=kwargs, expect_answers=expect_answers, timeout=timeout)
 
         if channel is None:

c2cwsgiutils/broadcast/interface.py

@@ -8,14 +8,14 @@ class BaseBroadcaster:
 
     @abstractmethod
     def subscribe(self, channel: str, callback: Callable[..., Any]) -> None:
-        pass  # pragma: no cover
+        """Subscribe to a channel."""
 
     @abstractmethod
     def unsubscribe(self, channel: str) -> None:
-        pass  # pragma: no cover
+        """Unsubscribe from a channel."""
 
     @abstractmethod
     def broadcast(
         self, channel: str, params: Mapping[str, Any], expect_answers: bool, timeout: float
     ) -> Optional[list[Any]]:
-        pass  # pragma: no cover
+        """Broadcast a message to a channel."""

c2cwsgiutils/broadcast/local.py

@@ -25,4 +25,5 @@ class LocalBroadcaster(interface.BaseBroadcaster):
         return answers if expect_answers else None
 
     def get_subscribers(self) -> Mapping[str, Callable[..., Any]]:
+        """Get the subscribers for testing purposes."""
         return self._subscribers

c2cwsgiutils/broadcast/redis.py

@@ -11,7 +11,7 @@ import redis
 
 from c2cwsgiutils.broadcast import interface, local, utils
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 class RedisBroadcaster(interface.BaseBroadcaster):
@@ -23,7 +23,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
         master: "redis.client.Redis[str]",
         slave: "redis.client.Redis[str]",
     ) -> None:
-        from c2cwsgiutils import redis_utils
+        from c2cwsgiutils import redis_utils  # pylint: disable=import-outside-toplevel
 
         self._master = master
         self._slave = slave
@@ -41,24 +41,24 @@ class RedisBroadcaster(interface.BaseBroadcaster):
 
     def subscribe(self, channel: str, callback: Callable[..., Any]) -> None:
         def wrapper(message: Mapping[str, Any]) -> None:
-            LOG.debug("Received a broadcast on %s: %s", message["channel"], repr(message["data"]))
+            _LOG.debug("Received a broadcast on %s: %s", message["channel"], repr(message["data"]))
             data = json.loads(message["data"])
             try:
                 response = callback(**data["params"])
             except Exception as e:  # pragma: no cover  # pylint: disable=broad-except
-                LOG.error("Failed handling a broadcast message", exc_info=True)
+                _LOG.error("Failed handling a broadcast message", exc_info=True)
                 response = {"status": 500, "message": str(e)}
             answer_channel = data.get("answer_channel")
             if answer_channel is not None:
-                LOG.debug("Sending broadcast answer on %s", answer_channel)
+                _LOG.debug("Sending broadcast answer on %s", answer_channel)
                 self._master.publish(answer_channel, json.dumps(utils.add_host_info(response)))
 
         actual_channel = self._get_channel(channel)
-        LOG.debug("Subscribing %s.%s to %s", callback.__module__, callback.__name__, actual_channel)
+        _LOG.debug("Subscribing %s.%s to %s", callback.__module__, callback.__name__, actual_channel)
         self._pub_sub.subscribe(**{actual_channel: wrapper})
 
     def unsubscribe(self, channel: str) -> None:
-        LOG.debug("Unsubscribing from %s")
+        _LOG.debug("Unsubscribing from %s")
         actual_channel = self._get_channel(channel)
         self._pub_sub.unsubscribe(actual_channel)
 
@@ -79,7 +79,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
         assert self._thread.is_alive()
 
         def callback(msg: Mapping[str, Any]) -> None:
-            LOG.debug("Received a broadcast answer on %s", msg["channel"])
+            _LOG.debug("Received a broadcast answer on %s", msg["channel"])
             with cond:
                 answers.append(json.loads(msg["data"]))
                 cond.notify()
@@ -87,7 +87,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
         answer_channel = self._get_channel(channel) + "".join(
             random.choice(string.ascii_uppercase + string.digits) for _ in range(10)  # nosec
         )
-        LOG.debug("Subscribing for broadcast answers on %s", answer_channel)
+        _LOG.debug("Subscribing for broadcast answers on %s", answer_channel)
         self._pub_sub.subscribe(**{answer_channel: callback})
         message = {"params": params, "answer_channel": answer_channel}
 
@@ -99,7 +99,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
                 while len(answers) < nb_received:
                     to_wait = timeout_time - time.perf_counter()
                     if to_wait <= 0.0:  # pragma: no cover
-                        LOG.warning(
+                        _LOG.warning(
                             "timeout waiting for %d/%d answers on %s",
                             len(answers),
                             nb_received,
@@ -115,11 +115,12 @@ class RedisBroadcaster(interface.BaseBroadcaster):
 
     def _broadcast(self, channel: str, message: Mapping[str, Any]) -> int:
         actual_channel = self._get_channel(channel)
-        LOG.debug("Sending a broadcast on %s", actual_channel)
+        _LOG.debug("Sending a broadcast on %s", actual_channel)
         nb_received = self._master.publish(actual_channel, json.dumps(message))
-        LOG.debug("Broadcast on %s sent to %d listeners", actual_channel, nb_received)
+        _LOG.debug("Broadcast on %s sent to %d listeners", actual_channel, nb_received)
         return nb_received
 
     def copy_local_subscriptions(self, prev_broadcaster: local.LocalBroadcaster) -> None:
+        """Copy the subscriptions from a local broadcaster."""
         for channel, callback in prev_broadcaster.get_subscribers().items():
             self.subscribe(channel, callback)

c2cwsgiutils/client_info.py

@@ -1,6 +1,9 @@
+import logging
+import os
 import re
 from typing import Any, Callable
 
+_LOG = logging.getLogger(__name__)
 SEP_RE = re.compile(r", *")
 
 
@@ -22,6 +25,15 @@ class Filter:
         else:
             _handle_others(environ)
 
+        if "C2CWSGIUTILS_FORCE_PROTO" in os.environ:
+            environ["wsgi.url_scheme"] = os.environ["C2CWSGIUTILS_FORCE_PROTO"]
+        if "C2CWSGIUTILS_FORCE_HOST" in os.environ:
+            environ["HTTP_HOST"] = os.environ["C2CWSGIUTILS_FORCE_HOST"]
+        if "C2CWSGIUTILS_FORCE_SERVER_NAME" in os.environ:
+            environ["SERVER_NAME"] = os.environ["C2CWSGIUTILS_FORCE_SERVER_NAME"]
+        if "C2CWSGIUTILS_FORCE_REMOTE_ADDR" in os.environ:
+            environ["REMOTE_ADDR"] = os.environ["C2CWSGIUTILS_FORCE_REMOTE_ADDR"]
+
         return self._application(environ, start_response)
 
 
@@ -57,7 +69,12 @@ def _handle_forwarded(environ: dict[str, str]) -> None:
         if "HTTP_" + header in environ:
             environ["HTTP_ORIGINAL_" + header] = environ.pop("HTTP_" + header)
     forwarded = SEP_RE.split(environ.pop("HTTP_FORWARDED"))[0]
-    fields = dict(tuple(f.split("=", maxsplit=1)) for f in forwarded.split(";"))
+    parts = forwarded.split(";")
+    ignored_parts = [part for part in parts if "=" not in part]
+    if ignored_parts:
+        _LOG.warning("Some parts of the Forwarded header are ignored: %s", ";".join(ignored_parts))
+    parts = [part for part in parts if "=" in part]
+    fields = dict(tuple(f.split("=", maxsplit=1)) for f in parts)
     if "by" in fields:
         environ["SERVER_NAME"] = fields["by"]
     if "for" in fields:
@@ -71,4 +88,5 @@ def _handle_forwarded(environ: dict[str, str]) -> None:
 
 def filter_factory(*args: Any, **kwargs: Any) -> Callable[..., Any]:
     """Get the filter."""
+    del args, kwargs  # unused
     return Filter

c2cwsgiutils/coverage_setup.py

@@ -5,7 +5,7 @@ from typing import Optional
 
 import pyramid.config
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 def init() -> None:
@@ -16,11 +16,12 @@ def init() -> None:
 
 def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
     """Initialize the code coverage."""
+    del config  # unused
     if os.environ.get("COVERAGE", "0") != "1":
         return
-    import coverage
+    import coverage  # pylint: disable=import-outside-toplevel
 
-    LOG.warning("Setting up code coverage")
+    _LOG.warning("Setting up code coverage")
     report_dir = "/tmp/coverage/api"  # nosec
     os.makedirs(report_dir, exist_ok=True)
     cov = coverage.Coverage(