Update app.py

app.py

@@ -1,19 +1,34 @@
 from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks, Query
-from fastapi.responses import FileResponse, JSONResponse
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
 import os
+import json
 import shutil
 import uuid
 import time
-from typing import Dict, List, Optional
 import threading
 import logging
+import aiofiles
 from pathlib import Path
+from typing import Dict, List, Optional
+from dataclasses import dataclass, asdict
+from datetime import datetime
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('api.log'),
+        logging.StreamHandler()
+    ]
+)
 logger = logging.getLogger(__name__)
 
+# Import error logger
+from error_logger import ErrorLogger
+error_logger = ErrorLogger()
+
 # Import processing functions and variables
 from processing_logic import (
     processing_status, 
@@ -26,7 +41,12 @@ from processing_logic import (
     DEFAULT_RAR_LIMIT
 )
 
-app = FastAPI(title="MP4 Processing API", description="API for uploading, processing, and downloading MP4 files")
+# Middleware Configuration
+LOCK_TIMEOUT = 300  # 5 minutes in seconds
+STATE_FILE = "middleware_state.json"
+CHUNK_SIZE = 8192  # 8KB chunks for streaming
+
+app = FastAPI(title="Unified MP4 Processing & Distribution API")
 
 # Configure CORS
 app.add_middleware(
@@ -37,13 +57,99 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Define MP4_UPLOAD_FOLDER if not imported from processing_logic
-MP4_UPLOAD_FOLDER = os.path.join(UPLOAD_DIRECTORY, "uploads") if 'UPLOAD_DIRECTORY' in globals() else "uploads"
+# Define folders
+MP4_UPLOAD_FOLDER = os.path.join(UPLOAD_DIRECTORY, "uploads")
 os.makedirs(MP4_UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(MP4_OUTPUT_FOLDER, exist_ok=True)
 
 processing_thread = None
 
+# ==== MIDDLEWARE STATE MANAGEMENT ====
+
+@dataclass
+class FileState:
+    path: str
+    locked: bool
+    lock_holder: Optional[str] = None
+    lock_time: Optional[float] = None
+    download_count: int = 0
+    last_access: Optional[float] = None
+
+class MiddlewareState:
+    def __init__(self):
+        self.files: Dict[str, FileState] = {}
+        self.load_state()
+    
+    def load_state(self):
+        """Load state from disk"""
+        if os.path.exists(STATE_FILE):
+            try:
+                with open(STATE_FILE, 'r') as f:
+                    data = json.load(f)
+                    self.files = {
+                        k: FileState(**v) for k, v in data.items()
+                    }
+            except Exception as e:
+                logger.error(f"Error loading state: {e}")
+                self.files = {}
+    
+    def save_state(self):
+        """Save state to disk"""
+        try:
+            with open(STATE_FILE, 'w') as f:
+                json.dump({
+                    k: asdict(v) for k, v in self.files.items()
+                }, f, indent=2)
+        except Exception as e:
+            logger.error(f"Error saving state: {e}")
+
+    def clean_expired_locks(self):
+        """Remove expired locks"""
+        now = time.time()
+        for file_id, state in self.files.items():
+            if state.locked and (now - state.lock_time) > LOCK_TIMEOUT:
+                state.locked = False
+                state.lock_holder = None
+                state.lock_time = None
+        self.save_state()
+
+    def get_next_available_file(self, requester_id: str) -> Optional[str]:
+        """Get next unlocked file"""
+        self.clean_expired_locks()
+        
+        # First try to find any file this requester has locked
+        for file_id, state in self.files.items():
+            if state.locked and state.lock_holder == requester_id:
+                return file_id
+        
+        # Then look for any unlocked file
+        for file_id, state in self.files.items():
+            if not state.locked:
+                state.locked = True
+                state.lock_holder = requester_id
+                state.lock_time = time.time()
+                self.save_state()
+                return file_id
+        
+        return None
+
+    def release_lock(self, file_id: str, requester_id: str) -> bool:
+        """Release a file lock"""
+        if file_id in self.files:
+            state = self.files[file_id]
+            if state.lock_holder == requester_id:
+                state.locked = False
+                state.lock_holder = None
+                state.lock_time = None
+                state.last_access = time.time()
+                state.download_count += 1
+                self.save_state()
+                return True
+        return False
+
+# Global state
+middleware_state = MiddlewareState()
+
 # ==== HELPER FUNCTIONS ====
 
 def save_file(uploaded_file: UploadFile, save_path: str):
@@ -55,25 +161,86 @@ def log_request(endpoint: str, params: dict = None):
     """Log API requests for debugging"""
     logger.info(f"API Request: {endpoint} - Params: {params}")
 
+# === ERROR HANDLING ===
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request, exc):
+    """Handle HTTP exceptions with detailed logging"""
+    error_id = error_logger.log_error(
+        exc,
+        request.url.path,
+        request_info={
+            "method": request.method,
+            "url": str(request.url),
+            "headers": dict(request.headers),
+            "query_params": dict(request.query_params),
+        },
+        context={
+            "status_code": exc.status_code,
+            "detail": exc.detail
+        }
+    )
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={
+            "error": exc.detail,
+            "error_id": error_id,
+            "type": "http_error",
+            "status_code": exc.status_code
+        }
+    )
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request, exc):
+    """Handle all other exceptions with detailed logging"""
+    error_id = error_logger.log_error(
+        exc,
+        request.url.path,
+        request_info={
+            "method": request.method,
+            "url": str(request.url),
+            "headers": dict(request.headers),
+            "query_params": dict(request.query_params),
+        }
+    )
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "Internal server error",
+            "error_id": error_id,
+            "type": "server_error",
+            "detail": str(exc) if app.debug else "An unexpected error occurred"
+        }
+    )
+
 # === ROUTES ===
 
 @app.get("/")
 async def root():
     """API root endpoint"""
     return {
-        "message": "MP4 Processing API",
+        "message": "Unified MP4 Processing & Distribution API",
         "version": "1.0.0",
         "status": "running",
         "endpoints": {
-            "upload": "POST /upload - Upload MP4 file",
-            "download": "GET /download?course={course}&file={file} - Download MP4 file",
-            "list": "GET /list - List uploaded files", 
-            "courses": "GET /courses - List all course folders",
-            "images": "GET /images/{course_folder:path} - List MP4s in course",
-            "debug": "GET /debug/structure - Debug file structure"
+            "processing": {
+                "courses": "GET /courses - List all course folders",
+                "images": "GET /images/{course_folder:path} - List MP4s in course",
+                "download": "GET /download?course={course}&file={file} - Download MP4 file",
+                "debug": "GET /debug/structure - Debug file structure"
+            },
+            "middleware": {
+                "status": "GET /middleware/status - Get middleware status",
+                "register": "POST /middleware/register - Register a new file",
+                "next": "GET /middleware/next - Get next available file",
+                "release": "POST /middleware/release/{file_id} - Release a file lock",
+                "stream": "GET /middleware/stream/{file_id} - Stream a file"
+            }
         }
     }
 
