sovereign 1.0.0b123__py3-none-any.whl → 1.0.0b124__py3-none-any.whl

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/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/worker.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Optional
+from typing import Optional, final
 from multiprocessing import Process, cpu_count
 from contextlib import asynccontextmanager
 
@@ -21,7 +21,43 @@ 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()
+
+
+ONDEMAND = RenderQueue()
 RENDER_SEMAPHORE = asyncio.Semaphore(cpu_count())
 
 
@@ -156,12 +192,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

{sovereign-1.0.0b123.dist-info → sovereign-1.0.0b124.dist-info}/METADATA

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

{sovereign-1.0.0b123.dist-info → sovereign-1.0.0b124.dist-info}/RECORD

@@ -1,6 +1,6 @@
 sovereign/__init__.py,sha256=m8MVzaMSW4AvAqHvUAsXFdp8Oas5oQ8X7BcVt7Hfcik,1431
 sovereign/app.py,sha256=fsf4Jgni2G4EYJO0oQSWfGRZVDBvE2Yfick4n2YR6K4,4876
-sovereign/cache.py,sha256=P2LAskGxZSFgQ392aKz7auHty57HJNepQ7xl2-iWbBA,3842
+sovereign/cache.py,sha256=f7d-x5ksRmd_tbSgdl5xKFXmwgUsMWECg98S5DZYc3w,5333
 sovereign/constants.py,sha256=qdWD1lTvkaW5JGF7TmZhfksQHlRAJFVqbG7v6JQA9k8,46
 sovereign/context.py,sha256=aoGJ5k1n8ytCk7jggQ6XTx6Hx_ocy7cEkvGOFS3gzzc,8912
 sovereign/dynamic_config/__init__.py,sha256=0hrI9Y-FzDywEM9Lu6i2mPFhs1c47C096R1B_-E3sKA,3161
@@ -12,7 +12,7 @@ sovereign/logging/application_logger.py,sha256=HjrGTi2zZ06AaToDVdSv4MNIF6aWN6vFW
 sovereign/logging/base_logger.py,sha256=ScOzHs8Rt1RZaUZGvaJSAlDEjD0BxkD5sLKSm2GgM0I,1243
 sovereign/logging/bootstrapper.py,sha256=gWFzIVsfeMdv7-d2Z6Fiw7J0xcuZzc4z2F4Iqn1KG30,1296
 sovereign/logging/types.py,sha256=rGqJAEVvgvzHy4aPfvEH6yQ-yblXNkEcWG7G8l9ALEA,282
-sovereign/middlewares.py,sha256=tQazHAtIdUc1hWhopg33x83-g-JcilU4HdjzoxFe6NU,3053
+sovereign/middlewares.py,sha256=6w4JpvtNGvQA4rocQsYQjuu-ckhpKT6gKYA16T-kiqA,3082
 sovereign/modifiers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sovereign/modifiers/lib.py,sha256=Cx0VrpTKbSjb3YmHyG4Jy6YEaPlrwpeqNaom3zu1_hw,2885
 sovereign/rendering.py,sha256=MIA7se7-C4WTWf7xZSgqpf7NvhDT7NkZbR3_G9N1dHI,5015
@@ -59,9 +59,9 @@ sovereign/views/crypto.py,sha256=7y0eHWtt-bbr2CwHEkH7odPaJ1IEviU-71U-MYJD0Kc,336
 sovereign/views/discovery.py,sha256=B_D1ckfbN1dSKBvuFCTyfB79GUUriCADTB53OwZ8D4Q,2409
 sovereign/views/healthchecks.py,sha256=TaXbxkX679jyQ8v5FxtBa2Qa0Z7KuqQ10WgAqfuVGUc,1743
 sovereign/views/interface.py,sha256=FmQ7LiUPLSvkEDOKCncrnKMD9g1lJKu-DQNbbyi8mqk,6346
-sovereign/worker.py,sha256=sOVHVVv63I08_KIdaKR0hUnYLMXwoqh9jmsCw8albZE,5230
-sovereign-1.0.0b123.dist-info/LICENSE.txt,sha256=2X125zvAb9AYLjCgdMDQZuufhm0kwcg31A8pGKj_-VY,560
-sovereign-1.0.0b123.dist-info/METADATA,sha256=ZiGaNA-XWo08b2EghMAbSDPRhKeu3_s8ls2o-pXqJNU,6304
-sovereign-1.0.0b123.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-sovereign-1.0.0b123.dist-info/entry_points.txt,sha256=VKJdnnN_HNL8xYQMXsFXfFmN6QkdXMEk5S964avxQJI,1404
-sovereign-1.0.0b123.dist-info/RECORD,,
+sovereign/worker.py,sha256=JWyZEsD-unguTWOMIwBWbWOTBppOozdbj_O4TrvN2BE,6315
+sovereign-1.0.0b124.dist-info/LICENSE.txt,sha256=2X125zvAb9AYLjCgdMDQZuufhm0kwcg31A8pGKj_-VY,560
+sovereign-1.0.0b124.dist-info/METADATA,sha256=zG_mBD_7-89gp9buqzGEKxAr3iv6fTEgjOFXw44hjRs,6304
+sovereign-1.0.0b124.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+sovereign-1.0.0b124.dist-info/entry_points.txt,sha256=VKJdnnN_HNL8xYQMXsFXfFmN6QkdXMEk5S964avxQJI,1404
+sovereign-1.0.0b124.dist-info/RECORD,,