paas-charm 2.0.dev1__tar.gz → 2.0.dev4__tar.gz

{paas_charm-2.0.dev1 → paas_charm-2.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paas-charm
-Version: 2.0.dev1
+Version: 2.0.dev4
 Summary: Companion library for 12-factor app support in Charmcraft & Rockcraft.
 Author-email: Canonical IS DevOps team <is-devops-team@canonical.com>
 Project-URL: Repository, https://github.com/canonical/paas-charm
@@ -11,6 +11,9 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: charmlibs-interfaces-tracing==1.0.0
+Requires-Dist: charmlibs-interfaces-oauth==1.1.0
+Requires-Dist: charmlibs-interfaces-openfga==1.0.0
 Requires-Dist: cosl==1.10.3
 Requires-Dist: dpcharmlibs-interfaces==1.2.0
 Requires-Dist: Jinja2==3.1.6

{paas_charm-2.0.dev1 → paas_charm-2.0.dev4}/pyproject.toml

@@ -2,7 +2,7 @@
 # See LICENSE file for licensing details.
 [project]
 name = "paas-charm"
-version = "2.0.dev1"
+version = "2.0.dev4"
 description = "Companion library for 12-factor app support in Charmcraft & Rockcraft."
 readme = "README.md"
 authors = [
@@ -17,6 +17,9 @@ classifiers = [
     "Programming Language :: Python :: 3",
 ]
 dependencies = [
+    "charmlibs-interfaces-tracing==1.0.0",
+    "charmlibs-interfaces-oauth==1.1.0",
+    "charmlibs-interfaces-openfga==1.0.0",
     "cosl==1.10.3",
     "dpcharmlibs-interfaces==1.2.0",
     "Jinja2==3.1.6",
@@ -37,7 +40,7 @@ where = ["src"]
 
 [tool.uv.sources]
 # opcli is published only from the charm-ci git repository, not PyPI.
-opcli = { git = "https://github.com/canonical/charm-ci.git", tag = "v1.0.1" }
+opcli = { git = "https://github.com/canonical/charm-ci.git", tag = "v1.0.2" }
 
 [tool.setuptools.package-data]
 paas_charm = ["**/cos/**", "**/cos/**/.**", "**/*.j2", "**/templates/**/*.py", "**/templates/**/*.json"]

{paas_charm-2.0.dev1 → paas_charm-2.0.dev4}/src/paas_charm/_gunicorn/webserver.py

@@ -17,14 +17,11 @@ import ops
 from ops.pebble import ExecError, PathError
 
 from paas_charm._gunicorn.workload_config import (
-    APPLICATION_ERROR_LOG_FILE,
-    APPLICATION_LOG_FILE,
     STATSD_HOST,
 )
 from paas_charm.app import WorkloadConfig
 from paas_charm.exceptions import CharmConfigInvalidError
 from paas_charm.paas_config import LoggingFormat
-from paas_charm.utils import enable_pebble_log_forwarding
 
 logger = logging.getLogger(__name__)
 
@@ -153,21 +150,14 @@ class GunicornWebserver:  # pylint: disable=too-few-public-methods
                 if isinstance(setting_value, (int, str))
                 else int(setting_value.total_seconds())
             )
-        if enable_pebble_log_forwarding():
-            access_log = "-"
-            error_log = "-"
-        else:
-            access_log = str(APPLICATION_LOG_FILE)
-            error_log = str(APPLICATION_ERROR_LOG_FILE)
-
         jinja_environment = jinja2.Environment(
             loader=jinja2.PackageLoader("paas_charm", "templates"), autoescape=True
         )
         config = jinja_environment.get_template("gunicorn.conf.py.j2").render(
             workload_port=self._workload_config.port,
             workload_app_dir=str(self._workload_config.app_dir),
-            access_log=access_log,
-            error_log=error_log,
+            access_log="-",
+            error_log="-",
             statsd_host=str(STATSD_HOST),
             enable_tracing=self._workload_config.tracing_enabled,
             enable_json_logging=self._workload_config.logging_format == LoggingFormat.JSON,
@@ -197,7 +187,6 @@ class GunicornWebserver:  # pylint: disable=too-few-public-methods
         Raises:
             CharmConfigInvalidError: if the charm configuration is not valid.
         """
-        self._prepare_log_dir()
         webserver_config_path = str(self._config_path)
         try:
             current_webserver_config = self._container.pull(webserver_config_path)
@@ -235,16 +224,3 @@ class GunicornWebserver:  # pylint: disable=too-few-public-methods
         if is_webserver_running:
             logger.info("gunicorn config changed, reloading")
             self._container.send_signal(self._reload_signal, self._workload_config.service_name)
-
-    def _prepare_log_dir(self) -> None:
-        """Prepare access and error log directory for the application."""
-        container = self._container
-        for log in self._workload_config.log_files:
-            log_dir = str(log.parent.absolute())
-            if not container.exists(log_dir):
-                container.make_dir(
-                    log_dir,
-                    make_parents=True,
-                    user=self._workload_config.user,
-                    group=self._workload_config.group,
-                )

{paas_charm-2.0.dev1 → paas_charm-2.0.dev4}/src/paas_charm/_gunicorn/workload_config.py

@@ -9,8 +9,6 @@ from paas_charm.app import WorkloadConfig
 from paas_charm.paas_config import PaasConfig
 
 STATSD_HOST = "localhost:9125"
-APPLICATION_LOG_FILE = "/var/log/app/access.log"
-APPLICATION_ERROR_LOG_FILE = "/var/log/app/error.log"
 GUNICORN_CONFIG_DIR = "/var/lib/gunicorn"
 
 
@@ -50,10 +48,6 @@ def create_workload_config(
         app_dir=app_dir,
         state_dir=state_dir,
         service_name=framework_name,
-        log_files=[
-            pathlib.Path(APPLICATION_LOG_FILE),
-            pathlib.Path(APPLICATION_ERROR_LOG_FILE),
-        ],
         metrics_path=metrics_path,
         metrics_port=metrics_port,
         unit_name=unit_name,

{paas_charm-2.0.dev1 → paas_charm-2.0.dev4}/src/paas_charm/app.py

@@ -9,19 +9,20 @@ import logging
 import pathlib
 import urllib.parse
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING
 
 import ops
 from dpcharmlibs.interfaces import ValkeyResponseModel
 
 from paas_charm.charm_state import CharmState
 from paas_charm.database_migration import DatabaseMigration
-from paas_charm.paas_config import LoggingFormat
+from paas_charm.exceptions import PaasConfigError
+from paas_charm.paas_config import EnvVarConfig, LoggingFormat, SecretEnvVarsConfig
 
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
-    from charms.openfga_k8s.v1.openfga import OpenfgaProviderAppData
+    from charmlibs.interfaces.openfga import OpenfgaProviderAppData
     from charms.smtp_integrator.v0.smtp import SmtpRelationData
 
     from paas_charm.databases import PaaSDatabaseRelationData
@@ -52,7 +53,6 @@ class WorkloadConfig:  # pylint: disable=too-many-instance-attributes
         app_dir: the application directory in the application container.
         state_dir: the directory in the application container to store states information.
         service_name: the WSGI application pebble service name.
-        log_files: list of files to monitor.
         metrics_path: path to scrape for metrics.
         metrics_port: port on which the application exposes metrics.
         unit_name: Name of the unit. Needed to know if schedulers should run here.
@@ -69,7 +69,6 @@ class WorkloadConfig:  # pylint: disable=too-many-instance-attributes
     app_dir: pathlib.Path
     state_dir: pathlib.Path
     service_name: str
-    log_files: List[pathlib.Path]
     metrics_path: str | None = "/metrics"
     metrics_port: int = 8080
     unit_name: str
@@ -444,37 +443,198 @@ class App:  # pylint: disable=too-many-instance-attributes
         self._run_migrations()
         self._container.replan()
 
-    # 2024/04/25 - we're refactoring this method which will get rid of map_integrations_to_env
-    # wrapper function. Ignore too-complex error from flake8 for now.
-    def gen_environment(self) -> dict[str, str]:  # noqa: too-complex
-        """Generate a environment dictionary from the charm configurations.
-
-        The environment generation follows these rules:
-             1. User-defined configuration cannot overwrite built-in framework configurations,
-                even if the built-in framework application configuration value is None (undefined).
-             2. Boolean and integer-typed configuration values will be JSON encoded before
-                being passed to application.
-             3. String-typed configuration values will be passed to the application as environment
-                variables directly.
-             4. Different prefixes can be set to the environment variable names depending on the
-                framework.
+    def gen_environment(self) -> dict[str, str]:
+        """Generate the final workload environment in precedence order.
+
+        Explicit config mappings override integrations, which override library-generated
+        variables. The config/framework layer comes from ``_framework_environment``.
+
+        Returns:
+            The final environment with string-encoded values.
+        """
+        framework_sources = self._framework_config_mapping_sources()
+        env = self._framework_environment()
+        for name, value in self._generate_integration_environments(
+            prefix=self.integrations_prefix
+        ).items():
+            if name in env:
+                logger.warning(
+                    "Environment variable %r for a relation or Prometheus metrics overwrites an "
+                    "environment variable from charm configuration or framework settings",
+                    name,
+                )
+            env[name] = value
+        for name, (source, value) in self._mapped_config_environment(framework_sources).items():
+            if name in env:
+                logger.warning(
+                    "Explicit config.options mapping from %r overwrites environment variable %r",
+                    source,
+                    name,
+                )
+            env[name] = value
+        return env
+
+    def _mapped_framework_config_fields(self) -> set[str]:
+        """Get framework fields whose default outputs are explicitly renamed.
+
+        Returns:
+            Framework field names, excluding unmapped secret-key entries.
+        """
+        mappings = self._charm_state.config_options.options
+        return {
+            field
+            for option, field in self._charm_state.framework_config_fields.items()
+            if (mapping := mappings.get(option)) is not None
+            and (
+                isinstance(mapping, EnvVarConfig)
+                or (
+                    field in ("secret_key", "app_secret_key")
+                    and "value" in mapping.secret_env_vars
+                    and not isinstance(self._charm_state.framework_config.get(field), dict)
+                )
+            )
+        }
+
+    def _framework_config_mapping_sources(self) -> dict[str, str | dict[str, str]]:
+        """Read resolved framework values without borrowing unrelated generated outputs.
+
+        Returns:
+            Values keyed by exact option names, using the existing encoding and key fallback.
+        """
+        sources: dict[str, str | dict[str, str]] = {}
+        for option, mapping in self._charm_state.config_options.options.items():
+            field = self._charm_state.framework_config_fields.get(option)
+            if field is None:
+                continue
+            value = self._charm_state.framework_config.get(field)
+            if value is None and field in ("secret_key", "app_secret_key"):
+                value = self._charm_state.secret_key
+            if value is None:
+                continue
+            if isinstance(mapping, SecretEnvVarsConfig):
+                if isinstance(value, dict):
+                    sources[option] = value
+                elif field in ("secret_key", "app_secret_key"):
+                    sources[option] = {"value": encode_env(value)}
+                else:
+                    sources[option] = encode_env(value)
+            else:
+                sources[option] = encode_env(value)
+        return sources
+
+    def _mapped_config_environment(
+        self, framework_sources: dict[str, str | dict[str, str]]
+    ) -> dict[str, tuple[str, str]]:
+        """Generate explicit config destinations from their original source values.
+
+        Args:
+            framework_sources: Resolved framework outputs keyed by exact option names,
+                including secret-key fallbacks.
 
         Returns:
-            A dictionary representing the application environment variables.
+            Destinations mapped to source names and encoded values, omitting absent values.
+
+        Raises:
+            PaasConfigError: If a secret mapping receives non-secret content.
+        """
+        env: dict[str, tuple[str, str]] = {}
+        for option, mapping in self._charm_state.config_options.options.items():
+            value = (
+                framework_sources.get(option)
+                if option in self._charm_state.framework_config_fields
+                else self._charm_state.user_defined_config.get(option.replace("-", "_"))
+            )
+            if value is None:
+                continue
+            if isinstance(mapping, SecretEnvVarsConfig):
+                if not isinstance(value, collections.abc.Mapping):
+                    raise PaasConfigError(
+                        f"config.options.{option}.secret-env-vars requires secret content"
+                    )
+                for key, destination in mapping.secret_env_vars.items():
+                    if key not in value:
+                        logger.warning(
+                            "Charm configuration option %r has no secret content key %r; "
+                            "skipping mapped environment variable %r",
+                            option,
+                            key,
+                            destination,
+                        )
+                        continue
+                    env[destination] = (f"{option}.{key}", encode_env(value[key]))
+            else:
+                env[mapping.env_var] = (option, encode_env(value))
+        return env
+
+    def _unmapped_framework_config(self) -> dict[str, str | int | bool | dict[str, str]]:
+        """Keep framework defaults and secret entries that have not been renamed.
+
+        Returns:
+            Resolved framework configuration with mapped fields or secret entries omitted.
+        """
+        mapped_fields = self._mapped_framework_config_fields()
+        config = {
+            field: value
+            for field, value in self._charm_state.framework_config.items()
+            if field not in mapped_fields
+        }
+        for option, field in self._charm_state.framework_config_fields.items():
+            mapping = self._charm_state.config_options.options.get(option)
+            value = config.get(field)
+            if (
+                isinstance(mapping, SecretEnvVarsConfig)
+                and isinstance(value, dict)
+                and value.keys() & mapping.secret_env_vars.keys()
+            ):
+                remaining = {
+                    key: val for key, val in value.items() if key not in mapping.secret_env_vars
+                }
+                if remaining:
+                    config[field] = remaining
+                else:
+                    config.pop(field)
+        return config
+
+    def _framework_environment(self) -> dict[str, str]:  # noqa: too-complex
+        """Build config and library-owned variables before higher-priority overrides.
+
+        Explicitly mapped sources are omitted from their default names. Unmapped config
+        retains its existing prefixes and value encoding. Framework subclasses extend
+        this layer; ``gen_environment`` then applies relations and explicit mappings.
+
+        Returns:
+            The config/framework environment with string-encoded values.
         """
         prefix = self.configuration_prefix
         env = {}
+        mappings = {
+            option.replace("-", "_"): mapping
+            for option, mapping in self._charm_state.config_options.options.items()
+        }
         for app_config_key, app_config_value in self._charm_state.user_defined_config.items():
+            mapping = mappings.get(app_config_key)
+            if app_config_key in self._charm_state.framework_config_field_names or isinstance(
+                mapping, EnvVarConfig
+            ):
+                continue
+            if isinstance(mapping, SecretEnvVarsConfig) and app_config_value is None:
+                continue
+            mapped_keys = (
+                mapping.secret_env_vars if isinstance(mapping, SecretEnvVarsConfig) else {}
+            )
             if isinstance(app_config_value, collections.abc.Mapping):
                 for k, v in app_config_value.items():
+                    if k in mapped_keys:
+                        continue
                     env[f"{prefix}{app_config_key.upper()}_{k.replace('-', '_').upper()}"] = (
                         encode_env(v)
                     )
             else:
                 env[f"{prefix}{app_config_key.upper()}"] = encode_env(app_config_value)
 
-        framework_config = self._charm_state.framework_config
+        framework_config = self._unmapped_framework_config()
         framework_config_prefix = self.framework_config_prefix
+        mapped_fields = self._mapped_framework_config_fields()
         env.update(
             {
                 f"{framework_config_prefix}{k.upper()}": encode_env(v)
@@ -489,7 +649,7 @@ class App:  # pylint: disable=too-many-instance-attributes
         if self._charm_state.base_url:
             env[f"{prefix}BASE_URL"] = self._charm_state.base_url
         secret_key_env = f"{prefix}SECRET_KEY"
-        if secret_key_env not in env:
+        if secret_key_env not in env and not {"secret_key", "app_secret_key"} & mapped_fields:
             env[secret_key_env] = self._charm_state.secret_key
         for proxy_variable in ("http_proxy", "https_proxy", "no_proxy"):
             proxy_value = getattr(self._charm_state.proxy, proxy_variable)
@@ -500,7 +660,6 @@ class App:  # pylint: disable=too-many-instance-attributes
         if self._charm_state.peer_fqdns is not None:
             env[f"{prefix}PEER_FQDNS"] = self._charm_state.peer_fqdns
 
-        env.update(self._generate_integration_environments(prefix=self.integrations_prefix))
         return env
 
     def _generate_integration_environments(self, prefix: str = "") -> dict[str, str]:
@@ -531,6 +690,17 @@ class App:  # pylint: disable=too-many-instance-attributes
                 relation_data=self._charm_state.integrations.oauth,
             )
         )
+
+        for relation in self._charm_state.custom_relations:
+            for key, value in (relation.gen_environment() or {}).items():
+                if key in env:
+                    logger.warning(
+                        "Custom relation %s overwrites environment variable %s",
+                        relation.relation_name,
+                        key,
+                    )
+                env[key] = value
+
         return {prefix + k: v for (k, v) in env.items()}
 
     @property