Update app.py

app.py

@@ -1,16 +1,21 @@
 import os
 import tempfile
 import shutil
+import subprocess
 import asyncio
 from pathlib import Path
 from typing import List, Optional, Dict, Any
 import uuid
 import re
+import time
+import hashlib
 from fastapi import (
     UploadFile,
     File,
     Form,
     HTTPException,
+    BackgroundTasks,
+    APIRouter,
     FastAPI,
 )
 from fastapi.responses import JSONResponse
@@ -19,9 +24,8 @@ import json
 import resource
 import platform
 from loguru import logger
-import subprocess
 
-app = FastAPI(title="Code Execution and Input Analysis API", docs_url="/")
+app = FastAPI(title="Code Grader API", version="1.0.0", docs_url="/")
 
 # Configuration
 MAX_EXECUTION_TIME = 5  # seconds
@@ -63,68 +67,6 @@ class CodeExecutor:
             "java": "javac",
             "python": "python3",
         }
-        # Check and log ulimits on startup
-        self._check_ulimits()
-    
-    def _check_ulimits(self):
-        """Check current ulimits and log them"""
-        try:
-            # Check various ulimits
-            limits = {
-                "RLIMIT_NOFILE": resource.RLIMIT_NOFILE,  # file descriptors
-                "RLIMIT_NPROC": resource.RLIMIT_NPROC,    # processes
-                "RLIMIT_STACK": resource.RLIMIT_STACK,    # stack size
-            }
-            
-            logger.info("Current ulimits:")
-            for name, limit_type in limits.items():
-                try:
-                    soft, hard = resource.getrlimit(limit_type)
-                    logger.info(f"{name}: soft={soft}, hard={hard}")
-                except:
-                    pass
-                    
-            # Try to increase limits if they're too low
-            try:
-                # Increase file descriptors
-                resource.setrlimit(resource.RLIMIT_NOFILE, (65536, 65536))
-            except:
-                try:
-                    # Try a lower value if the high one fails
-                    resource.setrlimit(resource.RLIMIT_NOFILE, (4096, 4096))
-                except:
-                    pass
-                    
-        except Exception as e:
-            logger.warning(f"Could not check/set ulimits: {e}")
-
-    async def _create_java_wrapper(self, workspace: str, jvm_opts: List[str]) -> str:
-        """Create a wrapper script for Java execution with ulimit settings"""
-        
-        wrapper_content = f"""#!/bin/bash
-# Set ulimits to prevent memory allocation issues
-ulimit -n 65536 2>/dev/null || ulimit -n 4096
-ulimit -u 32768 2>/dev/null || ulimit -u 2048
-ulimit -s 8192 2>/dev/null || ulimit -s 4096
-ulimit -v unlimited 2>/dev/null || true
-ulimit -m unlimited 2>/dev/null || true
-
-# Log current ulimits for debugging
-echo "Current ulimits:" >&2
-ulimit -a >&2
-
-# Execute Java with the provided options
-exec java {' '.join(jvm_opts)} "$@"
-"""
-        
-        wrapper_path = os.path.join(workspace, "java_wrapper.sh")
-        with open(wrapper_path, 'w') as f:
-            f.write(wrapper_content)
-        
-        # Make executable
-        os.chmod(wrapper_path, 0o755)
-        
-        return wrapper_path
 
     def set_resource_limits(self):
         """Set resource limits for subprocess (Unix only)"""
@@ -134,61 +76,6 @@ exec java {' '.join(jvm_opts)} "$@"
             )
             resource.setrlimit(resource.RLIMIT_AS, (MAX_MEMORY, MAX_MEMORY))
 