+# ==== PROCESSING ENDPOINTS ====
+
 @app.get("/courses")
 async def get_courses():
     """List all top-level course folders."""
@@ -156,11 +323,230 @@ async def debug_structure():
         "structure": structure
     }
 
+# ==== ERROR MONITORING ENDPOINTS ====
+
+@app.get("/errors/recent")
+async def get_recent_errors(limit: int = Query(10, ge=1, le=100)):
+    """Get most recent errors"""
+    return error_logger.get_recent_errors(limit)
+
+@app.get("/errors/{error_id}")
+async def get_error_details(error_id: str):
+    """Get detailed information about a specific error"""
+    error = error_logger.get_error(error_id)
+    if not error:
+        raise HTTPException(status_code=404, detail="Error ID not found")
+    return error
+
+@app.get("/errors/summary")
+async def get_error_summary():
+    """Get summary of errors by type"""
+    return error_logger.get_error_summary()
+
+# ==== MIDDLEWARE ENDPOINTS ====
+
+@app.get("/middleware/status")
+async def get_middleware_status():
+    """Get middleware status"""
+    courses = sum(1 for f in middleware_state.files.keys() if f.startswith("course:"))
+    images = sum(1 for f in middleware_state.files.keys() if f.startswith("image:"))
+    
+    return {
+        "active_locks": sum(1 for f in middleware_state.files.values() if f.locked),
+        "total_files": len(middleware_state.files),
+        "total_courses": courses,
+        "total_images": images,
+        "downloads_completed": sum(f.download_count for f in middleware_state.files.values())
+    }
+
+@app.get("/middleware/status/course/{course_id}")
+async def get_course_status(course_id: str):
+    """Get status of a specific course"""
+    file_id = f"course:{course_id}"
+    if file_id not in middleware_state.files:
+        raise HTTPException(status_code=404, detail="Course not found")
+    
+    state = middleware_state.files[file_id]
+    return {
+        "course_id": course_id,
+        "locked": state.locked,
+        "lock_holder": state.lock_holder,
+        "lock_time": state.lock_time,
+        "download_count": state.download_count,
+        "last_access": state.last_access
+    }
+
+@app.get("/middleware/status/image/{course_folder}/{file_id}")
+async def get_image_status(course_folder: str, file_id: str):
+    """Get status of a specific image"""
+    full_id = f"image:{course_folder}/{file_id}"
+    if full_id not in middleware_state.files:
+        raise HTTPException(status_code=404, detail="Image not found")
+    
+    state = middleware_state.files[full_id]
+    return {
+        "file_id": file_id,
+        "course": course_folder,
+        "locked": state.locked,
+        "lock_holder": state.lock_holder,
+        "lock_time": state.lock_time,
+        "download_count": state.download_count,
+        "last_access": state.last_access
+    }
+
+@app.post("/middleware/register")
+async def register_file(file_path: str):
+    """Register a new file in the system"""
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    file_id = os.path.basename(file_path)
+    if file_id not in middleware_state.files:
+        middleware_state.files[file_id] = FileState(
+            path=file_path,
+            locked=False
+        )
+        middleware_state.save_state()
+    
+    return {"file_id": file_id}
+
+@app.get("/middleware/next/course")
+async def get_next_course(requester_id: str):
+    """Get next available course folder"""
+    try:
+        courses = [d.name for d in Path(MP4_OUTPUT_FOLDER).iterdir() if d.is_dir()]
+        for course in courses:
+            course_id = f"course:{course}"
+            if course_id not in middleware_state.files:
+                middleware_state.files[course_id] = FileState(
+                    path=str(Path(MP4_OUTPUT_FOLDER) / course),
+                    locked=False
+                )
+                middleware_state.save_state()
+            
+            if not middleware_state.files[course_id].locked:
+                middleware_state.files[course_id].locked = True
+                middleware_state.files[course_id].lock_holder = requester_id
+                middleware_state.files[course_id].lock_time = time.time()
+                middleware_state.save_state()
+                return {
+                    "course_id": course,
+                    "path": str(Path(MP4_OUTPUT_FOLDER) / course),
+                    "lock_time": middleware_state.files[course_id].lock_time
+                }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get next course: {e}")
+    
+    raise HTTPException(status_code=404, detail="No courses available")
+
+@app.get("/middleware/next/image/{course_folder}")
+async def get_next_image(course_folder: str, requester_id: str):
+    """Get next available image from a specific course"""
+    course_path = Path(MP4_OUTPUT_FOLDER) / course_folder
+    
+    if not course_path.is_dir():
+        raise HTTPException(status_code=404, detail="Course folder not found")
+    
+    try:
+        mp4_files = [f for f in course_path.iterdir() if f.is_file() and f.suffix.lower() == ".mp4"]
+        for mp4_file in mp4_files:
+            file_id = f"image:{course_folder}/{mp4_file.name}"
+            if file_id not in middleware_state.files:
+                middleware_state.files[file_id] = FileState(
+                    path=str(mp4_file),
+                    locked=False
+                )
+                middleware_state.save_state()
+            
+            if not middleware_state.files[file_id].locked:
+                middleware_state.files[file_id].locked = True
+                middleware_state.files[file_id].lock_holder = requester_id
+                middleware_state.files[file_id].lock_time = time.time()
+                middleware_state.save_state()
+                return {
+                    "file_id": mp4_file.name,
+                    "course": course_folder,
+                    "path": str(mp4_file),
+                    "lock_time": middleware_state.files[file_id].lock_time
+                }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get next image: {e}")
+    
+    raise HTTPException(status_code=404, detail="No images available in this course")
+
+@app.get("/middleware/next/any")
+async def get_next_any_file(requester_id: str):
+    """Get next available file of any type"""
+    file_id = middleware_state.get_next_available_file(requester_id)
+    if not file_id:
+        raise HTTPException(status_code=404, detail="No files available")
+    
+    file_state = middleware_state.files[file_id]
+    return {
+        "file_id": file_id,
+        "file_path": file_state.path,
+        "lock_time": file_state.lock_time,
+        "type": "course" if file_id.startswith("course:") else "image"
+    }
+
+@app.post("/middleware/release/course/{course_id}")
+async def release_course(course_id: str, requester_id: str):
+    """Release a course lock"""
+    file_id = f"course:{course_id}"
+    if not middleware_state.release_lock(file_id, requester_id):
+        raise HTTPException(status_code=403, detail="Not lock holder")
+    return {"status": "ok"}
+
+@app.post("/middleware/release/image/{course_folder}/{file_id}")
+async def release_image(course_folder: str, file_id: str, requester_id: str):
+    """Release an image lock"""
+    full_id = f"image:{course_folder}/{file_id}"
+    if not middleware_state.release_lock(full_id, requester_id):
+        raise HTTPException(status_code=403, detail="Not lock holder")
+    return {"status": "ok"}
+
+@app.post("/middleware/release/{file_id}")
+async def release_file(file_id: str, requester_id: str):
+    """Release any file lock (backward compatibility)"""
+    if not middleware_state.release_lock(file_id, requester_id):
+        raise HTTPException(status_code=403, detail="Not lock holder")
+    return {"status": "ok"}
+
+@app.get("/middleware/stream/{file_id}")
+async def stream_file(file_id: str, requester_id: str):
+    """Stream a file to client"""
+    if file_id not in middleware_state.files:
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    file_state = middleware_state.files[file_id]
+    if not file_state.locked or file_state.lock_holder != requester_id:
+        raise HTTPException(status_code=403, detail="Not lock holder")
+    
+    if not os.path.exists(file_state.path):
+        raise HTTPException(status_code=404, detail="File not found on disk")
+
+    async def file_stream():
+        async with aiofiles.open(file_state.path, 'rb') as f:
+            while chunk := await f.read(CHUNK_SIZE):
+                yield chunk
+        # Auto-release lock after successful transfer
+        middleware_state.release_lock(file_id, requester_id)
+
+    return StreamingResponse(
+        file_stream(),
+        media_type="application/octet-stream",
+        headers={
+            "Content-Disposition": f"attachment; filename={file_id}"
+        }
+    )
+
+# ==== STARTUP EVENT ====
+
 @app.on_event("startup")
 async def startup_event():
     """Run the processing loop in the background when the API starts"""
     global processing_thread
-    logger.info("Starting up MP4 Processing API...")
+    logger.info("Starting up Unified MP4 Processing & Distribution API...")
     
     if not (processing_thread and processing_thread.is_alive()):
         logger.info("🚀 Starting background processing thread...")