sovereign 1.0.0b123.post2__tar.gz → 1.0.0b125__tar.gz

{sovereign-1.0.0b123.post2 → sovereign-1.0.0b125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sovereign
-Version: 1.0.0b123.post2
+Version: 1.0.0b125
 Summary: Envoy Proxy control-plane written in Python
 Home-page: https://pypi.org/project/sovereign/
 License: Apache-2.0

{sovereign-1.0.0b123.post2 → sovereign-1.0.0b125}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sovereign"
-version = "1.0.0b123-2"
+version = "1.0.0b125"
 description = "Envoy Proxy control-plane written in Python"
 license = "Apache-2.0"
 packages = [

{sovereign-1.0.0b123.post2 → sovereign-1.0.0b125}/src/sovereign/cache.py

@@ -19,11 +19,50 @@ CACHE: BaseCache
 CACHE_READ_TIMEOUT = config.cache_timeout
 WORKER_URL = "http://localhost:9080/client"
 
+
+class DualCache(BaseCache):
+    """Cache that writes to both filesystem and Redis, reads filesystem first with Redis fallback"""
+
+    def __init__(
+        self, fs_cache: FileSystemCache, redis_cache: Optional[RedisCache] = None
+    ):
+        self.fs_cache = fs_cache
+        self.redis_cache = redis_cache
+
+    def get(self, key):
+        # Try filesystem first
+        if value := self.fs_cache.get(key):
+            stats.increment("cache.fs.hit")
+            return value
+
+        # Fallback to Redis if available
+        if self.redis_cache:
+            if value := self.redis_cache.get(key):
+                stats.increment("cache.redis.hit")
+                # Write back to filesystem
+                self.fs_cache.set(key, value)
+                return value
+
+        return None
+
+    def set(self, key, value, timeout=None):
+        self.fs_cache.set(key, value, timeout)
+        if self.redis_cache:
+            try:
+                self.redis_cache.set(key, value, timeout)
+            except Exception as e:
+                log.warning(f"Failed to write to Redis cache: {e}")
+
+
+# Initialize caches
+fs_cache = FileSystemCache(config.cache_path, default_timeout=0, hash_method=blake2s)
+redis_cache = None
+
 redis = config.discovery_cache
 if redis.enabled:
     if mod := importlib.import_module("redis"):
         try:
-            CACHE = RedisCache(
+            redis_cache = RedisCache(
                 host=mod.Redis(
                     host=redis.host,
                     port=redis.port,
@@ -34,10 +73,11 @@ if redis.enabled:
                 key_prefix="discovery_request_",
                 default_timeout=redis.ttl,
             )
+            log.info("Redis cache enabled for dual caching")
         except Exception as e:
-            log.exception(f"Tried to use redis for caching: {e}")
-else:
-    CACHE = FileSystemCache(config.cache_path, default_timeout=0, hash_method=blake2s)
+            log.exception(f"Failed to initialize Redis cache: {e}")
+
+CACHE = DualCache(fs_cache, redis_cache)
 
 
 class Entry(BaseModel):
@@ -71,8 +111,9 @@ async def lock():
 
 @stats.timed("cache.read_ms")
 async def blocking_read(
-    req: DiscoveryRequest, timeout=CACHE_READ_TIMEOUT, poll_interval=0.05
+    req: DiscoveryRequest, timeout=CACHE_READ_TIMEOUT, poll_interval=0.5
 ) -> Optional[Entry]:
+    metric = "client.registration"
     id = client_id(req)
     if entry := read(id):
         return entry
@@ -80,16 +121,21 @@ async def blocking_read(
     registered = False
     registration = RegisterClientRequest(request=req)
     start = asyncio.get_event_loop().time()
+    attempt = 1
     while (asyncio.get_event_loop().time() - start) < timeout:
         if not registered:
             try:
                 response = requests.put(WORKER_URL, json=registration.model_dump())
-                if response.status_code == 200:
-                    registered = True
+                match response.status_code:
+                    case 200 | 202:
+                        registered = True
+                    case 429:
+                        stats.increment(metric, tags=["status:ratelimited"])
+                        await asyncio.sleep(min(attempt, CACHE_READ_TIMEOUT))
+                        attempt *= 2
             except Exception as e:
-                stats.increment("client.registration", tags=["status:failed"])
+                stats.increment(metric, tags=["status:failed"])
                 log.exception(f"Tried to register client but failed: {e}")
-                await asyncio.sleep(1)
         if entry := read(id):
             return entry
         await asyncio.sleep(poll_interval)

{sovereign-1.0.0b123.post2 → sovereign-1.0.0b125}/src/sovereign/middlewares.py

@@ -19,7 +19,7 @@ class RequestContextLogMiddleware(BaseHTTPMiddleware):
             response = await call_next(request)
         finally:
             req_id = get_request_id()
-            response.headers["X-Request-ID"] = req_id
+            req_id = response.headers.setdefault("X-Request-Id", get_request_id())
             logs.access_logger.queue_log_fields(REQUEST_ID=req_id)
             _request_id_ctx_var.reset(token)
         return response

{sovereign-1.0.0b123.post2 → sovereign-1.0.0b125}/src/sovereign/worker.py

@@ -1,6 +1,5 @@
 import asyncio
-import os
-from typing import Optional
+from typing import Optional, final
 from multiprocessing import Process, cpu_count
 from contextlib import asynccontextmanager
 
@@ -22,7 +21,46 @@ from sovereign.context import NEW_CONTEXT
 
 
 ClientId = str
-ONDEMAND: asyncio.Queue[tuple[ClientId, DiscoveryRequest]] = asyncio.Queue(100)
+OnDemandJob = tuple[ClientId, DiscoveryRequest]
+
+
+@final
+class RenderQueue:
+    def __init__(self, maxsize: int = 0):
+        self._queue: asyncio.Queue[OnDemandJob] = asyncio.Queue(maxsize)
+        self._set: set[ClientId] = set()
+        self._lock = asyncio.Lock()
+
+    async def put(self, item: OnDemandJob):
+        id_ = item[0]
+        async with self._lock:
+            if id_ not in self._set:
+                await self._queue.put(item)
+                self._set.add(id_)
+
+    def put_nowait(self, item: OnDemandJob):
+        id_ = item[0]
+        if id_ in self._set:
+            return
+        if self._queue.full():
+            raise asyncio.QueueFull
+        self._queue.put_nowait(item)
+        self._set.add(id_)
+
+    async def get(self):
+        item = await self._queue.get()
+        async with self._lock:
+            self._set.remove(item[0])
+        return item
+
+    def full(self):
+        return self._queue.full()
+
+    def task_done(self):
+        self._queue.task_done()
+
+
+ONDEMAND = RenderQueue()
 RENDER_SEMAPHORE = asyncio.Semaphore(cpu_count())
 
 
@@ -61,26 +99,9 @@ if config.sources is not None:
     context_middleware.append(poller.add_to_context)
 
 
-def _render_process_entry(job: rendering.RenderJob):  # runs in child
-    """Entry point for render subprocess; increase niceness so it is lower priority.
-
-    We deliberately raise the niceness (positive value) so these CPU bound template
-    renders cannot starve the worker's main event loop handling incoming requests.
-    """
-    try:
-        try:
-            # Always lower scheduling priority by adding +2 niceness relative to parent
-            os.nice(2)  # best-effort; ignored if insufficient privileges
-        except Exception:
-            pass
-        rendering.generate(job)
-    except Exception:
-        log.exception("Render process failed for %s", job.id)
-
-
 def render(job: rendering.RenderJob):
-    log.debug(f"Spawning render process for {job.id} with lowered priority")
-    process = Process(target=_render_process_entry, args=(job,), daemon=True)
+    log.debug(f"Spawning render process for {job.id}")
+    process = Process(target=rendering.generate, args=[job])
     process.start()
     return process
 
@@ -174,12 +195,17 @@ async def client_add(
     registration: RegisterClientRequest = Body(...),
 ):
     xds = registration.request
-    if not cache.registered(xds):
-        log.debug(f"Received registration for new client {xds}")
-        ONDEMAND.put_nowait(await cache.register(xds))
-        stats.increment("client.registration", tags=["status:registered"])
-        return "Registering", 202
-    else:
+    if cache.registered(xds):
         log.debug("Client already registered")
         stats.increment("client.registration", tags=["status:exists"])
         return "Registered", 200
+    else:
+        log.debug(f"Received registration for new client {xds}")
+        id, req = await cache.register(xds)
+        try:
+            ONDEMAND.put_nowait((id, req))
+        except asyncio.QueueFull:
+            stats.increment("client.registration", tags=["status:queue_full"])
+            return "Slow down :(", 429
+        stats.increment("client.registration", tags=["status:registered"])
+        return "Registering", 202