sovereign 1.0.0a4__py3-none-any.whl → 1.0.0b148__py3-none-any.whl

sovereign/utils/eds.py

@@ -1,9 +1,7 @@
 import random
+from typing import Dict, Any, Optional, List
 from copy import deepcopy
-from typing import Any, Dict, List, Optional
-
 from starlette.exceptions import HTTPException
-
 from sovereign.configuration import config
 from sovereign.types import DiscoveryRequest
 from sovereign.utils.templates import resolve

sovereign/utils/entry_point_loader.py

@@ -1,6 +1,6 @@
-from functools import cached_property
-from importlib.metadata import EntryPoints, entry_points
 from typing import Dict
+from functools import cached_property
+from importlib.metadata import entry_points, EntryPoints
 
 
 class EntryPointLoader:

sovereign/utils/mock.py

@@ -1,9 +1,8 @@
-import ast
 import re
+import ast
+from typing import Optional, Dict, List
 from random import randint
-from typing import Dict, List, Optional
-
-from sovereign.types import DiscoveryRequest, Locality, Node, Status
+from sovereign.types import DiscoveryRequest, Node, Locality, Status
 
 scrub = re.compile(r"[^a-zA-Z_\.]")
 

sovereign/utils/resources.py

@@ -1,5 +1,5 @@
-import importlib.resources as res
 from functools import cache
+import importlib.resources as res
 from importlib.resources.abc import Traversable
 
 

sovereign/utils/templates.py

@@ -1,9 +1,7 @@
-from socket import gaierror as dns_error
+from typing import List, Optional, Any, Dict
 from socket import gethostbyname_ex
-from typing import Any, Dict, List, Optional
-
+from socket import gaierror as dns_error
 from starlette.exceptions import HTTPException
-
 from sovereign import config, stats
 
 REGIONS = config.legacy_fields.regions

sovereign/utils/timer.py

@@ -6,11 +6,9 @@ from typing import Any, Callable, Coroutine, NoReturn
 from croniter import croniter
 
 
-def wait_until(target_dt: datetime) -> float:
-    now = datetime.now(dt.timezone.utc)
-    if target_dt.tzinfo is None:
-        target_dt = target_dt.replace(tzinfo=dt.timezone.utc)
-    sleep_time = (target_dt - now).total_seconds()
+def wait_until(dt: datetime) -> float:
+    now = datetime.now()
+    sleep_time = (dt - now).total_seconds()
     return sleep_time
 
 

sovereign/utils/weighted_clusters.py

@@ -1,6 +1,5 @@
 from __future__ import division
-
-from typing import Any, Dict, Generator, List
+from typing import List, Any, Dict, Generator
 
 
 def _round_to_n(sequence: List[int], n: int = 100) -> List[int]:

sovereign/views/__init__.py

@@ -1,7 +1,4 @@
-from sovereign import cache, config
+from sovereign import cache
 
-if not config.worker_v2_enabled:
-    reader = cache.CacheReader()
-else:
-    # don't use the cache reader when in v2 worker mode
-    reader = None
+
+reader = cache.CacheReader()

sovereign/views/api.py

@@ -1,14 +1,12 @@
 import json
-from typing import Annotated, Optional
+from typing import Optional
 
-from fastapi import APIRouter, Path, Query
+from fastapi import APIRouter, Query, Path
 from fastapi.responses import Response
 
-from sovereign.cache import Entry
-from sovereign.configuration import ConfiguredResourceTypes, config
-from sovereign.utils.mock import mock_discovery_request
-from sovereign.v2.web import wait_for_discovery_response
 from sovereign.views import reader
+from sovereign.configuration import ConfiguredResourceTypes
+from sovereign.utils.mock import mock_discovery_request
 
 router = APIRouter()
 
@@ -27,10 +25,9 @@ def expand_metadata_to_expr(m):
     yield from _traverse(m, "", exprs)
 
 
