diracx 0.0.6__tar.gz → 0.0.7__tar.gz

{diracx-0.0.6 → diracx-0.0.7}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.0.7](https://github.com/DIRACGrid/diracx/compare/v0.0.6...v0.0.7) (2026-01-20)
+
+
+### Bug Fixes
+
+* add logging and retry for cache population failures ([#736](https://github.com/DIRACGrid/diracx/issues/736)) ([b899a8d](https://github.com/DIRACGrid/diracx/commit/b899a8d207a42b232fbe4062f329a32d64c37ec3))
+* require fastapi>=0.121.0 for Depends scope parameter ([#737](https://github.com/DIRACGrid/diracx/issues/737)) ([fb15f9c](https://github.com/DIRACGrid/diracx/commit/fb15f9c5bb9d36568e37f0fae7a2a78995f02d51))
+
 ## [0.0.6](https://github.com/DIRACGrid/diracx/compare/v0.0.5...v0.0.6) (2026-01-20)
 
 

{diracx-0.0.6 → diracx-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diracx
-Version: 0.0.6
+Version: 0.0.7
 Summary: Client installation for users of DiracX installations
 License: GPL-3.0-only
 License-File: LICENSE

{diracx-0.0.6 → diracx-0.0.7}/diracx-core/src/diracx/core/utils.py

@@ -12,13 +12,14 @@ __all__ = [
 
 import fcntl
 import json
+import logging
 import os
 import re
 import stat
 import threading
 from collections import defaultdict
 from collections.abc import Callable
-from concurrent.futures import Future, ThreadPoolExecutor, wait
+from concurrent.futures import Future, ThreadPoolExecutor
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, AsyncIterable, TypeVar, overload
@@ -28,6 +29,8 @@ from cachetools import Cache, TTLCache
 from diracx.core.exceptions import NotReadyError
 from diracx.core.models import TokenResponse
 
+logger = logging.getLogger(__name__)
+
 EXPIRES_GRACE_SECONDS = 15
 
 T = TypeVar("T")
@@ -208,15 +211,16 @@ class TwoLevelCache:
             This method is thread-safe and handles concurrent requests for the same key.
 
         """
-        if result := self.soft_cache.get(key):
-            return result
+        if key in self.soft_cache:
+            return self.soft_cache[key]
         if self.locks[key].acquire(blocking=blocking):
             try:
                 if key not in self.futures:
                     self.futures[key] = self.pool.submit(self._work, key, populate_func)
-                if result := self.hard_cache.get(key):
+                if key in self.hard_cache:
                     # The soft cache will be updated by _work so we can fill the soft
-                    # cache to avoid later requests needign to acquire the lock.
+                    # cache to avoid later requests needing to acquire the lock.
+                    result = self.hard_cache[key]
                     self.soft_cache[key] = result
                     return result
                 future = self.futures[key]
@@ -227,13 +231,17 @@ class TwoLevelCache:
                 # as _work acquires the lock before filling the caches. This also
                 # means we can guarantee that the future has not yet been removed
                 # from the futures dict.
-                wait([future])
+                # Use result() instead of wait() to propagate any exceptions
+                future.result()
                 return self.hard_cache[key]
 
         # If the lock is not acquired we're in a non-blocking mode, try to get the
         # value from the hard cache. If it's not there, raise NotReadyError.
-        if result := self.hard_cache.get(key):
-            return result
+        if key in self.hard_cache:
+            return self.hard_cache[key]
+        logger.debug(
+            "Cache key %r not ready yet, background population in progress", key
+        )
         raise NotReadyError(f"Cache key {key} is not ready yet.")
 
     def _work(self, key: str, populate_func: Callable[[], Any]) -> None:
@@ -251,11 +259,26 @@ class TwoLevelCache:
             This method is not intended to be called directly by users of the class.
 
         """
-        result = populate_func()
-        with self.locks[key]:
-            self.futures.pop(key)
-            self.hard_cache[key] = result
-            self.soft_cache[key] = result
+        success = False
+        result = None
+        try:
+            result = populate_func()
+            success = True
+        except Exception:
+            logger.error(
+                "Failed to populate cache key %r, will retry on next request",
+                key,
+                exc_info=True,
+            )
+            raise
+        finally:
+            # Always remove the future so the next request can retry on failure
+            # or submit a new refresh task on success
+            with self.locks[key]:
+                self.futures.pop(key, None)
+                if success:
+                    self.hard_cache[key] = result
+                    self.soft_cache[key] = result
 
     def clear(self):
         """Clear all caches and reset the thread pool."""

{diracx-0.0.6 → diracx-0.0.7}/diracx-core/tests/test_utils.py

@@ -8,8 +8,10 @@ from pathlib import Path
 
 import pytest
 
+from diracx.core.exceptions import NotReadyError
 from diracx.core.models import TokenResponse
 from diracx.core.utils import (
+    TwoLevelCache,
     dotenv_files_from_environment,
     read_credentials,
     serialize_credentials,
@@ -182,3 +184,118 @@ def test_read_credentials_valid_file(tmp_path):
     assert credentials.expires_in < token_response.expires_in
     assert credentials.token_type == token_response.token_type
     assert credentials.refresh_token == token_response.refresh_token
+
+
+class TestTwoLevelCache:
+    """Tests for TwoLevelCache."""
+
+    def test_successful_population(self):
+        """Test that cache is populated successfully."""
+        cache = TwoLevelCache(soft_ttl=10, hard_ttl=60)
+        call_count = 0
+
+        def populate():
+            nonlocal call_count
+            call_count += 1
+            return "test_value"
+
+        result = cache.get("key", populate)
+        assert result == "test_value"
+        assert call_count == 1
+
+        # Second call should use cached value
+        result = cache.get("key", populate)
+        assert result == "test_value"
+        assert call_count == 1
+
+    def test_failed_population_logs_and_allows_retry(self, caplog):
+        """Test that failed population logs error and allows retry on next request."""
+        cache = TwoLevelCache(soft_ttl=10, hard_ttl=60)
+        call_count = 0
+
+        def failing_populate():
+            nonlocal call_count
+            call_count += 1
+            raise ValueError("Test error")
+
+        # First call should fail and log the error
+        with pytest.raises(ValueError, match="Test error"):
+            cache.get("key", failing_populate, blocking=True)
+
+        assert call_count == 1
+        assert "Failed to populate cache key 'key'" in caplog.text
+        assert "Test error" in caplog.text
+
+        # Future should be removed, so next call should retry
+        with pytest.raises(ValueError, match="Test error"):
+            cache.get("key", failing_populate, blocking=True)
+
+        assert call_count == 2  # Should have retried
+
+    def test_failed_population_then_success(self):
+        """Test that after a failure, subsequent successful call works."""
+        cache = TwoLevelCache(soft_ttl=10, hard_ttl=60)
+        should_fail = True
+
+        def populate():
+            if should_fail:
+                raise ValueError("Test error")
+            return "success_value"
+
+        # First call fails
+        with pytest.raises(ValueError):
+            cache.get("key", populate, blocking=True)
+
+        # Second call succeeds
+        should_fail = False
+        result = cache.get("key", populate, blocking=True)
+        assert result == "success_value"
+
+    def test_none_return_value_is_cached(self):
+        """Test that None return values are properly cached."""
+        cache = TwoLevelCache(soft_ttl=10, hard_ttl=60)
+        call_count = 0
+
+        def populate_none():
+            nonlocal call_count
+            call_count += 1
+            return None
+
+        result = cache.get("key", populate_none)
+        assert result is None
+        assert call_count == 1
+
+        # Second call should use cached None value
+        result = cache.get("key", populate_none)
+        assert result is None
+        assert call_count == 1  # Should not have called populate again
+
+    def test_non_blocking_raises_not_ready(self):
+        """Test that non-blocking mode raises NotReadyError when cache is empty."""
+        import threading
+        import time
+
+        cache = TwoLevelCache(soft_ttl=10, hard_ttl=60)
+        started = threading.Event()
+
+        def slow_populate():
+            started.set()
+            time.sleep(0.5)
+            return "value"
+
+        def start_slow():
+            cache.get("key", slow_populate, blocking=True)
+
+        # Start population in background
+        thread = threading.Thread(target=start_slow)
+        thread.start()
+
+        # Wait until slow_populate has started to avoid race conditions
+        assert started.wait(timeout=1.0)
+
+        # Non-blocking call should raise NotReadyError since cache isn't populated yet
+        with pytest.raises(NotReadyError, match="not ready yet"):
+            cache.get("key", slow_populate, blocking=False)
+
+        # Ensure background thread completes
+        thread.join()

{diracx-0.0.6 → diracx-0.0.7}/diracx-routers/pyproject.toml

@@ -19,7 +19,7 @@ dependencies = [
     "diracx-db",
     "python-dotenv",    # TODO: We might not need this
     "python-multipart",
-    "fastapi",
+    "fastapi>=0.121.0",
     "httpx",
     "joserfc",
     "pydantic >=2.10",