854396680f
- Recipes: Now content-addressed only (cache + IPFS), removed Redis storage - Runs: Completed runs stored in PostgreSQL, Redis only for task_id mapping - Add list_runs_by_actor() to database.py for paginated run queries - Add list_by_type() to cache_manager for filtering by node_type - Fix upload endpoint to return size and filename fields - Fix recipe run endpoint with proper DAG input binding - Fix get_run_service() dependency to pass database module Storage architecture: - Redis: Ephemeral only (sessions, task mappings with TTL) - PostgreSQL: Permanent records (completed runs, metadata) - Cache: Content-addressed files (recipes, media, outputs) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
137 lines
3.5 KiB
Python
137 lines
3.5 KiB
Python
"""
|
|
FastAPI dependency injection container.
|
|
|
|
Provides shared resources and services to route handlers.
|
|
"""
|
|
|
|
from functools import lru_cache
|
|
from typing import Optional
|
|
import asyncio
|
|
|
|
from fastapi import Request, Depends, HTTPException
|
|
from jinja2 import Environment
|
|
|
|
from artdag_common.middleware.auth import UserContext, get_user_from_cookie, get_user_from_header
|
|
|
|
from .config import settings
|
|
|
|
|
|
# Lazy imports to avoid circular dependencies
|
|
_redis_client = None
|
|
_cache_manager = None
|
|
_database = None
|
|
|
|
|
|
def get_redis_client():
|
|
"""Get the Redis client singleton."""
|
|
global _redis_client
|
|
if _redis_client is None:
|
|
import redis
|
|
_redis_client = redis.from_url(settings.redis_url, decode_responses=True)
|
|
return _redis_client
|
|
|
|
|
|
def get_cache_manager():
|
|
"""Get the cache manager singleton."""
|
|
global _cache_manager
|
|
if _cache_manager is None:
|
|
from cache_manager import get_cache_manager as _get_cache_manager
|
|
_cache_manager = _get_cache_manager()
|
|
return _cache_manager
|
|
|
|
|
|
def get_database():
|
|
"""Get the database singleton."""
|
|
global _database
|
|
if _database is None:
|
|
import database
|
|
_database = database
|
|
return _database
|
|
|
|
|
|
def get_templates(request: Request) -> Environment:
|
|
"""Get the Jinja2 environment from app state."""
|
|
return request.app.state.templates
|
|
|
|
|
|
async def get_current_user(request: Request) -> Optional[UserContext]:
|
|
"""
|
|
Get the current user from request (cookie or header).
|
|
|
|
This is a permissive dependency - returns None if not authenticated.
|
|
Use require_auth for routes that require authentication.
|
|
"""
|
|
# Try header first (API clients)
|
|
ctx = get_user_from_header(request)
|
|
if ctx:
|
|
return ctx
|
|
|
|
# Fall back to cookie (browser)
|
|
return get_user_from_cookie(request)
|
|
|
|
|
|
async def require_auth(request: Request) -> UserContext:
|
|
"""
|
|
Require authentication for a route.
|
|
|
|
Raises:
|
|
HTTPException 401 if not authenticated
|
|
HTTPException 302 redirect to login for HTML requests
|
|
"""
|
|
ctx = await get_current_user(request)
|
|
if ctx is None:
|
|
# Check if HTML request for redirect
|
|
accept = request.headers.get("accept", "")
|
|
if "text/html" in accept:
|
|
raise HTTPException(
|
|
status_code=302,
|
|
headers={"Location": "/login"}
|
|
)
|
|
raise HTTPException(status_code=401, detail="Authentication required")
|
|
return ctx
|
|
|
|
|
|
async def get_user_context_from_cookie(request: Request) -> Optional[UserContext]:
|
|
"""
|
|
Legacy compatibility: get user from cookie.
|
|
|
|
Validates token with L2 server if configured.
|
|
"""
|
|
ctx = get_user_from_cookie(request)
|
|
if ctx is None:
|
|
return None
|
|
|
|
# If L2 server configured, could validate token here
|
|
# For now, trust the cookie
|
|
return ctx
|
|
|
|
|
|
# Service dependencies (lazy loading)
|
|
|
|
def get_run_service():
|
|
"""Get the run service."""
|
|
from .services.run_service import RunService
|
|
return RunService(
|
|
database=get_database(),
|
|
redis=get_redis_client(),
|
|
cache=get_cache_manager(),
|
|
)
|
|
|
|
|
|
def get_recipe_service():
|
|
"""Get the recipe service."""
|
|
from .services.recipe_service import RecipeService
|
|
return RecipeService(
|
|
redis=get_redis_client(), # Kept for API compatibility, not used
|
|
cache=get_cache_manager(),
|
|
)
|
|
|
|
|
|
def get_cache_service():
|
|
"""Get the cache service."""
|
|
from .services.cache_service import CacheService
|
|
return CacheService(
|
|
cache_manager=get_cache_manager(),
|
|
database=get_database(),
|
|
)
|