Upload app.py

app.py

@@ -1,6 +1,6 @@
 """
-Flare – Main Application (Refactored)
-=====================================
+Flare – Main Application (Refactored with Event-Driven Architecture)
+====================================================================
 """
 # FastAPI imports
 from fastapi import FastAPI, WebSocket, Request, status
@@ -17,15 +17,12 @@ import mimetypes
 import uuid
 import traceback
 from datetime import datetime
+import asyncio
+import time
 from pydantic import ValidationError
 from dotenv import load_dotenv
 
-# Project imports
-from routes.websocket_handler import websocket_endpoint
-from routes.admin_routes import router as admin_router, start_cleanup_task
-from llm.llm_startup import run_in_thread
-from session import session_store, start_session_cleanup
-from config.config_provider import ConfigProvider
+# Event-driven architecture imports
 from event_bus import event_bus
 from state_orchestrator import StateOrchestrator
 from websocket_manager import WebSocketManager
@@ -35,19 +32,26 @@ from tts_lifecycle_manager import TTSLifecycleManager
 from llm_manager import LLMManager
 from audio_buffer_manager import AudioBufferManager
 
-# Logger imports (utils.log yerine)
+# Project imports
+from routes.admin_routes import router as admin_router, start_cleanup_task
+from llm.llm_startup import run_in_thread
+from session import session_store, start_session_cleanup
+from config.config_provider import ConfigProvider
+
+# Logger imports
 from utils.logger import log_error, log_info, log_warning
 
 # Exception imports
 from utils.exceptions import (
     DuplicateResourceError,
     RaceConditionError,
-    ValidationError,
+    ValidationError as FlareValidationError,
     ResourceNotFoundError,
     AuthenticationError,
     AuthorizationError,
     ConfigurationError,
-    get_http_status_code
+    get_http_status_code,
+    FlareException
 )
 
 # Load .env file if exists
@@ -148,9 +152,71 @@ async def add_request_id(request: Request, call_next):
         )
         raise
 
