Rename app.py to main.py

app.py

@@ -1,96 +0,0 @@
-import os
-import re
-import shutil
-import subprocess
-import tempfile
-import uuid
-import time
-import resource  # Only works on Unix-like systems
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-
-app = FastAPI()
-
-# Allow CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-def extract_class_name(code: str) -> str:
-    match = re.search(r'public\s+class\s+(\w+)', code)
-    return match.group(1) if match else "Main"
-
-@app.post("/run")
-async def run_java(request: Request):
-    data = await request.json()
-    code = data.get("code", "")
-
-    if not code.strip():
-        return {"status": "error", "message": "No code provided"}
-
-    run_id = str(uuid.uuid4())
-    workdir = os.path.join(tempfile.gettempdir(), f"runner_{run_id}")
-    os.makedirs(workdir, exist_ok=True)
-
-    try:
-        class_name = extract_class_name(code)
-        java_file = os.path.join(workdir, f"{class_name}.java")
-
-        with open(java_file, "w") as f:
-            f.write(code)
-
-        # --- Compile phase ---
-        start_compile = time.time()
-        compile_proc = subprocess.run(
-            ["javac", java_file],
-            capture_output=True,
-            text=True,
-            cwd=workdir
-        )
-        end_compile = time.time()
-        compile_time = (end_compile - start_compile) * 1000  # ms
-
-        if compile_proc.returncode != 0:
-            return {
-                "status": "error",
-                "stage": "compile",
-                "compile_time_ms": round(compile_time, 2),
-                "exit_code": compile_proc.returncode,
-                "stdout": compile_proc.stdout,
-                "stderr": compile_proc.stderr,
-            }
-
-        # --- Run phase ---
-        start_run = time.time()
-        run_proc = subprocess.run(
-            ["java", "-cp", workdir, class_name],
-            capture_output=True,
-            text=True,
-            cwd=workdir
-        )
-        end_run = time.time()
-        run_time = (end_run - start_run) * 1000  # ms
-
-        # Memory usage (only works on Linux/macOS, returns KB)
-        usage = resource.getrusage(resource.RUSAGE_CHILDREN)
-        memory_kb = usage.ru_maxrss
-
-        result = {
-            "status": "success" if run_proc.returncode == 0 else "error",
-            "stage": "run",
-            "compile_time_ms": round(compile_time, 2),
-            "execution_time_ms": round(run_time, 2),
-            "exit_code": run_proc.returncode,
-            "stdout": run_proc.stdout,
-            "stderr": run_proc.stderr,
-            "memory_kb": memory_kb
-        }
-
-        return result
-
-    finally:
-        shutil.rmtree(workdir, ignore_errors=True)

main.py

@@ -0,0 +1,36 @@
+from fastapi import FastAPI, Request
+from redis import Redis
+from rq import Queue
+from runner import run_java
+
+app = FastAPI(title="Safe Java Runner")
+
+# Connect to Redis
+redis_conn = Redis(host="localhost", port=6379)
+queue = Queue(connection=redis_conn)
+
+@app.post("/run")
+async def submit_code(request: Request):
+    data = await request.json()
+    code = data.get("code", "")
+
+    if not code.strip():
+        return {"status": "error", "message": "No code provided"}
+
+    job = queue.enqueue(run_java, code)
+    return {"status": "queued", "job_id": job.id}
+
+@app.get("/result/{job_id}")
+async def get_result(job_id: str):
+    from rq.job import Job
+    try:
+        job = Job.fetch(job_id, connection=redis_conn)
+    except Exception:
+        return {"status": "error", "message": "Job not found"}
+
+    if job.is_finished:
+        return {"status": "finished", "result": job.result}
+    elif job.is_failed:
+        return {"status": "failed", "error": str(job.exc_info)}
+    else:
+        return {"status": "running"}