ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

ccproxy/services/auth_registry.py

@@ -0,0 +1,180 @@
+"""Auth manager registry for plugin system."""
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from ccproxy.core.logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class AuthManagerRegistry:
+    """Registry for auth managers that can be referenced by name.
+
+    This registry uses Any types to avoid circular imports with the auth module.
+    The actual auth managers are expected to have a 'create' class method for
+    async instantiation.
+    """
+
+    def __init__(self) -> None:
+        self._factories: dict[str, Callable[[], Awaitable[Any]]] = {}
+        self._instances: dict[str, Any] = {}
+
+    def register_class(self, name: str, auth_manager_class: type[Any]) -> None:
+        """Register an auth manager class that will be instantiated on demand.
+
+        Args:
+            name: Name to register the auth manager under
+            auth_manager_class: Auth manager class to instantiate
+        """
+
+        async def create_instance() -> Any:
+            # Use the async create class method if available
+            if hasattr(auth_manager_class, "create"):
+                instance = await auth_manager_class.create()
+                return instance
+            else:
+                # Fallback to direct instantiation (requires storage parameter)
+                raise RuntimeError(
+                    f"Auth manager class {auth_manager_class.__name__} must have a 'create' class method"
+                )
+
+        self._factories[name] = create_instance
+        logger.debug(
+            "auth_manager_class_registered",
+            name=name,
+            class_name=auth_manager_class.__name__,
+        )
+
+    def register_factory(
+        self, name: str, factory: Callable[[], Awaitable[Any]]
+    ) -> None:
+        """Register a factory function for creating auth managers.
+
+        Args:
+            name: Name to register the auth manager under
+            factory: Factory function that returns an auth manager instance
+        """
+        self._factories[name] = factory
+        logger.debug("auth_manager_factory_registered", name=name)
+
+    def register_instance(self, name: str, instance: Any) -> None:
+        """Register an existing auth manager instance.
+
+        Args:
+            name: Name to register the auth manager under
+            instance: Auth manager instance
+        """
+        self._instances[name] = instance
+        logger.debug(
+            "auth_manager_instance_registered",
+            name=name,
+            instance_type=type(instance).__name__,
+        )
+
+    def unregister(self, name: str) -> None:
+        """Unregister an auth manager.
+
+        Args:
+            name: Name of auth manager to unregister
+        """
+        if name in self._factories:
+            del self._factories[name]
+        if name in self._instances:
+            del self._instances[name]
+        logger.debug("auth_manager_unregistered", name=name)
+
+    async def get(self, name: str) -> Any | None:
+        """Get an auth manager by name.
+
+        Args:
+            name: Name of the auth manager to retrieve
+
+        Returns:
+            Auth manager instance or None if not found
+        """
+        # Check for existing instance first
+        if name in self._instances:
+            return self._instances[name]
+
+        # Check for factory
+        if name in self._factories:
+            try:
+                instance = await self._factories[name]()
+                # Cache the instance for future use
+                self._instances[name] = instance
+                logger.debug(
+                    "auth_manager_created",
+                    name=name,
+                    instance_type=type(instance).__name__,
+                )
+                return instance
+            except Exception as e:
+                logger.error(
+                    "auth_manager_creation_failed", name=name, error=str(e), exc_info=e
+                )
+                return None
+
+        return None
+
+    def has(self, name: str) -> bool:
+        """Check if an auth manager is registered under the given name.
+
+        Args:
+            name: Name to check
+
+        Returns:
+            True if auth manager is registered, False otherwise
+        """
+        return name in self._factories or name in self._instances
+
+    def list(self) -> dict[str, str]:
+        """List all registered auth managers.
+
+        Returns:
+            Dictionary mapping auth manager names to their types
+        """
+        result = {}
+
+        # Add factories
+        for name in self._factories:
+            result[name] = "factory"
+
+        # Add instances
+        for name, instance in self._instances.items():
+            result[name] = type(instance).__name__
+
+        return result
+
+    def get_class(self, name: str) -> type[Any] | None:
+        """Get the auth manager class if registered via register_class.
+
+        Args:
+            name: Name of the auth manager
+
+        Returns:
+            Auth manager class or None if not found or not registered as class
+        """
+        # This is a bit hacky but works: we inspect the factory closure
+        # to extract the class that was registered
+        if name not in self._factories:
+            return None
+
+        factory = self._factories[name]
+        # Check if this factory was created by register_class
+        if hasattr(factory, "__closure__") and factory.__closure__:
+            for cell in factory.__closure__:
+                try:
+                    obj = cell.cell_contents
+                    if isinstance(obj, type):
+                        return obj
+                except (AttributeError, ValueError):
+                    continue
+        return None
+
+    def clear(self) -> None:
+        """Clear all registered auth managers."""
+        self._factories.clear()
+        self._instances.clear()
+        logger.debug("auth_manager_registry_cleared")