-# noinspection DuplicatedCode
 @router.get("/resources/{resource_type}", summary="Get resources for a given type")
 async def resource(
-    resource_type: Annotated[ConfiguredResourceTypes, Path(title="xDS Resource type")],
+    resource_type: ConfiguredResourceTypes = Path(title="xDS Resource type"),
     resource_name: Optional[str] = Query(None, title="Resource name"),
     api_version: Optional[str] = Query("v3", title="Envoy API version"),
     service_cluster: Optional[str] = Query("*", title="Envoy Service cluster"),
@@ -38,8 +35,6 @@ async def resource(
     version: Optional[str] = Query(None, title="Envoy Semantic Version"),
     metadata: Optional[str] = Query(None, title="Envoy node metadata to filter by"),
 ) -> Response:
-    # todo: rewrite for worker v2
-
     expressions = [f"cluster={service_cluster}"]
     try:
         data = {"metadata": json.loads(metadata or "{}")}
@@ -56,24 +51,8 @@ async def resource(
         "expressions": expressions,
     }
     req = mock_discovery_request(**{k: v for k, v in kwargs.items() if v is not None})  # type: ignore
-
-    entry: Entry | None = None
-
-    if config.worker_v2_enabled:
-        # we're set up to use v2 of the worker
-        discovery_response = await wait_for_discovery_response(req)
-        if discovery_response is not None:
-            entry = Entry(
-                text=discovery_response.model_dump_json(indent=None),
-                len=len(discovery_response.resources),
-                version=discovery_response.version_info,
-                node=req.node,
-            )
-
-    else:
-        entry = await reader.blocking_read(req)  # ty: ignore[possibly-missing-attribute]
-
-    if content := getattr(entry, "text", None):
+    response = await reader.blocking_read(req)
+    if content := getattr(response, "text", None):
         return Response(content, media_type="application/json")
     else:
         return Response(

sovereign/views/crypto.py

@@ -5,8 +5,8 @@ from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field
 
 from sovereign import logs, server_cipher_container
-from sovereign.configuration import EncryptionConfig
 from sovereign.response_class import json_response_class
+from sovereign.configuration import EncryptionConfig
 from sovereign.utils.crypto.crypto import CipherContainer
 from sovereign.utils.crypto.suites import EncryptionType
 

sovereign/views/discovery.py

@@ -2,15 +2,14 @@ from fastapi import Body, Header
 from fastapi.responses import Response
 from fastapi.routing import APIRouter
 
-from sovereign import cache, config, logs
+from sovereign import cache, logs
+from sovereign.views import reader
 from sovereign.cache.types import Entry
+from sovereign.utils.auth import authenticate
 from sovereign.types import (
     DiscoveryRequest,
     DiscoveryResponse,
 )
-from sovereign.utils.auth import authenticate
-from sovereign.v2.web import wait_for_discovery_response
-from sovereign.views import reader
 
 
 def response_headers(
@@ -72,21 +71,7 @@ async def discovery_response(
             return Response(status_code=304, headers=headers)
         return Response(entry.text, media_type="application/json", headers=headers)
 
-    if config.worker_v2_enabled:
-        # we're set up to use v2 of the worker
-        response = await wait_for_discovery_response(xds_req)
-        if response is not None:
-            entry = Entry(
-                text=response.model_dump_json(indent=None),
-                len=len(response.resources),
-                version=response.version_info,
-                node=xds_req.node,
-            )
-            return handle_response(entry)
-
-    else:
-        entry: Entry | None
-        if entry := await reader.blocking_read(xds_req):  # ty: ignore[possibly-missing-attribute]
-            return handle_response(entry)
+    if entry := await reader.blocking_read(xds_req):
+        return handle_response(entry)
 
     return Response(content="Something went wrong", status_code=500)

sovereign/views/healthchecks.py

@@ -1,18 +1,18 @@
 import asyncio
+from typing_extensions import Annotated, Literal
 
-import pydantic
 import requests
-from fastapi import Query, Request, Response
-from fastapi.responses import JSONResponse, PlainTextResponse
+import pydantic
+from fastapi import Request, Response, Query
 from fastapi.routing import APIRouter
-from typing_extensions import Annotated, Literal
+from fastapi.responses import JSONResponse, PlainTextResponse
 
 from sovereign import __version__
-from sovereign.configuration import XDS_TEMPLATES, config
-from sovereign.response_class import json_response_class
-from sovereign.utils.mock import mock_discovery_request
-from sovereign.v2.web import wait_for_discovery_response
 from sovereign.views import reader
+from sovereign.configuration import XDS_TEMPLATES
+from sovereign.utils.mock import mock_discovery_request
+from sovereign.response_class import json_response_class
+
 
 router = APIRouter()
 
@@ -80,45 +80,27 @@ async def deep_check(
 ) -> Response:
     result = DeepCheckResult()
     for template in list(XDS_TEMPLATES["default"].keys()):
-        discovery_request = mock_discovery_request(
-            "v3",
-            template,
-            expressions=[f"cluster={envoy_service_cluster}"],
-        )
-
-        if config.worker_v2_enabled:
-            # we're set up to use v2 of the worker
-            response = await wait_for_discovery_response(discovery_request)
-            if response:
-                result.templates[template] = "OK"
-            else:
-                result.templates[template] = (
-                    "FAIL",
-                    f"Failed to render {template}",
-                )
-
-            result.worker = "OK"
-        else:
-            try:
-                _ = await reader.blocking_read(discovery_request)  # ty: ignore[possibly-missing-attribute]
-                result.templates[template] = "OK"
-            except Exception as e:
-                result.templates[template] = ("FAIL", f"Failed {template}: {str(e)}")
-
-    if not config.worker_v2_enabled:
-        for attempt in range(worker_attempts):
-            try:
-                worker_health = requests.get("http://localhost:9080/health")
-                if worker_health.ok:
-                    result.worker = "OK"
-                    break
-            except Exception as e:
-                result.worker = ("FAIL", str(e))
-                await asyncio.sleep(attempt)
-
+        try:
+            req = mock_discovery_request(
+                "v3",
+                template,
+                expressions=[f"cluster={envoy_service_cluster}"],
+            )
+            _ = await reader.blocking_read(req)
+            result.templates[template] = "OK"
+        except Exception as e:
+            result.templates[template] = ("FAIL", f"Failed {template}: {str(e)}")
+    for attempt in range(worker_attempts):
+        try:
+            worker_health = requests.get("http://localhost:9080/health")
+            if worker_health.ok:
+                result.worker = "OK"
+                break
+        except Exception as e:
+            result.worker = ("FAIL", str(e))
+            await asyncio.sleep(attempt)
     if "json" in request.headers.get("Accept", ""):
         return result.json_response()
-
     return result.response()
 
 

sovereign/views/interface.py

@@ -1,5 +1,4 @@
 import json
-import logging
 from collections import defaultdict
 from typing import Any, Dict, List
 
@@ -8,17 +7,13 @@ from fastapi.encoders import jsonable_encoder
 from fastapi.requests import Request
 from fastapi.responses import HTMLResponse, JSONResponse, Response
 from starlette.templating import Jinja2Templates
-from structlog.typing import FilteringBoundLogger
 
 from sovereign import __version__
-from sovereign.cache import Entry
-from sovereign.configuration import XDS_TEMPLATES, ConfiguredResourceTypes, config
+from sovereign.views import reader
+from sovereign.configuration import ConfiguredResourceTypes, XDS_TEMPLATES
 from sovereign.response_class import json_response_class
 from sovereign.utils.mock import NodeExpressionError, mock_discovery_request
 from sovereign.utils.resources import get_package_file
-from sovereign.v2.logging import get_named_logger
-from sovereign.v2.web import wait_for_discovery_response
-from sovereign.views import reader
 
 router = APIRouter()
 
@@ -56,7 +51,6 @@ async def ui_main(request: Request) -> HTMLResponse:
         )
 
 
-# noinspection DuplicatedCode
 @router.get(
     "/resources/{xds_type}", summary="List available resources for a given xDS type"
 )
@@ -75,12 +69,8 @@ async def resources(
     ),
     debug: int = Query(0, title="Show debug information on errors"),
 ) -> HTMLResponse:
-    logger: FilteringBoundLogger = get_named_logger(
-        f"{__name__}.{resources.__qualname__} ({__file__})",
-        level=logging.DEBUG,
-    )
-
     ret: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+    response = None
     try:
         mock_request = mock_discovery_request(
             api_version,
@@ -101,26 +91,9 @@ async def resources(
         clear_cookie = True
         error = str(e)
 
-    logger.debug("Making mock request", mock_request=mock_request)
-
-    entry: Entry | None = None
-
-    if config.worker_v2_enabled:
-        # we're set up to use v2 of the worker
-        discovery_response = await wait_for_discovery_response(mock_request)
-        if discovery_response is not None:
-            entry = Entry(
-                text=discovery_response.model_dump_json(indent=None),
-                len=len(discovery_response.resources),
-                version=discovery_response.version_info,
-                node=mock_request.node,
-            )
-
-    else:
-        entry = await reader.blocking_read(mock_request)  # ty: ignore[possibly-missing-attribute]
-
-    if entry:
-        ret["resources"] = json.loads(entry.text).get("resources", [])
+    response = await reader.blocking_read(mock_request)
+    if response:
+        ret["resources"] = json.loads(response.text).get("resources", [])
 
     resp = html_templates.TemplateResponse(
         request=request,
@@ -128,7 +101,7 @@ async def resources(
         media_type="text/html",
         context={
             "show_debuginfo": True if debug else False,
-            "discovery_response": entry,
+            "discovery_response": response,
             "discovery_request": mock_request,
             "resources": ret["resources"],
             "resource_type": xds_type,
@@ -144,7 +117,6 @@ async def resources(
     return resp
 
 
-# noinspection DuplicatedCode
 @router.get(
     "/resources/{xds_type}/{resource_name}",
     summary="Return JSON representation of a resource",
@@ -163,11 +135,6 @@ async def resource(
         "__any__", title="The clients envoy version to emulate in this XDS request"
     ),
 ) -> Response:
-    logger: FilteringBoundLogger = get_named_logger(
-        f"{__name__}.{resources.__qualname__} ({__file__})",
-        level=logging.DEBUG,
-    )
-
     mock_request = mock_discovery_request(
         api_version,
         xds_type,
@@ -175,27 +142,8 @@ async def resource(
         region=region,
         expressions=node_expression.split(),
     )
-
-    logger.debug("Making mock request", mock_request=mock_request)
-
-    entry: Entry | None = None
-
-    if config.worker_v2_enabled:
-        # we're set up to use v2 of the worker
-        discovery_response = await wait_for_discovery_response(mock_request)
-        if discovery_response is not None:
-            entry = Entry(
-                text=discovery_response.model_dump_json(indent=None),
-                len=len(discovery_response.resources),
-                version=discovery_response.version_info,
-                node=mock_request.node,
-            )
-
-    else:
-        entry = await reader.blocking_read(mock_request)  # ty: ignore[possibly-missing-attribute]
-
-    if entry:
-        for res in json.loads(entry.text).get("resources", []):
+    if response := await reader.blocking_read(mock_request):
+        for res in json.loads(response.text).get("resources", []):
             if res.get("name", res.get("cluster_name")) == resource_name:
                 safe_response = jsonable_encoder(res)
                 try:
@@ -226,11 +174,6 @@ async def virtual_hosts(
         "__any__", title="The clients envoy version to emulate in this XDS request"
     ),
 ) -> Response:
-    logger: FilteringBoundLogger = get_named_logger(
-        f"{__name__}.{virtual_hosts.__qualname__} ({__file__})",
-        level=logging.DEBUG,
-    )
-
     mock_request = mock_discovery_request(
         api_version,
         "routes",
@@ -238,10 +181,7 @@ async def virtual_hosts(
         region=region,
         expressions=node_expression.split(),
     )
-
-    logger.debug("Making mock request", mock_request=mock_request)
-
-    if response := await reader.blocking_read(mock_request):  # ty: ignore[possibly-missing-attribute]
+    if response := await reader.blocking_read(mock_request):
         route_configs = [
             resource_
             for resource_ in json.loads(response.text).get("resources", [])

sovereign/worker.py

@@ -1,26 +1,24 @@
 import asyncio
-from contextlib import asynccontextmanager
 from typing import final
+from contextlib import asynccontextmanager
 
-from fastapi import Body, FastAPI
+from fastapi import FastAPI, Body
 
-from sovereign import (
-    application_logger as log,
-)
 from sovereign import (
     cache,
-    disabled_ciphersuite,
     rendering,
     server_cipher_container,
+    disabled_ciphersuite,
+    application_logger as log,
     stats,
 )
-from sovereign.configuration import config
 from sovereign.context import TemplateContext
-from sovereign.events import Topic, bus
-from sovereign.types import DiscoveryRequest, RegisterClientRequest
+from sovereign.sources import SourcePoller
+from sovereign.configuration import config
+from sovereign.types import RegisterClientRequest, DiscoveryRequest
+from sovereign.events import bus, Topic
 
 
-# noinspection PyUnusedLocal
 def hidden_field(*args, **kwargs):
     return "(value hidden)"
 
@@ -90,6 +88,16 @@ if config.sources is not None:
         matching_enabled = False
         node_key = None
         source_key = None
+    poller = SourcePoller(
+        sources=config.sources,
+        matching_enabled=matching_enabled,
+        node_match_key=node_key,
+        source_match_key=source_key,
+        source_refresh_rate=config.source_config.refresh_rate,
+        logger=log,
+        stats=stats,
+    )
+    context_middleware.append(poller.add_to_context)
 
 
 async def render_on_event(ctx):
@@ -123,19 +131,18 @@ async def render_on_event(ctx):
 
 async def render_on_demand(ctx):
     while True:
-        cid, request = await ONDEMAND.get()
+        id, request = await ONDEMAND.get()
         stats.increment("template.render_on_demand")
         log.debug(
-            f"Received on-demand request to render templates for {cid} ({request})"
+            f"Received on-demand request to render templates for {id} ({request})"
         )
         job = rendering.RenderJob(
-            id=cid, request=request, context=ctx.get_context(request)
+            id=id, request=request, context=ctx.get_context(request)
         )
         _ = job.submit()
-        await ONDEMAND.task_done(cid)
+        await ONDEMAND.task_done(id)
 
 
-# noinspection PyProtectedMember
 async def monitor_render_queue():
     """Periodically report render queue size metrics"""
     while True:
@@ -158,6 +165,13 @@ async def lifespan(_: FastAPI):
     event = await subscription.get()
     log.debug(event.message)
 
+    # Source polling
+    if poller is not None:
+        log.debug("Starting source poller")
+        poller.lazy_load_modifiers(config.modifiers)
+        poller.lazy_load_global_modifiers(config.global_modifiers)
+        asyncio.create_task(poller.poll_forever())
+
     log.debug("Worker lifespan initialized")
     yield
 
@@ -165,10 +179,7 @@ async def lifespan(_: FastAPI):
 worker = FastAPI(lifespan=lifespan)
 if dsn := config.sentry_dsn.get_secret_value():
     try:
-        # noinspection PyUnusedImports
         import sentry_sdk
-
-        # noinspection PyUnusedImports
         from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 
         sentry_sdk.init(dsn)
@@ -188,6 +199,6 @@ async def client_add(
 ):
     log.info(f"Received registration: {registration.request}")
     xds = registration.request
-    client_id, req = writer.register(xds)
-    ONDEMAND.put_nowait((client_id, req))
+    id, req = writer.register(xds)
+    ONDEMAND.put_nowait((id, req))
     return "Registered", 200

{sovereign-1.0.0a4.dist-info → sovereign-1.0.0b148.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sovereign
-Version: 1.0.0a4
+Version: 1.0.0b148
 Summary: Envoy Proxy control-plane written in Python
 Project-URL: Homepage, https://pypi.org/project/sovereign/
 Project-URL: Repository, https://bitbucket.org/atlassian/sovereign/src/master/
@@ -27,7 +27,7 @@ Requires-Dist: cachelib<0.11,>=0.10.2
 Requires-Dist: cachetools<6,>=5.3.2
 Requires-Dist: croniter<2,>=1.4.1
 Requires-Dist: cryptography>=45.0.2
-Requires-Dist: fastapi<0.129,>=0.128.0
+Requires-Dist: fastapi<0.117,>=0.116.0
 Requires-Dist: glom<24,>=23.3.0
 Requires-Dist: h11<0.17,>=0.16.0
 Requires-Dist: jinja2<4,>=3.1.2
@@ -36,9 +36,8 @@ Requires-Dist: pydantic-settings<2.6.0
 Requires-Dist: pydantic<3,>=2.7.2
 Requires-Dist: pyyaml<7,>=6.0.1
 Requires-Dist: requests<3,>=2.32.4
-Requires-Dist: rich>=14.2.0
 Requires-Dist: starlette-context<0.4,>=0.3.6
-Requires-Dist: starlette<0.50,>=0.49.1
+Requires-Dist: starlette<0.48,>=0.47.2
 Requires-Dist: structlog<24,>=23.1.0
 Requires-Dist: supervisor<5,>=4.2.5
 Requires-Dist: uvicorn<0.24,>=0.23.2