-    def check_available_memory(self) -> int:
-        """Create a wrapper script for Java execution with ulimit settings"""
-        
-        wrapper_content = f"""#!/bin/bash
-# Set ulimits to prevent memory allocation issues
-ulimit -n 65536 2>/dev/null || ulimit -n 4096
-ulimit -u 32768 2>/dev/null || ulimit -u 2048
-ulimit -s 8192 2>/dev/null || ulimit -s 4096
-ulimit -v unlimited 2>/dev/null || true
-ulimit -m unlimited 2>/dev/null || true
-
-# Log current ulimits for debugging
-echo "Current ulimits:" >&2
-ulimit -a >&2
-
-# Execute Java with the provided options
-exec java {' '.join(jvm_opts)} "$@"
-"""
-        
-        wrapper_path = os.path.join(workspace, "java_wrapper.sh")
-        with open(wrapper_path, 'w') as f:
-            f.write(wrapper_content)
-        
-        # Make executable
-        os.chmod(wrapper_path, 0o755)
-        
-        return wrapper_path
-        """Check available memory in MB"""
-        try:
-            with open('/proc/meminfo', 'r') as f:
-                meminfo = f.read()
-                
-            available_match = re.search(r'MemAvailable:\s+(\d+)\s+kB', meminfo)
-            if available_match:
-                available_kb = int(available_match.group(1))
-                available_mb = available_kb // 1024
-                logger.info(f"Available memory: {available_mb}MB")
-                return available_mb
-            
-            # Fallback to MemFree + Cached
-            free_match = re.search(r'MemFree:\s+(\d+)\s+kB', meminfo)
-            cached_match = re.search(r'Cached:\s+(\d+)\s+kB', meminfo)
-            
-            if free_match and cached_match:
-                free_kb = int(free_match.group(1))
-                cached_kb = int(cached_match.group(1))
-                available_mb = (free_kb + cached_kb) // 1024
-                logger.info(f"Estimated available memory: {available_mb}MB")
-                return available_mb
-                
-        except Exception as e:
-            logger.warning(f"Could not check memory: {e}")
-            
-        return 0  # Unknown
-
     def analyze_input_patterns(
         self, language: str, file_contents: Dict[str, str]
     ) -> InputAnalysisResult:
@@ -571,28 +458,26 @@ exec java {' '.join(jvm_opts)} "$@"
         workspace: str,
         input_data: Optional[List[str]] = None,
     ) -> ExecutionResult:
-        """Compile and execute Java code with optimized memory settings"""
-        
+        """Compile and execute Java code with input support"""
+
         # Check if we have .java files to compile
         java_files = list(Path(workspace).glob("*.java"))
         needs_compilation = len(java_files) > 0
-        
+
         # If we have .java files, compile them
         if needs_compilation:
             logger.info(f"Found {len(java_files)} Java source files, compiling...")
-            
-            # Compile with minimal memory
-            compile_cmd = ["javac", "-J-Xmx32m"] + [str(f) for f in java_files]
-            
+
             compile_process = await asyncio.create_subprocess_exec(
-                *compile_cmd,
+                "javac",
+                *[str(f) for f in java_files],
                 cwd=workspace,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
-            
+
             stdout, stderr = await compile_process.communicate()
-            
+
             if compile_process.returncode != 0:
                 return ExecutionResult(
                     success=False,
@@ -601,20 +486,20 @@ exec java {' '.join(jvm_opts)} "$@"
                     execution_time=0,
                     exit_code=compile_process.returncode,
                 )
-            
+
             logger.info("Java compilation successful")
         else:
-            # Check if we have .class files
+            # Check if we have .class files for the main files
             class_files_missing = []
             for main_file in main_files:
                 if main_file.endswith(".class"):
                     class_file_path = os.path.join(workspace, main_file)
                 else:
                     class_file_path = os.path.join(workspace, f"{main_file}.class")
-                
+
                 if not os.path.exists(class_file_path):
                     class_files_missing.append(main_file)
-            
+
             if class_files_missing:
                 return ExecutionResult(
                     success=False,
@@ -623,10 +508,10 @@ exec java {' '.join(jvm_opts)} "$@"
                     execution_time=0,
                     exit_code=-1,
                 )
-            
+
             logger.info("Using existing .class files, skipping compilation")
-        
-        # Execute Java with multiple fallback strategies
+
+        # Execute main files
         results = []
         for main_file in main_files:
             # Determine class name
@@ -636,7 +521,7 @@ exec java {' '.join(jvm_opts)} "$@"
                 class_name = main_file.replace(".java", "")
             else:
                 class_name = main_file
-            
+
             # Verify the .class file exists
             class_file_path = os.path.join(workspace, f"{class_name}.class")
             if not os.path.exists(class_file_path):
@@ -650,108 +535,48 @@ exec java {' '.join(jvm_opts)} "$@"
                     )
                 )
                 continue
