Update main.py

main.py

@@ -122,6 +122,13 @@ _GLOBAL_DEEPCASTLE_ENGINE = None
 _ENGINE_LOCK = asyncio.Lock()
 _ENGINE_IO_LOCK = asyncio.Lock()
 
+# Global state for monitoring
+_PENDING_ENGINE_REQUESTS = 0
+_MAX_PENDING_ENGINE_REQUESTS = 10  # Drop requests if queue is too long to prevent OOM
+_MAX_PENDING_GAME_REVIEWS = 2     # Max concurrent full game reviews (heavy RAM)
+_PENDING_GAME_REVIEWS = 0
+_LOCK_TIMEOUT_SEC = 20.0            # Max wait time in queue before giving up
+
 
 def _engine_hash_mb() -> int:
     try:
@@ -456,25 +463,35 @@ def normalize_search_stats(info: dict) -> Tuple[int, int, int]:
 # ─── Bot Move (/move) ──────────────────────────────────────────────────────────
 @app.post("/move", response_model=MoveResponse)
 async def get_move(request: MoveRequest):
+    global _PENDING_ENGINE_REQUESTS
+    if _PENDING_ENGINE_REQUESTS > _MAX_PENDING_ENGINE_REQUESTS:
+        force_memory_release()
+        raise HTTPException(status_code=429, detail="Server busy — too many analysis requests.")
+
+    _PENDING_ENGINE_REQUESTS += 1
     try:
         engine = await get_deepcastle_engine()
         board = chess.Board(request.fen)
         limit = chess.engine.Limit(time=request.time, depth=request.depth)
         tsec = _search_timeout_sec(request.time, request.depth)
 
-        async with _ENGINE_IO_LOCK:
-            result = await _engine_call(
-                engine,
-                engine.play(board, limit, info=chess.engine.INFO_ALL),
-                tsec,
-            )
-            info = dict(result.info)
-            if not info:
-                info = await _engine_call(
-                    engine,
-                    engine.analyse(board, limit, info=chess.engine.INFO_ALL),
-                    tsec,
-                )
+        try:
+            async with asyncio.timeout(_LOCK_TIMEOUT_SEC):
+                async with _ENGINE_IO_LOCK:
+                    result = await _engine_call(
+                        engine,
+                        engine.play(board, limit, info=chess.engine.INFO_ALL),
+                        tsec,
+                    )
+                    info = dict(result.info)
+                    if not info:
+                        info = await _engine_call(
+                            engine,
+                            engine.analyse(board, limit, info=chess.engine.INFO_ALL),
+                            tsec,
+                        )
+        except asyncio.TimeoutError:
+            raise HTTPException(status_code=503, detail="Server overloaded — lock wait timeout.")
 
         score_cp, mate_in = get_normalized_score(info)
         depth, nodes, nps = normalize_search_stats(info)
@@ -500,6 +517,11 @@ async def get_move(request: MoveRequest):
 
         del result
         del info
+        
+        # Match Shield: Force cleanup and hash clear after every move to prevent "Idle Growth"
+        async with _ENGINE_IO_LOCK:
+            await _clear_engine_hash(engine)
+        force_memory_release()
 
         return MoveResponse(
             bestmove=best_move,
@@ -516,30 +538,42 @@ async def get_move(request: MoveRequest):
     except Exception as e:
         print(f"Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        _PENDING_ENGINE_REQUESTS -= 1
 
 
 # ─── Hint Move (/analysis-move) ───────────────────────────────────────────────
 @app.post("/analysis-move", response_model=MoveResponse)
 async def get_analysis_move(request: MoveRequest):
+    global _PENDING_ENGINE_REQUESTS
+    if _PENDING_ENGINE_REQUESTS > _MAX_PENDING_ENGINE_REQUESTS:
+        force_memory_release()
+        raise HTTPException(status_code=429, detail="Server busy — too many analysis requests.")
+
+    _PENDING_ENGINE_REQUESTS += 1
     try:
         engine = await get_stockfish_engine()
         board = chess.Board(request.fen)
         limit = chess.engine.Limit(time=request.time, depth=request.depth)
         tsec = _search_timeout_sec(request.time, request.depth)
 
-        async with _ENGINE_IO_LOCK:
-            result = await _engine_call(
-                engine,
-                engine.play(board, limit, info=chess.engine.INFO_ALL),
-                tsec,
-            )
-            info = dict(result.info)
-            if not info:
-                info = await _engine_call(
-                    engine,
-                    engine.analyse(board, limit, info=chess.engine.INFO_ALL),
-                    tsec,
-                )
+        try:
+            async with asyncio.timeout(_LOCK_TIMEOUT_SEC):
+                async with _ENGINE_IO_LOCK:
+                    result = await _engine_call(
+                        engine,
+                        engine.play(board, limit, info=chess.engine.INFO_ALL),
+                        tsec,
+                    )
+                    info = dict(result.info)
+                    if not info:
+                        info = await _engine_call(
+                            engine,
+                            engine.analyse(board, limit, info=chess.engine.INFO_ALL),
+                            tsec,
+                        )
+        except asyncio.TimeoutError:
+            raise HTTPException(status_code=503, detail="Server overloaded — lock wait timeout.")
 
         score_cp, mate_in = get_normalized_score(info)
         depth, nodes, nps = normalize_search_stats(info)
@@ -586,6 +620,8 @@ async def get_analysis_move(request: MoveRequest):
     except Exception as e:
         print(f"Analysis move error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        _PENDING_ENGINE_REQUESTS -= 1
 
 
 # ─── Openings DB ───────────────────────────────────────────────────────────────
@@ -741,6 +777,16 @@ def get_move_classification(
 # ─── Game Analysis (/analyze-game) ────────────────────────────────────────────
 @app.post("/analyze-game", response_model=AnalyzeResponse)
 async def analyze_game(request: AnalyzeRequest):
+    global _PENDING_ENGINE_REQUESTS, _PENDING_GAME_REVIEWS
+    
+    if _PENDING_GAME_REVIEWS >= _MAX_PENDING_GAME_REVIEWS:
+        raise HTTPException(status_code=429, detail="Analysis queue full. Only 2 games can be reviewed at once.")
+    
+    if _PENDING_ENGINE_REQUESTS >= _MAX_PENDING_ENGINE_REQUESTS:
+        raise HTTPException(status_code=429, detail="Server busy — too many moving parts.")
+
+    _PENDING_ENGINE_REQUESTS += 1
+    _PENDING_GAME_REVIEWS += 1
     try:
         engine = await get_stockfish_engine()
         board = chess.Board(request.start_fen) if request.start_fen else chess.Board()
@@ -912,6 +958,9 @@ async def analyze_game(request: AnalyzeRequest):
     except Exception as e:
         print(f"Analysis Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        _PENDING_ENGINE_REQUESTS -= 1
+        _PENDING_GAME_REVIEWS -= 1
 
 
 if __name__ == "__main__":