sovereign 0.25.3__tar.gz → 0.26.0__tar.gz

{sovereign-0.25.3 → sovereign-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sovereign
-Version: 0.25.3
+Version: 0.26.0
 Summary: Envoy Proxy control-plane written in Python
 Home-page: https://pypi.org/project/sovereign/
 License: Apache-2.0
@@ -41,7 +41,7 @@ Requires-Dist: cryptography (>=42.0.5,<43.0.0)
 Requires-Dist: datadog (>=0.47.0,<0.48.0) ; extra == "statsd"
 Requires-Dist: fastapi (>=0.110.0,<0.111.0)
 Requires-Dist: glom (>=23.3.0,<24.0.0)
-Requires-Dist: gunicorn (>=21.2.0,<22.0.0)
+Requires-Dist: gunicorn (>=22.0.0,<23.0.0)
 Requires-Dist: httptools (>=0.6.0,<0.7.0) ; extra == "httptools"
 Requires-Dist: orjson (>=3.9.15,<4.0.0) ; extra == "orjson"
 Requires-Dist: redis (<=5.0.0)

{sovereign-0.25.3 → sovereign-0.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sovereign"
-version = "0.25.3"
+version = "0.26.0"
 description = "Envoy Proxy control-plane written in Python"
 license = "Apache-2.0"
 packages = [
@@ -37,12 +37,15 @@ sovereign = 'sovereign.server:main'
 "inline" = "sovereign.sources.inline:Inline"
 
 [tool.poetry.plugins."sovereign.modifiers"]
-"sovereign_3rd_party_test" = "sovereign.modifiers.test:Test"
+"sovereign_3rd_party_test" = "sovereign.testing.modifiers:Test"
+
+[tool.poetry.plugins."sovereign.loaders"]
+"example" = "sovereign.testing.loaders:Multiply"
 
 [tool.poetry.dependencies]
 python = "^3.11"
 uvicorn = "^0.23.2"
-gunicorn = "^21.2.0"
+gunicorn = "^22.0.0"
 aiofiles = "^23.2.1"
 requests = "^2.31.0"
 PyYAML = "^6.0.1"

{sovereign-0.25.3 → sovereign-0.26.0}/src/sovereign/app.py

@@ -1,9 +1,11 @@
 import asyncio
 import traceback
-import uvicorn
 from collections import namedtuple
+
+import uvicorn
 from fastapi import FastAPI, Request
 from fastapi.responses import RedirectResponse, FileResponse, Response, JSONResponse
+
 from sovereign import (
     __version__,
     config,
@@ -14,12 +16,12 @@ from sovereign import (
     logs,
 )
 from sovereign.error_info import ErrorInfo
+from sovereign.utils.resources import get_package_file
 from sovereign.views import crypto, discovery, healthchecks, admin, interface
 from sovereign.middlewares import (
     RequestContextLogMiddleware,
     LoggingMiddleware,
 )
-from sovereign.utils.resources import get_package_file
 
 Router = namedtuple("Router", "module tags prefix")
 

{sovereign-0.25.3 → sovereign-0.26.0}/src/sovereign/config_loader.py

@@ -1,7 +1,7 @@
 import os
 import json
 from enum import Enum
-from typing import Any, Dict, Callable, Union
+from typing import Any, Dict, Callable, Union, Protocol
 from types import ModuleType
 import yaml
 import jinja2
@@ -14,6 +14,11 @@ from sovereign.utils.resources import get_package_file_bytes
 
 
 class Serialization(Enum):
+    """
+    Types of deserialization available in Sovereign
+    for loading configuration field values.
+    """
+
     yaml = "yaml"
     json = "json"
     orjson = "orjson"
@@ -22,18 +27,7 @@ class Serialization(Enum):
     jinja2 = "jinja2"
     string = "string"
     raw = "raw"
-
-
-class Protocol(Enum):
-    file = "file"
-    http = "http"
-    https = "https"
-    pkgdata = "pkgdata"
-    env = "env"
-    module = "module"
-    s3 = "s3"
-    python = "python"
-    inline = "inline"
+    skip = "skip"
 
 
 jinja_env = jinja2.Environment(autoescape=True)
@@ -56,6 +50,7 @@ serializers: Dict[Serialization, Callable[[Any], Any]] = {
     Serialization.raw: passthrough,
 }
 
+
 try:
     import ujson
 
@@ -99,8 +94,13 @@ except ImportError:
     boto3 = None
 
 
+class CustomLoader(Protocol):
+    def load(self, path: str, ser: Serialization) -> Any:
+        ...
+
+
 class Loadable(BaseModel):
-    protocol: Protocol = Protocol.http
+    protocol: str = "http"
     serialization: Serialization = Serialization.yaml
     path: str
 
@@ -113,26 +113,25 @@ class Loadable(BaseModel):
             raise
 
     @staticmethod
-    def from_legacy_fmt(s: str) -> "Loadable":
-        if "://" not in s:
+    def from_legacy_fmt(fmt_string: str) -> "Loadable":
+        if "://" not in fmt_string:
             return Loadable(
-                protocol=Protocol.inline, serialization=Serialization.string, path=s
+                protocol="inline", serialization=Serialization.string, path=fmt_string
             )
         try:
-            scheme, path = s.split("://")
+            scheme, path = fmt_string.split("://")
         except ValueError:
-            raise ValueError(s)
+            raise ValueError(fmt_string)
         try:
-            p, s = scheme.split("+")
+            proto, ser = scheme.split("+")
         except ValueError:
-            p, s = scheme, "yaml"
+            proto, ser = scheme, "yaml"
 
-        proto: Protocol = Protocol(p)
-        serialization: Serialization = Serialization(s)
-        if proto in (Protocol.python, Protocol.module):
+        serialization: Serialization = Serialization(ser)
+        if proto in ("python", "module"):
             serialization = Serialization.raw
-        if proto in (Protocol.http, Protocol.https):
-            path = "://".join([proto.value, path])
+        if proto in ("http", "https"):
+            path = "://".join([proto, path])
 
         return Loadable(
             protocol=proto,
@@ -145,32 +144,32 @@ def raise_(e: Exception) -> Exception:
     raise e
 
 
-def load_file(path: str, loader: Serialization) -> Any:
+def load_file(path: str, ser: Serialization) -> Any:
     with open(path) as f:
         contents = f.read()
         try:
-            return serializers[loader](contents)
+            return serializers[ser](contents)
         except FileNotFoundError:
             raise FileNotFoundError(f"Unable to load {path}")
 
 
-def load_package_data(path: str, loader: Serialization) -> Any:
+def load_package_data(path: str, ser: Serialization) -> Any:
     pkg, pkg_file = path.split(":")
     data = get_package_file_bytes(pkg, pkg_file)
-    return serializers[loader](data)
+    return serializers[ser](data)
 
 
-def load_http(path: str, loader: Serialization) -> Any:
+def load_http(path: str, ser: Serialization) -> Any:
     response = requests.get(path)
     response.raise_for_status()
     data = response.text
-    return serializers[loader](data)
+    return serializers[ser](data)
 
 
-def load_env(variable: str, loader: Serialization = Serialization.raw) -> Any:
+def load_env(variable: str, ser: Serialization = Serialization.raw) -> Any:
     data = os.getenv(variable)
     try:
-        return serializers[loader](data)
+        return serializers[ser](data)
     except AttributeError as e:
         raise AttributeError(
             f"Unable to read environment variable {variable}: {repr(e)}"
@@ -188,7 +187,7 @@ def load_module(name: str, _: Serialization = Serialization.raw) -> Any:
     return imported
 
 
-def load_s3(path: str, loader: Serialization = Serialization.raw) -> Any:
+def load_s3(path: str, ser: Serialization = Serialization.raw) -> Any:
     if isinstance(boto3, type(None)):
         raise ImportError(
             "boto3 must be installed to load S3 paths. Use ``pip install sovereign[boto]``"
@@ -197,7 +196,7 @@ def load_s3(path: str, loader: Serialization = Serialization.raw) -> Any:
     s3 = boto3.client("s3")
     response = s3.get_object(Bucket=bucket, Key=key)
     data = "".join([chunk.decode() for chunk in response["Body"]])
-    return serializers[loader](data)
+    return serializers[ser](data)
 
 
 def load_python(path: str, _: Serialization = Serialization.raw) -> ModuleType:
@@ -210,14 +209,14 @@ def load_inline(path: str, _: Serialization = Serialization.raw) -> Any:
     return str(path)
 
 
-loaders: Dict[Protocol, Callable[[str, Serialization], Union[str, Any]]] = {
-    Protocol.file: load_file,
-    Protocol.pkgdata: load_package_data,
-    Protocol.http: load_http,
-    Protocol.https: load_http,
-    Protocol.env: load_env,
-    Protocol.module: load_module,
-    Protocol.s3: load_s3,
-    Protocol.python: load_python,
-    Protocol.inline: load_inline,
+loaders: Dict[str, Callable[[str, Serialization], Union[str, Any]]] = {
+    "file": load_file,
+    "pkgdata": load_package_data,
+    "http": load_http,
+    "https": load_http,
+    "env": load_env,
+    "module": load_module,
+    "s3": load_s3,
+    "python": load_python,
+    "inline": load_inline,
 }

{sovereign-0.25.3 → sovereign-0.26.0}/src/sovereign/context.py

@@ -13,6 +13,8 @@ from typing import (
 )
 
 from fastapi import HTTPException
+from sovereign import config_loader
+from sovereign.utils.entry_point_loader import EntryPointLoader
 from structlog.stdlib import BoundLogger
 
 from sovereign.config_loader import Loadable
@@ -53,6 +55,14 @@ class TemplateContext:
         self.stats = stats
         # initial load
         self.context: Dict[str, Any] = {}
+        entry_points = EntryPointLoader("loaders")
+        for entry_point in entry_points.groups["loaders"]:
+            custom_loader = entry_point.load()
+            try:
+                func = custom_loader.load
+            except AttributeError:
+                raise AttributeError("Custom loader does not implement .load()")
+            config_loader.loaders[entry_point.name] = func
         asyncio.run(self.load_context_variables())
 
     async def start_refresh_context(self) -> NoReturn:
@@ -60,7 +70,6 @@ class TemplateContext:
             await poll_forever_cron(self.refresh_cron, self.refresh_context)
         elif self.refresh_rate is not None:
             await poll_forever(self.refresh_rate, self.refresh_context)
-
         raise RuntimeError("Failed to start refresh_context, this should never happen")
 
     async def refresh_context(self) -> None:
@@ -68,25 +77,25 @@ class TemplateContext:
 
     async def _load_context(
         self,
-        context_name: str,
-        context_config: Loadable | str,
+        name: str,
+        loader: Loadable | str,
         refresh_num_retries: int,
         refresh_retry_interval_secs: int,
     ) -> LoadContextResponse:
         retries_left = refresh_num_retries
-        context_response = {}
+        response = {}
 
         while True:
             try:
-                if isinstance(context_config, Loadable):
-                    context_response = context_config.load()
-                elif isinstance(context_config, str):
-                    context_response = Loadable.from_legacy_fmt(context_config).load()
+                if isinstance(loader, Loadable):
+                    response = loader.load()
+                elif isinstance(loader, str):
+                    response = Loadable.from_legacy_fmt(loader).load()
                 self.stats.increment(
                     "context.refresh.success",
-                    tags=[f"context:{context_name}"],
+                    tags=[f"context:{name}"],
                 )
-                return LoadContextResponse(context_name, context_response)
+                return LoadContextResponse(name, response)
             # pylint: disable=broad-except
             except Exception as e:
                 retries_left -= 1
@@ -95,34 +104,29 @@ class TemplateContext:
                     self.logger.error(str(e), traceback=tb)
                     self.stats.increment(
                         "context.refresh.error",
-                        tags=[f"context:{context_name}"],
+                        tags=[f"context:{name}"],
                     )
-                    return LoadContextResponse(context_name, context_response, False)
+                    return LoadContextResponse(name, response, False)
                 else:
                     await asyncio.sleep(refresh_retry_interval_secs)
 
     async def load_context_variables(self) -> None:
-        context_coroutines: list[Awaitable[LoadContextResponse]] = []
-        for context_name, context_config in self.configured_context.items():
-            context_coroutines.append(
+        coroutines: list[Awaitable[LoadContextResponse]] = []
+        for name, conf in self.configured_context.items():
+            coroutines.append(
                 self._load_context(
-                    context_name,
-                    context_config,
+                    name,
+                    conf,
                     self.refresh_num_retries,
                     self.refresh_retry_interval_secs,
                 )
             )
 
-        context_results: list[LoadContextResponse] = await asyncio.gather(
-            *context_coroutines
-        )
+        results: list[LoadContextResponse] = await asyncio.gather(*coroutines)
 
-        for context_result in context_results:
-            if (
-                context_result.success
-                or context_result.context_name not in self.context
-            ):
-                self.context[context_result.context_name] = context_result.context
+        for res in results:
+            if res.success or res.context_name not in self.context:
+                self.context[res.context_name] = res.context
 
         if "crypto" not in self.context and self.crypto:
             self.context["crypto"] = self.crypto
@@ -162,7 +166,9 @@ class TemplateContext:
         ret = self.build_new_context_from_instances(
             node_value=self.poller.extract_node_key(request.node),
         )
+        ret["__hide_from_ui"] = lambda v: v
         if request.hide_private_keys:
+            ret["__hide_from_ui"] = lambda _: "(value hidden)"
             ret["crypto"] = CipherContainer.from_encryption_configs(
                 encryption_configs=[EncryptionConfig("", EncryptionType.DISABLED)],
                 logger=self.logger,

{sovereign-0.25.3 → sovereign-0.26.0}/src/sovereign/schemas.py

@@ -19,7 +19,7 @@ from pydantic import (
     validator,
 )
 
-from sovereign.config_loader import Loadable, Protocol, Serialization, jinja_env
+from sovereign.config_loader import Loadable, Serialization, jinja_env
 from sovereign.utils.crypto.suites import EncryptionType
 from sovereign.utils.version_info import compute_hash
 
@@ -132,7 +132,7 @@ class XdsTemplate:
             self.loadable: Loadable = Loadable.from_legacy_fmt(path)
         elif isinstance(path, Loadable):
             self.loadable = path
-        self.is_python_source = self.loadable.protocol == Protocol.python
+        self.is_python_source = self.loadable.protocol == "python"
         self.source = self.load_source()
         template_ast = jinja_env.parse(self.source)
         self.jinja_variables = meta.find_undeclared_variables(template_ast)
@@ -177,7 +177,7 @@ class XdsTemplate:
             # we can simply read and return the source of it.
             old_protocol = self.loadable.protocol
             old_serialization = self.loadable.serialization
-            self.loadable.protocol = Protocol("inline")
+            self.loadable.protocol = "inline"
             self.loadable.serialization = Serialization("string")
             ret = self.loadable.load()
             self.loadable.protocol = old_protocol

sovereign-0.26.0/src/sovereign/testing/loaders.py

@@ -0,0 +1,9 @@
+from typing import Any
+from sovereign.config_loader import CustomLoader, Serialization
+
+
+class Multiply(CustomLoader):
+    @staticmethod
+    def load(path: str, ser: Serialization) -> Any:
+        result = path * 2
+        return f"{ser}:{result}"