ccproxy/services/cache/__init__.py

@@ -0,0 +1,6 @@
+"""Cache services for performance optimization."""
+
+from .response_cache import CacheEntry, ResponseCache
+
+
+__all__ = ["ResponseCache", "CacheEntry"]

ccproxy/services/cache/response_cache.py

@@ -0,0 +1,261 @@
+"""Response caching for API requests."""
+
+import hashlib
+import json
+import time
+from dataclasses import dataclass
+from typing import Any
+
+import structlog
+
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclass
+class CacheEntry:
+    """A cached response entry."""
+
+    key: str
+    data: Any
+    timestamp: float
+    ttl: float
+
+    def is_expired(self) -> bool:
+        """Check if the cache entry has expired."""
+        return time.time() - self.timestamp > self.ttl
+
+
+class ResponseCache:
+    """In-memory response cache with TTL support."""
+
+    def __init__(self, default_ttl: float = 300.0, max_size: int = 1000) -> None:
+        """Initialize the response cache.
+
+        Args:
+            default_ttl: Default time-to-live in seconds (5 minutes)
+            max_size: Maximum number of cached entries
+        """
+        self.default_ttl = default_ttl
+        self.max_size = max_size
+        self._cache: dict[str, CacheEntry] = {}
+        self._access_order: list[str] = []
+        self.logger = logger
+
+    def _generate_key(
+        self,
+        method: str,
+        url: str,
+        body: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> str:
+        """Generate a cache key for the request.
+
+        Args:
+            method: HTTP method
+            url: Request URL
+            body: Request body
+            headers: Request headers
+
+        Returns:
+            Cache key string
+        """
+        # Include important headers in cache key
+        cache_headers = {}
+        if headers:
+            for header in ["authorization", "x-api-key", "content-type"]:
+                if header in headers:
+                    cache_headers[header] = headers[header]
+
+        key_parts = [
+            method,
+            url,
+            body.decode("utf-8") if body else "",
+            json.dumps(cache_headers, sort_keys=True),
+        ]
+
+        key_string = "|".join(key_parts)
+        return hashlib.sha256(key_string.encode()).hexdigest()
+
+    def get(
+        self,
+        method: str,
+        url: str,
+        body: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Any | None:
+        """Get a cached response if available and not expired.
+
+        Args:
+            method: HTTP method
+            url: Request URL
+            body: Request body
+            headers: Request headers
+
+        Returns:
+            Cached response data or None
+        """
+        key = self._generate_key(method, url, body, headers)
+
+        if key in self._cache:
+            entry = self._cache[key]
+
+            if entry.is_expired():
+                # Remove expired entry
+                del self._cache[key]
+                if key in self._access_order:
+                    self._access_order.remove(key)
+                self.logger.debug("cache_entry_expired", key=key[:8])
+                return None
+
+            # Update access order (LRU)
+            if key in self._access_order:
+                self._access_order.remove(key)
+            self._access_order.append(key)
+
+            self.logger.debug("cache_hit", key=key[:8])
+            return entry.data
+
+        self.logger.debug("cache_miss", key=key[:8])
+        return None
+
+    def set(
+        self,
+        method: str,
+        url: str,
+        data: Any,
+        body: bytes | None = None,
+        headers: dict[str, str] | None = None,
+        ttl: float | None = None,
+    ) -> None:
+        """Cache a response.
+
+        Args:
+            method: HTTP method
+            url: Request URL
+            data: Response data to cache
+            body: Request body
+            headers: Request headers
+            ttl: Time-to-live in seconds (uses default if None)
+        """
+        # Don't cache streaming responses
+        if hasattr(data, "__aiter__"):
+            return
+
+        key = self._generate_key(method, url, body, headers)
+        ttl = ttl or self.default_ttl
+
+        # Enforce max size with LRU eviction
+        if (
+            len(self._cache) >= self.max_size
+            and key not in self._cache
+            and self._access_order
+        ):
+            oldest_key = self._access_order.pop(0)
+            del self._cache[oldest_key]
+            self.logger.debug("cache_evicted", key=oldest_key[:8])
+
+        # Store the entry
+        self._cache[key] = CacheEntry(
+            key=key,
+            data=data,
+            timestamp=time.time(),
+            ttl=ttl,
+        )
+
+        # Update access order
+        if key in self._access_order:
+            self._access_order.remove(key)
+        self._access_order.append(key)
+
+        self.logger.debug("cache_set", key=key[:8], ttl=ttl)
+
+    def invalidate(
+        self,
+        method: str | None = None,
+        url: str | None = None,
+        pattern: str | None = None,
+    ) -> int:
+        """Invalidate cached entries.
+
+        Args:
+            method: HTTP method to match (None for any)
+            url: URL to match (None for any)
+            pattern: URL pattern to match (None for any)
+
+        Returns:
+            Number of entries invalidated
+        """
+        keys_to_remove = []
+
+        for key, entry in self._cache.items():
+            should_remove = False
+
+            # Check if entry matches invalidation criteria
+            if pattern and pattern in str(entry.data.get("url", "")):
+                should_remove = True
+            elif method and url:
+                test_key = self._generate_key(method, url)
+                if key == test_key:
+                    should_remove = True
+
+            if should_remove:
+                keys_to_remove.append(key)
+
+        # Remove matched entries
+        for key in keys_to_remove:
+            del self._cache[key]
+            if key in self._access_order:
+                self._access_order.remove(key)
+
+        if keys_to_remove:
+            self.logger.info(
+                "cache_invalidated",
+                count=len(keys_to_remove),
+                method=method,
+                url=url,
+                pattern=pattern,
+            )
+
+        return len(keys_to_remove)
+
+    def clear(self) -> None:
+        """Clear all cached entries."""
+        count = len(self._cache)
+        self._cache.clear()
+        self._access_order.clear()
+        self.logger.info("cache_cleared", count=count)
+
+    def cleanup_expired(self) -> int:
+        """Remove all expired entries.
+
+        Returns:
+            Number of entries removed
+        """
+        expired_keys = [key for key, entry in self._cache.items() if entry.is_expired()]
+
+        for key in expired_keys:
+            del self._cache[key]
+            if key in self._access_order:
+                self._access_order.remove(key)
+
+        if expired_keys:
+            self.logger.debug("cache_cleanup", removed=len(expired_keys))
+
+        return len(expired_keys)
+
+    @property
+    def size(self) -> int:
+        """Get the current cache size."""
+        return len(self._cache)
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """Get cache statistics."""
+        return {
+            "size": self.size,
+            "max_size": self.max_size,
+            "default_ttl": self.default_ttl,
+            "oldest_entry": self._access_order[0][:8] if self._access_order else None,
+            "newest_entry": self._access_order[-1][:8] if self._access_order else None,
+        }