Add runtime, FastAPI main, and worker

Dockerfile

@@ -0,0 +1,40 @@
+# Use a lightweight base with Python
+FROM python:3.10-slim-bullseye
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    redis-server \
+    supervisor \
+    curl \
+    xz-utils \
+    && rm -rf /var/lib/apt/apt-get/lists/*
+
+WORKDIR /app
+
+# --- Install Piston Engine ---
+RUN curl -L https://github.com/engineer-man/piston/releases/download/v2.0.0/piston-v2.0.0.tar.gz | tar -xz \
+    && mv piston-v2.0.0 /app/piston
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all application files
+COPY . .
+
+# --- Runtime Installation Phase ---
+RUN chmod +x install_runtimes.sh && ./install_runtimes.sh && rm install_runtimes.sh
+
+# --- Security & Permissions ---
+RUN useradd -m appuser
+RUN mkdir -p /tmp/piston_jobs && chown -R appuser:appuser /app /tmp/piston_jobs
+
+# Set environment variables
+ENV PISTON_URL=http://localhost:2000/api/v2/execute
+ENV PYTHONUNBUFFERED=1
+
+# Hugging Face Spaces port
+EXPOSE 7860
+
+# Start Supervisor
+CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"]

install_runtime.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Start Piston in the background temporarily
+/app/piston/piston-server & 
+PISTON_PID=$!
+
+# Wait for Piston to wake up
+sleep 5
+
+# Install common runtimes
+languages=("python" "javascript" "cpp" "java")
+
+for lang in "${languages[@]}"; do
+    echo "Installing $lang..."
+    curl -X POST http://localhost:2000/api/v2/packages \
+         -H "Content-Type: application/json" \
+         -d "{\"language\": \"$lang\", \"version\": \"*\"}"
+done
+
+# Shutdown the temporary Piston process
+kill $PISTON_PID
+echo "Runtimes installed successfully."

main.py

@@ -0,0 +1,85 @@
+import os
+import time
+import json
+from typing import List, Optional
+from fastapi import FastAPI, HTTPException, Depends, Header, BackgroundTasks
+from pydantic import BaseModel
+from jose import jwt, JWTError
+from redis import Redis
+from rq import Queue
+import httpx
+
+# --- Configuration ---
+# These should be set in Hugging Face Space Secrets
+SUPABASE_JWT_SECRET = os.getenv("SUPABASE_JWT_SECRET", "")
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+
+app = FastAPI(title="Piston Execution Gateway")
+redis_conn = Redis(host='localhost', port=6379)
+q = Queue('executions', connection=redis_conn)
+
+# --- Models ---
+class CodeExecutionRequest(BaseModel):
+    problem_id: str
+    source_code: str
+    language: str
+    is_submit: bool = False
+
+class ExecutionResponse(BaseModel):
+    job_id: str
+    status: str
+
+# --- Middleware: JWT Verification ---
+async def verify_supabase_jwt(authorization: str = Header(None)):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Missing or invalid token")
+    
+    token = authorization.split(" ")[1]
+    try:
+        # Validate the token using Supabase JWT Secret
+        payload = jwt.decode(
+            token, 
+            SUPABASE_JWT_SECRET, 
+            algorithms=["HS256"], 
+            options={"verify_aud": False}
+        )
+        return payload  # Contains user_id (sub)
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Token verification failed")
+
+# --- Core Logic ---
+@app.post("/execute", response_model=ExecutionResponse)
+async def execute_code(
+    request: CodeExecutionRequest, 
+    user: dict = Depends(verify_supabase_jwt)
+):
+    """
+    Validates user, pushes job to Redis queue, and returns immediately.
+    """
+    job_id = f"job_{int(time.time() * 1000)}_{user.get('sub')[:8]}"
+    
+    # Payload for the worker
+    job_data = {
+        "job_id": job_id,
+        "user_id": user.get("sub"),
+        "problem_id": request.problem_id,
+        "source_code": request.source_code,
+        "language": request.language,
+        "is_submit": request.is_submit,
+        "timestamp": time.time()
+    }
+
+    # Push to Redis Queue
+    # We use 'worker.process_job' which we will define in the next file
+    q.enqueue("worker.process_job", job_data, job_id=job_id)
+
+    return {"job_id": job_id, "status": "queued"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "online", "queue_size": len(q)}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn[standard]
+supabase
+python-jose[cryptography]
+python-multipart
+redis
+rq
+pydantic
+pydantic-settings
+httpx
+requests
+supervisor

supervisord.conf

@@ -0,0 +1,36 @@
+[supervisord]
+nodaemon=true
+user=root
+logfile=/app/supervisord.log
+pidfile=/var/run/supervisord.pid
+
+[program:redis]
+command=redis-server --port 6379 --bind 127.0.0.1 --maxmemory 256mb --maxmemory-policy allkeys-lru
+autostart=true
+autorestart=true
+stdout_logfile=/app/redis.log
+stderr_logfile=/app/redis.err
+
+[program:piston]
+command=/app/piston/piston-server
+directory=/app/piston
+autostart=true
+autorestart=true
+stdout_logfile=/app/piston.log
+stderr_logfile=/app/piston.err
+
+[program:fastapi]
+command=uvicorn main:app --host 0.0.0.0 --port 7860 --workers 4
+directory=/app
+autostart=true
+autorestart=true
+stdout_logfile=/app/fastapi.log
+stderr_logfile=/app/fastapi.err
+
+[program:worker]
+command=python worker.py
+directory=/app
+autostart=true
+autorestart=true
+stdout_logfile=/app/worker.log
+stderr_logfile=/app/worker.err

worker.py

@@ -0,0 +1,114 @@
+import os
+import time
+import json
+import requests
+from redis import Redis
+from rq import Worker, Queue, Connection
+from supabase import create_client, Client
+
+# --- Configuration ---
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+# Piston internal URL (assuming it runs on localhost via the Docker setup)
+PISTON_URL = os.getenv("PISTON_URL", "http://localhost:2000/api/v2/execute")
+
+# Initialize Supabase Admin Client
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY)
+
+def process_job(job_data):
+    """
+    The core logic executed by the background worker.
+    """
+    job_id = job_data['job_id']
+    problem_id = job_data['problem_id']
+    source_code = job_data['source_code']
+    language = job_data['language']
+    is_submit = job_data['is_submit']
+    user_id = job_data['user_id']
+
+    try:
+        # 1. Fetch Test Cases from Supabase
+        # We fetch from 'problems' table where problem_id matches
+        # Expecting a JSON column 'test_cases' like [{"input": "...", "expected": "..."}]
+        response = supabase.table("problems").select("test_cases").eq("id", problem_id).single().execute()
+        if not response.data:
+            raise Exception(f"Problem {problem_id} not found")
+        
+        test_cases = response.data.get("test_cases", [])
+        results = []
+        all_passed = True
+
+        # 2. Iterate through Test Cases
+        for index, tc in enumerate(test_cases):
+            # Security: Custom Piston Payload with our 10MB / 1s limits
+            payload = {
+                "language": language,
+                "version": "*", # Use latest available
+                "files": [{"content": source_code}],
+                "stdin": tc.get("input", ""),
+                "run_timeout": 1000,       # 1 second limit
+                "compile_timeout": 10000,  # 10s for compilation
+                "memory_limit": 10485760,  # 10MB limit (10 * 1024 * 1024)
+            }
+
+            # Call Piston Engine
+            piston_res = requests.post(PISTON_URL, json=payload, timeout=5)
+            piston_data = piston_res.json()
+
+            run_info = piston_data.get("run", {})
+            actual_output = run_info.get("stdout", "").strip()
+            error_output = run_info.get("stderr", "")
+            
+            passed = actual_output == tc.get("expected", "").strip()
+            if not passed:
+                all_passed = False
+
+            results.append({
+                "test_case": index + 1,
+                "passed": passed,
+                "stdout": actual_output if not is_submit else "Hidden",
+                "stderr": error_output,
+                "exit_code": run_info.get("code")
+            })
+
+            # Optimization: If it's a 'Run' and one fails, we can stop early
+            if not passed and not is_submit:
+                break
+
+        # 3. Handle Persistence & Real-time Update
+        final_payload = {
+            "job_id": job_id,
+            "user_id": user_id,
+            "problem_id": problem_id,
+            "status": "completed",
+            "results": results,
+            "all_passed": all_passed,
+            "created_at": "now()"
+        }
+
+        if is_submit:
+            # Save to 'submissions' table
+            supabase.table("submissions").insert(final_payload).execute()
+        
+        # Broadcast via a 'results' table or a dedicated Realtime channel
+        # Here we update a 'job_status' table that the frontend is listening to via Supabase Realtime
+        supabase.table("job_status").insert({
+            "job_id": job_id,
+            "user_id": user_id,
+            "data": final_payload
+        }).execute()
+
+    except Exception as e:
+        # Update status to failed
+        supabase.table("job_status").insert({
+            "job_id": job_id,
+            "user_id": user_id,
+            "data": {"status": "error", "message": str(e)}
+        }).execute()
+
+if __name__ == '__main__':
+    # Connect to the local Redis instance defined in supervisord.conf
+    redis_conn = Redis(host='localhost', port=6379)
+    with Connection(redis_conn):
+        worker = Worker([Queue('executions')])
+        worker.work()