Update app.py

app.py

@@ -100,60 +100,6 @@ class CodeExecutor:
             
         return 0  # Unknown
 
-    async def _create_java_wrapper(self, workspace: str) -> str:
-        """Create a wrapper script for Java execution with better memory handling"""
-        
-        wrapper_script = """#!/bin/bash
-# Java memory wrapper for container environments
-
-# Get available memory
-AVAILABLE_MEM=$(awk '/MemAvailable/ {print int($2/1024)}' /proc/meminfo 2>/dev/null || echo "32")
-
-if [ "$AVAILABLE_MEM" -lt 20 ]; then
-    echo "Error: Insufficient memory available ($AVAILABLE_MEM MB)" >&2
-    exit 1
-fi
-
-# Calculate heap size (15% of available, min 8MB, max 16MB)
-HEAP_SIZE=$((AVAILABLE_MEM * 15 / 100))
-if [ "$HEAP_SIZE" -lt 8 ]; then
-    HEAP_SIZE=8
-elif [ "$HEAP_SIZE" -gt 16 ]; then
-    HEAP_SIZE=16
-fi
-
-# Calculate code cache (smaller)
-CODE_CACHE_SIZE=$((HEAP_SIZE / 4))
-if [ "$CODE_CACHE_SIZE" -lt 4 ]; then
-    CODE_CACHE_SIZE=4
-fi
-
-echo "Using ${HEAP_SIZE}MB heap, ${CODE_CACHE_SIZE}MB code cache (${AVAILABLE_MEM}MB available)" >&2
-
-# Execute Java with proper stack size and memory limits
-exec java \\
-    -Xms2m \\
-    -Xmx${HEAP_SIZE}m \\
-    -XX:ReservedCodeCacheSize=${CODE_CACHE_SIZE}m \\
-    -XX:InitialCodeCacheSize=1m \\
-    -XX:+UseSerialGC \\
-    -XX:MaxMetaspaceSize=16m \\
-    -XX:CompressedClassSpaceSize=8m \\
-    -Xss256k \\
-    -XX:-TieredCompilation \\
-    -Djava.awt.headless=true \\
-    "$@"
-"""
-        
-        wrapper_path = os.path.join(workspace, "java_wrapper.sh")
-        with open(wrapper_path, 'w') as f:
-            f.write(wrapper_script)
-        
-        # Make executable
-        os.chmod(wrapper_path, 0o755)
-        
-        return wrapper_path
-
     def analyze_input_patterns(
         self, language: str, file_contents: Dict[str, str]
     ) -> InputAnalysisResult:
@@ -536,18 +482,18 @@ exec java \\
         workspace: str,
         input_data: Optional[List[str]] = None,
     ) -> ExecutionResult:
-        """Compile and execute Java code with input support and memory optimization"""
-    
+        """Compile and execute Java code with optimized memory settings"""
+        
         # 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 absolute minimal memory for javac
-            compile_cmd = ["javac", "-J-Xmx16m", "-J-Xms2m"] + [str(f) for f in java_files]
+            
+            # 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,
@@ -555,9 +501,9 @@ exec java \\
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
-    
+            
             stdout, stderr = await compile_process.communicate()
-    
+            
             if compile_process.returncode != 0:
                 return ExecutionResult(
                     success=False,
@@ -566,20 +512,20 @@ exec java \\
                     execution_time=0,
                     exit_code=compile_process.returncode,
                 )
-    
+            
             logger.info("Java compilation successful")
         else:
-            # Check if we have .class files for the main files
+            # Check if we have .class 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,
@@ -588,72 +534,10 @@ exec java \\
                     execution_time=0,
                     exit_code=-1,
                 )
-    
-            logger.info("Using existing .class files, skipping compilation")
-    
-        # Use memory-aware wrapper for execution
-        return await self._execute_java_with_wrapper(main_files, workspace, input_data)
-
-    async def _execute_java_with_wrapper(
-        self,
-        main_files: List[str],
-        workspace: str,
-        input_data: Optional[List[str]] = None,
-    ) -> ExecutionResult:
-        """Execute Java using a memory-aware wrapper script with fallback"""
-        
-        # Try wrapper first, then fallback to minimal direct execution
-        approaches = [
-            ("wrapper", None),
-            ("minimal", ["-Xms2m", "-Xmx16m", "-Xss256k", "-Djava.awt.headless=true"]),
-            ("basic", ["-Xms2m", "-Xmx12m", "-Djava.awt.headless=true"]),
-            ("simple", ["-Xmx8m", "-Djava.awt.headless=true"]),
-            ("no_limits", ["-Djava.awt.headless=true"])
-        ]
-        
-        for approach_name, jvm_opts in approaches:
-            logger.info(f"Trying Java execution approach: {approach_name}")
             