-            
-            # Try different JVM configurations
-            jvm_configs = [
-                # Config 1: Ultra minimal with no code cache reservation
-                [
-                    "-Xint",  # Interpreter only mode (no JIT)
-                    "-Xmx32m",
-                    "-Xms2m",
-                    "-XX:MaxMetaspaceSize=16m",
-                    "-Djava.awt.headless=true",
-                ],
-                # Config 2: Minimal with small code cache
-                [
-                    "-XX:+UseSerialGC",
-                    "-Xmx32m",
-                    "-Xms4m",
-                    "-XX:ReservedCodeCacheSize=8m",
-                    "-XX:InitialCodeCacheSize=2m",
-                    "-XX:MaxMetaspaceSize=24m",
-                    "-XX:-TieredCompilation",
-                    "-Djava.awt.headless=true",
-                ],
-                # Config 3: Slightly more memory
-                [
-                    "-Xmx48m",
-                    "-Xms8m",
-                    "-XX:ReservedCodeCacheSize=16m",
-                    "-XX:MaxMetaspaceSize=32m",
-                    "-XX:-TieredCompilation",
-                    "-Djava.awt.headless=true",
-                ],
-                # Config 4: Use container support
-                [
-                    "-XX:+UseContainerSupport",
-                    "-XX:MaxRAMPercentage=25.0",
-                    "-XX:-TieredCompilation",
-                    "-Djava.awt.headless=true",
-                ],
-            ]
-            
-            result = None
-            for config_idx, jvm_opts in enumerate(jvm_configs):
-                try:
-                    logger.info(f"Trying JVM config {config_idx + 1} for {class_name}")
-                    start_time = asyncio.get_event_loop().time()
-                    
-                    # For first two configs, try with wrapper script
-                    if config_idx < 2:
-                        wrapper_path = await self._create_java_wrapper(workspace, jvm_opts)
-                        java_cmd = [wrapper_path, class_name]
-                    else:
-                        java_cmd = ["java"] + jvm_opts + [class_name]
-                    
-                    stdout, stderr, returncode = await self._execute_with_input(
-                        java_cmd, workspace, input_data
-                    )
-                    
-                    execution_time = asyncio.get_event_loop().time() - start_time
-                    
-                    # Check if it's a memory-related error
-                    stderr_text = stderr.decode("utf-8", errors="replace")
-                    if "Could not reserve" in stderr_text or "insufficient memory" in stderr_text:
-                        logger.warning(f"Config {config_idx + 1} failed with memory error, trying next...")
-                        continue
-                    
-                    result = ExecutionResult(
+
+            try:
+                start_time = asyncio.get_event_loop().time()
+
+                stdout, stderr, returncode = await self._execute_with_input(
+                    ["java", class_name], workspace, input_data
+                )
+
+                execution_time = asyncio.get_event_loop().time() - start_time
+
+                results.append(
+                    ExecutionResult(
                         success=returncode == 0,
                         stdout=stdout.decode("utf-8", errors="replace"),
-                        stderr=stderr_text,
+                        stderr=stderr.decode("utf-8", errors="replace"),
                         execution_time=execution_time,
                         exit_code=returncode,
                     )
-                    
-                    logger.info(f"Java execution completed with config {config_idx + 1}")
-                    break
-                    
-                except asyncio.TimeoutError:
-                    result = ExecutionResult(
+                )
+
+            except asyncio.TimeoutError:
+                results.append(
+                    ExecutionResult(
                         success=False,
                         stdout="",
                         stderr="Execution timeout exceeded",
                         execution_time=MAX_EXECUTION_TIME,
                         exit_code=-1,
                     )
-                    break
-                except Exception as e:
-                    logger.error(f"Error with config {config_idx + 1}: {str(e)}")
-                    continue
-            
-            # If all configs failed, return error
-            if result is None:
-                result = ExecutionResult(
-                    success=False,
-                    stdout="",
-                    stderr="Failed to execute Java code with all memory configurations. The container environment may have insufficient memory for JVM.",
-                    execution_time=0,
-                    exit_code=-1,
-                    error="All JVM configurations failed"
                 )
-            
-            results.append(result)
-        
+            except Exception as e:
+                results.append(
+                    ExecutionResult(
+                        success=False,
+                        stdout="",
+                        stderr=str(e),
+                        execution_time=0,
+                        exit_code=-1,
+                        error=str(e),
+                    )
+                )
+
         return self._combine_results(results, main_files)
 
     async def _execute_c_cpp(
@@ -995,12 +820,6 @@ def detect_language_from_files(main_files: List[str]) -> str:
     return detected_language
 
 
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy", "timestamp": asyncio.get_event_loop().time()}
-
-
 @app.post("/analyze-inputs")
 async def analyze_inputs(code_content: str = Form(...), language: str = Form(...)):
     """
@@ -1032,6 +851,8 @@ async def analyze_inputs(code_content: str = Form(...), language: str = Form(...
         )
         result_dict = analysis_result.model_dump()
 
+        # Cache the result
+
         logger.info(f"Input analysis completed for {language} code")
         return JSONResponse(content=result_dict)
 
@@ -1223,9 +1044,3 @@ input("Press enter to continue...")
             "",  # for press enter
         ],
     }
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)