-run_in_thread()  # Start LLM startup notifier if needed
-start_cleanup_task()  # Activity log cleanup
-start_session_cleanup()  # Session cleanup
+# ===================== Event-Driven Architecture Initialization =====================
+@app.on_event("startup")
+async def startup_event():
+    """Initialize event-driven components on startup"""
+    try:
+        # Initialize event bus
+        await event_bus.start()
+        log_info("✅ Event bus started")
+        
+        # Initialize resource manager
+        resource_manager = ResourceManager(event_bus)
+        await resource_manager.start()
+        log_info("✅ Resource manager started")
+        
+        # Initialize managers
+        state_orchestrator = StateOrchestrator(event_bus)
+        websocket_manager = WebSocketManager(event_bus)
+        audio_buffer_manager = AudioBufferManager(event_bus)
+        stt_manager = STTLifecycleManager(event_bus, resource_manager)
+        tts_manager = TTSLifecycleManager(event_bus, resource_manager)
+        llm_manager = LLMManager(event_bus, resource_manager)
+        
+        # Store in app state for access in routes
+        app.state.event_bus = event_bus
+        app.state.resource_manager = resource_manager
+        app.state.state_orchestrator = state_orchestrator
+        app.state.websocket_manager = websocket_manager
+        app.state.audio_buffer_manager = audio_buffer_manager
+        app.state.stt_manager = stt_manager
+        app.state.tts_manager = tts_manager
+        app.state.llm_manager = llm_manager
+        
+        log_info("✅ All managers initialized")
+        
+        # Start existing background tasks
+        run_in_thread()  # Start LLM startup notifier if needed
+        start_cleanup_task()  # Activity log cleanup
+        start_session_cleanup()  # Session cleanup
+        
+        log_info("✅ Background tasks started")
+        
+    except Exception as e:
+        log_error("❌ Failed to start event-driven components", error=str(e), traceback=traceback.format_exc())
+        raise
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup event-driven components on shutdown"""
+    try:
+        # Stop event bus
+        await event_bus.stop()
+        log_info("✅ Event bus stopped")
+        
+        # Stop resource manager
+        if hasattr(app.state, 'resource_manager'):
+            await app.state.resource_manager.stop()
+            log_info("✅ Resource manager stopped")
+            
+        # Close all WebSocket connections
+        if hasattr(app.state, 'websocket_manager'):
+            await app.state.websocket_manager.close_all_connections()
+            log_info("✅ All WebSocket connections closed")
+            
+    except Exception as e:
+        log_error("❌ Error during shutdown", error=str(e))
 
 # ---------------- Core chat/session routes --------------------------
 from routes.chat_handler import router as chat_router
@@ -163,8 +229,59 @@ app.include_router(audio_router, prefix="/api")
 # ---------------- Admin API routes ----------------------------------
 app.include_router(admin_router, prefix="/api/admin")
 
+# ---------------- WebSocket route for real-time chat ------------------
+@app.websocket("/ws/conversation/{session_id}")
+async def websocket_route(websocket: WebSocket, session_id: str):
+    """Handle WebSocket connections using the new WebSocketManager"""
+    if hasattr(app.state, 'websocket_manager'):
+        await app.state.websocket_manager.handle_connection(websocket, session_id)
+    else:
+        log_error("WebSocketManager not initialized")
+        await websocket.close(code=1011, reason="Server not ready")
+
+# ---------------- Test endpoint for event-driven flow ------------------
+@app.post("/api/test/realtime")
+async def test_realtime():
+    """Test endpoint for event-driven realtime flow"""
+    from event_bus import Event, EventType
+    
+    try:
+        # Create a test session
+        session = session_store.create_session(
+            project_name="kronos_jet",
+            version_no=1,
+            is_realtime=True
+        )
+        
+        # Get version config
+        cfg = ConfigProvider.get()
+        project = next((p for p in cfg.projects if p.name == "kronos_jet"), None)
+        if project:
+            version = next((v for v in project.versions if v.no == 1), None)
+            if version:
+                session.set_version_config(version)
+        
+        # Publish session started event
+        await app.state.event_bus.publish(Event(
+            type=EventType.SESSION_STARTED,
+            session_id=session.session_id,
+            data={
+                "session": session,
+                "has_welcome": bool(version and version.welcome_prompt),
+                "welcome_text": version.welcome_prompt if version and version.welcome_prompt else "Hoş geldiniz!"
+            }
+        ))
+        
+        return {
+            "session_id": session.session_id,
+            "message": "Test session created. Connect via WebSocket to continue."
+        }
+        
+    except Exception as e:
+        log_error("Test endpoint error", error=str(e))
+        raise HTTPException(500, f"Test failed: {str(e)}")
+
 # ---------------- Exception Handlers ----------------------------------
-# Add global exception handler
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
     """Handle all unhandled exceptions"""
@@ -184,7 +301,13 @@ async def global_exception_handler(request: Request, exc: Exception):
     # Special handling for FlareExceptions
     if isinstance(exc, FlareException):
         status_code = get_http_status_code(exc)
-        response_body = format_error_response(exc, request_id)
+        response_body = {
+            "error": type(exc).__name__,
+            "message": str(exc),
+            "request_id": request_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "details": getattr(exc, 'details', {})
+        }
 
         # Special message for race conditions
         if isinstance(exc, RaceConditionError):
@@ -228,8 +351,8 @@ async def race_condition_handler(request: Request, exc: RaceConditionError):
         content=exc.to_http_detail()
     )
 
-@app.exception_handler(ValidationError)
-async def validation_error_handler(request: Request, exc: ValidationError):
+@app.exception_handler(FlareValidationError)
+async def validation_error_handler(request: Request, exc: FlareValidationError):
     """Handle validation errors"""
     return JSONResponse(
         status_code=422,
@@ -290,7 +413,7 @@ async def configuration_error_handler(request: Request, exc: ConfigurationError)
 # ---------------- Metrics endpoint -----------------
 @app.get("/metrics")
 async def get_metrics():
-    """Get system metrics"""
+    """Get system metrics including event-driven components"""
     import psutil
     import gc
 
@@ -300,6 +423,23 @@ async def get_metrics():
 
     # Session stats
     session_stats = session_store.get_session_stats()
+    
+    # Event-driven component stats
+    event_stats = {}
+    if hasattr(app.state, 'stt_manager'):
+        event_stats['stt'] = app.state.stt_manager.get_stats()
+    if hasattr(app.state, 'tts_manager'):
+        event_stats['tts'] = app.state.tts_manager.get_stats()
+    if hasattr(app.state, 'llm_manager'):
+        event_stats['llm'] = app.state.llm_manager.get_stats()
+    if hasattr(app.state, 'websocket_manager'):
+        event_stats['websocket'] = {
+            'active_connections': app.state.websocket_manager.get_connection_count()
+        }
+    if hasattr(app.state, 'resource_manager'):
+        event_stats['resources'] = app.state.resource_manager.get_stats()
+    if hasattr(app.state, 'audio_buffer_manager'):
+        event_stats['audio_buffers'] = app.state.audio_buffer_manager.get_all_stats()
 
     metrics = {
         "memory": {
@@ -312,6 +452,7 @@ async def get_metrics():
             "num_threads": process.num_threads()
         },
         "sessions": session_stats,
+        "event_driven_components": event_stats,
         "gc": {
             "collections": gc.get_count(),
             "objects": len(gc.get_objects())
@@ -325,18 +466,26 @@ async def get_metrics():
 @app.get("/api/health")
 def health_check():
     """Health check endpoint - moved to /api/health"""
+    # Check if event-driven components are healthy
+    event_bus_healthy = hasattr(app.state, 'event_bus') and app.state.event_bus._running
+    
     return {
-        "status": "ok",
+        "status": "ok" if event_bus_healthy else "degraded",
         "version": "2.0.0",
         "timestamp": datetime.utcnow().isoformat(),
-        "environment": os.getenv("ENVIRONMENT", "development")
+        "environment": os.getenv("ENVIRONMENT", "development"),
+        "event_driven": {
+            "event_bus": "running" if event_bus_healthy else "not_running",
+            "managers": {
+                "state_orchestrator": "initialized" if hasattr(app.state, 'state_orchestrator') else "not_initialized",
+                "websocket_manager": "initialized" if hasattr(app.state, 'websocket_manager') else "not_initialized",
+                "stt_manager": "initialized" if hasattr(app.state, 'stt_manager') else "not_initialized",
+                "tts_manager": "initialized" if hasattr(app.state, 'tts_manager') else "not_initialized",
+                "llm_manager": "initialized" if hasattr(app.state, 'llm_manager') else "not_initialized"
+            }
+        }
     }
 
-# ---------------- WebSocket route for real-time STT ------------------
-@app.websocket("/ws/conversation/{session_id}")
-async def conversation_websocket(websocket: WebSocket, session_id: str):
-    await websocket_endpoint(websocket, session_id)
-
 # ---------------- Serve static files ------------------------------------
 # UI static files (production build)
 static_path = Path(__file__).parent / "static"
@@ -393,4 +542,4 @@ else:
 
 if __name__ == "__main__":
     log_info("🌐 Starting Flare backend on port 7860...")
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)