-            try:
-                if approach_name == "wrapper":
-                    # Create and use wrapper script
-                    wrapper_path = await self._create_java_wrapper(workspace)
-                    result = await self._try_java_direct(main_files, workspace, input_data, wrapper_cmd=wrapper_path)
-                else:
-                    # Use direct java with specific JVM options
-                    result = await self._try_java_direct(main_files, workspace, input_data, jvm_opts=jvm_opts)
-                
-                # If successful or not a memory error, return result
-                if result.success or "Could not reserve" not in result.stderr:
-                    logger.info(f"Java execution successful with approach: {approach_name}")
-                    return result
-                else:
-                    logger.warning(f"Approach {approach_name} failed with memory error, trying next...")
-                    
-            except Exception as e:
-                logger.warning(f"Approach {approach_name} failed with exception: {e}")
-                continue
-        
-        # If all approaches fail
-        return ExecutionResult(
-            success=False,
-            stdout="",
-            stderr="Java execution failed with all memory configurations. Container memory too limited for JVM.",
-            execution_time=0,
-            exit_code=-1,
-            error="All JVM memory configurations failed"
-        )
-
-    async def _try_java_direct(
-        self,
-        main_files: List[str],
-        workspace: str,
-        input_data: Optional[List[str]],
-        wrapper_cmd: Optional[str] = None,
-        jvm_opts: Optional[List[str]] = None
-    ) -> ExecutionResult:
-        """Try Java execution with specific configuration"""
+            logger.info("Using existing .class files, skipping compilation")
         
+        # Execute Java with optimized settings
         results = []
         for main_file in main_files:
             # Determine class name
@@ -663,7 +547,7 @@ exec java \\
                 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):
@@ -677,24 +561,31 @@ exec java \\
                     )
                 )
                 continue
-
+            
             try:
                 start_time = asyncio.get_event_loop().time()
-
-                # Build command
-                if wrapper_cmd:
-                    java_cmd = [wrapper_cmd, class_name]
-                elif jvm_opts:
-                    java_cmd = ["java"] + jvm_opts + [class_name]
-                else:
-                    java_cmd = ["java", class_name]
+                
+                # Optimized JVM settings for container environments
+                java_cmd = [
+                    "java",
+                    "-XX:+UseSerialGC",           # Use simple GC for small heap
+                    "-Xmx64m",                     # Max heap 64MB
+                    "-Xms8m",                      # Initial heap 8MB
+                    "-XX:MaxMetaspaceSize=64m",    # Limit metaspace
+                    "-XX:MaxDirectMemorySize=32m", # Limit direct memory
+                    "-XX:-TieredCompilation",      # Disable tiered compilation
+                    "-XX:CICompilerCount=1",       # Single compiler thread
+                    "-Djava.awt.headless=true",    # Headless mode
+                    "-Dfile.encoding=UTF-8",       # UTF-8 encoding
+                    class_name
+                ]
                 
                 stdout, stderr, returncode = await self._execute_with_input(
                     java_cmd, workspace, input_data
                 )
-
+                
                 execution_time = asyncio.get_event_loop().time() - start_time
-
+                
                 results.append(
                     ExecutionResult(
                         success=returncode == 0,
@@ -704,7 +595,7 @@ exec java \\
                         exit_code=returncode,
                     )
                 )
-
+                
             except asyncio.TimeoutError:
                 results.append(
                     ExecutionResult(
@@ -716,6 +607,7 @@ exec java \\
                     )
                 )
             except Exception as e:
+                logger.error(f"Java execution error: {str(e)}")
                 results.append(
                     ExecutionResult(
                         success=False,
@@ -726,7 +618,7 @@ exec java \\
                         error=str(e),
                     )
                 )
-
+        
         return self._combine_results(results, main_files)
 
     async def _execute_c_cpp(
@@ -1007,8 +899,6 @@ 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)