Building an Online Code Compiler: A Complete Guide

┌─────────────────┐ WebSocket ┌─────────────────┐ │ React │ ◄──────────────► │ Node.js │ │ Frontend │ │ Backend │ │ │ HTTP/REST │ │ └─────────────────┘ ◄──────────────► └─────────────────┘ │ │ Jobs ▼ ┌─────────────────┐ ┌─────────────────┐ │ Redis │ │ RabbitMQ │ │ (Streaming) │ │ (Job Queue) │ └─────────────────┘ └─────────────────┘ ▲ │ │ Results │ Jobs │ ▼ └─────────── ┌─────────────────┐ ◄───── │ Runner │ │ Service │ │ (Go) │ └─────────────────┘ │ │ Docker API ▼ ┌─────────────────┐ │ Docker │ │ Containers │ │ (Multi-lang) │ └─────────────────┘ 

type LanguageVM struct { Language string ContainerName string IsRunning bool WorkspaceDir string mutex sync.Mutex } type Manager struct { config config.FirecrackerConfig logger *logrus.Logger vms map[string]*LanguageVM vmsMutex sync.RWMutex } 

func (m *Manager) initializePersistentContainers() error { m.logger.Info("Initializing persistent containers for all languages...") for language := range m.config.Environments { m.logger.Infof("Starting persistent container for language: %s", language) vm := &LanguageVM{ Language: language, ContainerName: fmt.Sprintf("runner-vm-%s", language), WorkspaceDir: filepath.Join(m.config.WorkspaceDir, language), IsRunning: false, } // Create language-specific workspace directory if err := os.MkdirAll(vm.WorkspaceDir, 0755); err != nil { return fmt.Errorf("failed to create workspace directory for %s: %w", language, err) } // Start the container if err := m.startPersistentContainer(vm); err != nil { m.logger.Errorf("Failed to start container for %s: %v", language, err) continue } m.vms[language] = vm } return nil } 

func (m *Manager) executeInPersistentContainer(ctx context.Context, vm *LanguageVM, req ExecutionRequest) (*ExecutionResult, error) { var execCmd []string workspacePath := fmt.Sprintf("/tmp/workspaces/%s/%s", vm.Language, req.JobID) switch vm.Language { case "python": entryPoint := req.EntryPoint if entryPoint == "" { entryPoint = "main.py" } execCmd = []string{"docker", "exec", vm.ContainerName, "bash", "-c", fmt.Sprintf("cd %s && if [ -f requirements.txt ]; then pip install -r requirements.txt; fi && timeout 30 python %s", workspacePath, entryPoint)} case "nodejs": entryPoint := req.EntryPoint if entryPoint == "" { entryPoint = "index.js" } execCmd = []string{"docker", "exec", vm.ContainerName, "bash", "-c", fmt.Sprintf("cd %s && if [ -f package.json ]; then npm install; fi && timeout 30 node %s", workspacePath, entryPoint)} case "go": execCmd = []string{"docker", "exec", vm.ContainerName, "bash", "-c", fmt.Sprintf("cd %s && go mod tidy 2>/dev/null || true && timeout 30 go run .", workspacePath)} case "rust": execCmd = []string{"docker", "exec", vm.ContainerName, "bash", "-c", fmt.Sprintf("cd %s && timeout 30 cargo run", workspacePath)} case "java": entryPoint := req.EntryPoint if entryPoint == "" { entryPoint = "Main.java" } className := strings.TrimSuffix(entryPoint, ".java") execCmd = []string{"docker", "exec", vm.ContainerName, "bash", "-c", fmt.Sprintf("cd %s && javac %s && timeout 30 java %s", workspacePath, entryPoint, className)} } // Execute with timeout execCtx, cancel := context.WithTimeout(ctx, 30*time.Second) defer cancel() cmd := exec.CommandContext(execCtx, execCmd[0], execCmd[1:]...) output, err := cmd.CombinedOutput() result := &ExecutionResult{ JobID: req.JobID, WorkspaceID: req.WorkspaceID, Output: string(output), ExitCode: 0, } if err != nil { result.Error = err.Error() result.ExitCode = 1 } return result, nil } 

# Exchange Configuration exchanges: jobs: name: "code-execution.jobs" type: "topic" durable: true auto_delete: false results: name: "code-execution.results" type: "topic" durable: true auto_delete: false dead_letter: name: "code-execution.dead-letter" type: "direct" durable: true auto_delete: false # Queue Configuration queues: job_prefix: "jobs" result_prefix: "results" dead_letter_suffix: "dlq" 

interface ExecutionJob { job_id: string; // Unique identifier workspace_id: string; // User workspace language: string; // Target language source_code: string; // Code to execute entry_point?: string; // Main file (optional) dependencies?: string[]; // Package dependencies timeout?: number; // Execution timeout memory_limit?: number; // Memory limit in MB } 

const amqp = require('amqplib'); class JobProducer { constructor(rabbitmqUrl) { this.rabbitmqUrl = rabbitmqUrl; this.connection = null; this.channel = null; } async connect() { this.connection = await amqp.connect(this.rabbitmqUrl); this.channel = await this.connection.createChannel(); // Declare exchanges await this.channel.assertExchange('code-execution.jobs', 'topic', { durable: true }); await this.channel.assertExchange('code-execution.results', 'topic', { durable: true }); } async submitJob(job) { const routingKey = `jobs.${job.language}`; const jobMessage = { job_id: job.job_id, workspace_id: job.workspace_id, language: job.language, url: this.createDataURL(job.source_code, job.entry_point), entry_point: job.entry_point }; await this.channel.publish( 'code-execution.jobs', routingKey, Buffer.from(JSON.stringify(jobMessage)), { persistent: true, messageId: job.job_id, timestamp: Date.now() } ); console.log(`Job ${job.job_id} submitted for ${job.language}`); } createDataURL(sourceCode, filename = 'main.py') { // Create inline data URL for source code return `data:text/plain;filename=${filename},${sourceCode}`; } async close() { if (this.channel) await this.channel.close(); if (this.connection) await this.connection.close(); } } 

func (m *Manager) consumeRabbitMQMessages(config RabbitMQConfig) error { conn, err := amqp.Dial(config.URL) if err != nil { return fmt.Errorf("failed to connect to RabbitMQ: %w", err) } defer conn.Close() ch, err := conn.Channel() if err != nil { return fmt.Errorf("failed to open channel: %w", err) } defer ch.Close() // Declare unified queue for all languages jobQueue, err := ch.QueueDeclare( "jobs.all-languages", // name true, // durable false, // delete when unused false, // exclusive false, // no-wait nil, // arguments ) if err != nil { return fmt.Errorf("failed to declare job queue: %w", err) } // Bind queue to exchange for each language languages := []string{"python", "nodejs", "go", "rust", "java"} for _, lang := range languages { err = ch.QueueBind( jobQueue.Name, fmt.Sprintf("jobs.%s", lang), "code-execution.jobs", false, nil, ) if err != nil { return fmt.Errorf("failed to bind queue for %s: %w", lang, err) } } // Set QoS for fair distribution err = ch.Qos(1, 0, false) if err != nil { return fmt.Errorf("failed to set QoS: %w", err) } // Start consuming msgs, err := ch.Consume( jobQueue.Name, "", // consumer tag false, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) if err != nil { return fmt.Errorf("failed to register consumer: %w", err) } for msg := range msgs { go m.processJob(msg) } return nil } func (m *Manager) processJob(msg amqp.Delivery) { var execReq ExecutionRequest if err := json.Unmarshal(msg.Body, &execReq); err != nil { m.logger.WithError(err).Error("Failed to parse job message") msg.Nack(false, false) // Don't requeue invalid messages return } // Execute the job ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) result, err := m.ExecuteCode(ctx, execReq) cancel() if err != nil { m.logger.WithError(err).Error("Job execution failed") result = &ExecutionResult{ JobID: execReq.JobID, Output: "", Error: err.Error(), ExitCode: 1, } } // Publish result resultBytes, _ := json.Marshal(result) err = msg.Channel.Publish( "code-execution.results", fmt.Sprintf("results.%s", execReq.Language), false, // mandatory false, // immediate amqp.Publishing{ ContentType: "application/json", Body: resultBytes, }) if err != nil { m.logger.WithError(err).Error("Failed to publish result") msg.Nack(false, true) // Requeue on publish failure } else { msg.Ack(false) // Acknowledge successful processing } } 

// Redis streaming setup const redis = require('redis'); class StreamingService { constructor(redisUrl) { this.publisher = redis.createClient({ url: redisUrl }); this.subscriber = redis.createClient({ url: redisUrl }); } async connect() { await this.publisher.connect(); await this.subscriber.connect(); } // Publish output line from runner service async publishOutput(jobId, line, stream = 'stdout') { const message = { job_id: jobId, line: line, stream: stream, timestamp: new Date().toISOString() }; await this.publisher.publish( `execution:${jobId}`, JSON.stringify(message) ); } // Subscribe to job output async subscribeToJob(jobId, callback) { await this.subscriber.subscribe(`execution:${jobId}`, (message) => { const data = JSON.parse(message); callback(data); }); } async unsubscribeFromJob(jobId) { await this.subscriber.unsubscribe(`execution:${jobId}`); } } 

// WebSocket server integration const WebSocket = require('ws'); class WebSocketManager { constructor(server, streamingService) { this.wss = new WebSocket.Server({ server }); this.streamingService = streamingService; this.connections = new Map(); // jobId -> Set of WebSocket connections this.setupWebSocketHandlers(); } setupWebSocketHandlers() { this.wss.on('connection', (ws) => { ws.on('message', async (data) => { const message = JSON.parse(data); switch (message.type) { case 'subscribe': await this.subscribeToJobOutput(ws, message.job_id); break; case 'unsubscribe': await this.unsubscribeFromJobOutput(ws, message.job_id); break; } }); ws.on('close', () => { this.cleanupConnection(ws); }); }); } async subscribeToJobOutput(ws, jobId) { // Add connection to job subscription if (!this.connections.has(jobId)) { this.connections.set(jobId, new Set()); // Subscribe to Redis stream for this job await this.streamingService.subscribeToJob(jobId, (data) => { // Broadcast to all subscribed WebSocket connections const connections = this.connections.get(jobId); if (connections) { connections.forEach(conn => { if (conn.readyState === WebSocket.OPEN) { conn.send(JSON.stringify({ type: 'output', data: data })); } }); } }); } this.connections.get(jobId).add(ws); } async unsubscribeFromJobOutput(ws, jobId) { const connections = this.connections.get(jobId); if (connections) { connections.delete(ws); // If no more connections, unsubscribe from Redis if (connections.size === 0) { await this.streamingService.unsubscribeFromJob(jobId); this.connections.delete(jobId); } } } cleanupConnection(ws) { // Remove connection from all job subscriptions for (const [jobId, connections] of this.connections.entries()) { connections.delete(ws); if (connections.size === 0) { this.streamingService.unsubscribeFromJob(jobId); this.connections.delete(jobId); } } } } 

func (m *Manager) executeWithStreaming(ctx context.Context, vm *LanguageVM, req ExecutionRequest) (*ExecutionResult, error) { // ... command setup ... cmd := exec.CommandContext(execCtx, execCmd[0], execCmd[1:]...) // Create pipes for real-time output capture stdout, err := cmd.StdoutPipe() if err != nil { return nil, fmt.Errorf("failed to create stdout pipe: %w", err) } stderr, err := cmd.StderrPipe() if err != nil { return nil, fmt.Errorf("failed to create stderr pipe: %w", err) } // Start the command if err := cmd.Start(); err != nil { return nil, fmt.Errorf("failed to start command: %w", err) } // Stream output in real-time var outputBuffer strings.Builder var wg sync.WaitGroup wg.Add(2) // Stream stdout go func() { defer wg.Done() scanner := bufio.NewScanner(stdout) for scanner.Scan() { line := scanner.Text() outputBuffer.WriteString(line + "\n") // Publish to Redis for real-time streaming m.publishStreamingOutput(req.JobID, line, "stdout") } }() // Stream stderr go func() { defer wg.Done() scanner := bufio.NewScanner(stderr) for scanner.Scan() { line := scanner.Text() outputBuffer.WriteString(line + "\n") // Publish to Redis for real-time streaming m.publishStreamingOutput(req.JobID, line, "stderr") } }() // Wait for command completion err = cmd.Wait() wg.Wait() // Wait for all output to be processed result := &ExecutionResult{ JobID: req.JobID, WorkspaceID: req.WorkspaceID, Output: outputBuffer.String(), ExitCode: 0, } if err != nil { result.Error = err.Error() result.ExitCode = 1 } return result, nil } func (m *Manager) publishStreamingOutput(jobID, line, stream string) { // This would integrate with your Redis client message := StreamingOutput{ JobID: jobID, Line: line, Stream: stream, Timestamp: time.Now(), } // Publish to Redis (implementation depends on your Redis client) // m.redisClient.Publish(fmt.Sprintf("execution:%s", jobID), message) } 

const express = require('express'); const WebSocket = require('ws'); const { v4: uuidv4 } = require('uuid'); const cors = require('cors'); class CodeExecutionAPI { constructor() { this.app = express(); this.server = null; this.jobProducer = null; this.streamingService = null; this.wsManager = null; this.activeJobs = new Map(); // Track running jobs this.setupMiddleware(); this.setupRoutes(); } setupMiddleware() { this.app.use(cors()); this.app.use(express.json({ limit: '10mb' })); this.app.use(express.urlencoded({ extended: true })); // Request logging this.app.use((req, res, next) => { console.log(`${req.method} ${req.path} - ${new Date().toISOString()}`); next(); }); } setupRoutes() { // Health check this.app.get('/health', (req, res) => { res.json({ status: 'ok', timestamp: new Date().toISOString() }); }); // Submit code execution job this.app.post('/api/execute', async (req, res) => { try { const result = await this.handleCodeExecution(req.body); res.json(result); } catch (error) { console.error('Execution error:', error); res.status(500).json({ error: 'Execution failed', message: error.message }); } }); // Get job status this.app.get('/api/jobs/:jobId', (req, res) => { const jobId = req.params.jobId; const job = this.activeJobs.get(jobId); if (!job) { return res.status(404).json({ error: 'Job not found' }); } res.json(job); }); // List active jobs this.app.get('/api/jobs', (req, res) => { const jobs = Array.from(this.activeJobs.values()); res.json({ jobs, count: jobs.length }); }); // Cancel job this.app.delete('/api/jobs/:jobId', async (req, res) => { const jobId = req.params.jobId; await this.cancelJob(jobId); res.json({ message: 'Job cancelled' }); }); } async handleCodeExecution(requestBody) { const { language, source_code, entry_point, workspace_id = 'default', timeout = 30 } = requestBody; // Validate request if (!language || !source_code) { throw new Error('Language and source_code are required'); } const supportedLanguages = ['python', 'nodejs', 'go', 'rust', 'java']; if (!supportedLanguages.includes(language)) { throw new Error(`Unsupported language: ${language}`); } // Generate unique job ID const jobId = uuidv4(); // Create job record const job = { job_id: jobId, workspace_id, language, source_code, entry_point, timeout, status: 'queued', created_at: new Date().toISOString(), updated_at: new Date().toISOString() }; this.activeJobs.set(jobId, job); // Submit to RabbitMQ await this.jobProducer.submitJob(job); // Update status job.status = 'submitted'; job.updated_at = new Date().toISOString(); return { job_id: jobId, status: 'submitted', message: 'Job submitted for execution', stream_url: `/stream/${jobId}` }; } async cancelJob(jobId) { const job = this.activeJobs.get(jobId); if (job && job.status === 'running') { // Send cancellation signal (implementation depends on your setup) job.status = 'cancelled'; job.updated_at = new Date().toISOString(); } } async start(port = 3001) { // Initialize services await this.initializeServices(); // Start HTTP server this.server = this.app.listen(port, () => { console.log(`Code execution API running on port ${port}`); }); // Setup WebSocket manager this.wsManager = new WebSocketManager(this.server, this.streamingService); // Setup result consumer this.setupResultConsumer(); } async initializeServices() { // Initialize RabbitMQ producer this.jobProducer = new JobProducer(process.env.RABBITMQ_URL); await this.jobProducer.connect(); // Initialize Redis streaming this.streamingService = new StreamingService(process.env.REDIS_URL); await this.streamingService.connect(); console.log('All services initialized successfully'); } setupResultConsumer() { // Consumer for job results from RabbitMQ const amqp = require('amqplib'); amqp.connect(process.env.RABBITMQ_URL) .then(conn => conn.createChannel()) .then(ch => { // Declare results queue return ch.assertQueue('results.all', { durable: true }) .then(() => { // Bind to results exchange return ch.bindQueue('results.all', 'code-execution.results', 'results.*'); }) .then(() => { // Consume results return ch.consume('results.all', (msg) => { if (msg) { this.handleJobResult(JSON.parse(msg.content.toString())); ch.ack(msg); } }); }); }) .catch(console.error); } handleJobResult(result) { const job = this.activeJobs.get(result.job_id); if (job) { job.status = result.exit_code === 0 ? 'completed' : 'failed'; job.result = result; job.updated_at = new Date().toISOString(); // Optionally clean up completed jobs after some time setTimeout(() => { this.activeJobs.delete(result.job_id); }, 300000); // 5 minutes } } async stop() { if (this.server) { this.server.close(); } if (this.jobProducer) { await this.jobProducer.close(); } if (this.streamingService) { await this.streamingService.close(); } } } // Environment configuration const config = { port: process.env.PORT || 3001, rabbitmq_url: process.env.RABBITMQ_URL || 'amqp://admin:admin123@localhost:5672', redis_url: process.env.REDIS_URL || 'redis://localhost:6379' }; // Start the server const api = new CodeExecutionAPI(); api.start(config.port); // Graceful shutdown process.on('SIGINT', async () => { console.log('Shutting down gracefully...'); await api.stop(); process.exit(0); }); 

const rateLimit = require('express-rate-limit'); const validator = require('validator'); // Rate limiting for code execution const executionLimiter = rateLimit({ windowMs: 60 * 1000, // 1 minute max: 10, // Maximum 10 executions per minute per IP message: 'Too many execution requests, please try again later', standardHeaders: true, legacyHeaders: false }); // Code validation middleware const validateCodeRequest = (req, res, next) => { const { language, source_code, entry_point } = req.body; // Check required fields if (!language || !source_code) { return res.status(400).json({ error: 'Missing required fields', required: ['language', 'source_code'] }); } // Validate language const supportedLanguages = ['python', 'nodejs', 'go', 'rust', 'java']; if (!supportedLanguages.includes(language)) { return res.status(400).json({ error: 'Unsupported language', supported: supportedLanguages }); } // Check code length (prevent abuse) if (source_code.length > 100000) { // 100KB limit return res.status(400).json({ error: 'Source code too large', max_size: '100KB' }); } // Validate entry point if provided if (entry_point && !validator.isAlphanumeric(entry_point.replace(/[._-]/g, ''))) { return res.status(400).json({ error: 'Invalid entry point format' }); } // Basic security checks (can be expanded) const dangerousPatterns = [ /rm\s+-rf/, /sudo/, /passwd/, /\/etc\/passwd/, /mkfs/, /format/, /del\s+\/[a-z]/i ]; for (const pattern of dangerousPatterns) { if (pattern.test(source_code)) { return res.status(400).json({ error: 'Code contains potentially dangerous operations' }); } } next(); }; // Apply middleware to execution endpoint app.post('/api/execute', executionLimiter, validateCodeRequest, async (req, res) => { // ... execution logic } ); 

import React, { useState, useEffect, useCallback, useRef } from 'react'; import { Button } from '@/components/ui/button'; import { Card, CardContent } from '@/components/ui/card'; import { Badge } from '@/components/ui/badge'; import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs'; import { Play, Square, Copy, Download, Settings } from 'lucide-react'; import CodeMirror from '@uiw/react-codemirror'; import { githubDark } from '@uiw/codemirror-theme-github'; import { javascript } from '@codemirror/lang-javascript'; import { python } from '@codemirror/lang-python'; import { rust } from '@codemirror/lang-rust'; import { go } from '@codemirror/lang-go'; import { java } from '@codemirror/lang-java'; interface ExecutionResult { job_id: string; status: string; output?: string; error?: string; exit_code?: number; duration?: number; } interface OutputLine { line: string; stream: 'stdout' | 'stderr'; timestamp: string; } const LANGUAGES = { python: { ext: python(), icon: '🐍', name: 'Python', starter: 'print("Hello, World!")' }, javascript: { ext: javascript(), icon: '⚡', name: 'JavaScript', starter: 'console.log("Hello, World!");' }, go: { ext: go(), icon: '🔵', name: 'Go', starter: 'package main\n\nimport "fmt"\n\nfunc main() {\n fmt.Println("Hello, World!")\n}' }, rust: { ext: rust(), icon: '🦀', name: 'Rust', starter: 'fn main() {\n println!("Hello, World!");\n}' }, java: { ext: java(), icon: '☕', name: 'Java', starter: 'public class Main {\n public static void main(String[] args) {\n System.out.println("Hello, World!");\n }\n}' } }; export function CodeExecutor() { const [selectedLanguage, setSelectedLanguage] = useState('python'); const [code, setCode] = useState(LANGUAGES.python.starter); const [isExecuting, setIsExecuting] = useState(false); const [output, setOutput] = useState<OutputLine[]>([]); const [executionResult, setExecutionResult] = useState<ExecutionResult | null>(null); const [currentJobId, setCurrentJobId] = useState<string | null>(null); const wsRef = useRef<WebSocket | null>(null); const outputRef = useRef<HTMLDivElement>(null); // WebSocket connection for real-time output const connectWebSocket = useCallback((jobId: string) => { const wsUrl = `ws://localhost:3001/stream/${jobId}`; wsRef.current = new WebSocket(wsUrl); wsRef.current.onopen = () => { console.log('WebSocket connected for job:', jobId); wsRef.current?.send(JSON.stringify({ type: 'subscribe', job_id: jobId })); }; wsRef.current.onmessage = (event) => { const message = JSON.parse(event.data); if (message.type === 'output') { const outputLine: OutputLine = { line: message.data.line, stream: message.data.stream, timestamp: message.data.timestamp }; setOutput(prev => [...prev, outputLine]); // Auto-scroll to bottom setTimeout(() => { if (outputRef.current) { outputRef.current.scrollTop = outputRef.current.scrollHeight; } }, 10); } }; wsRef.current.onclose = () => { console.log('WebSocket disconnected'); }; wsRef.current.onerror = (error) => { console.error('WebSocket error:', error); }; }, []); // Execute code const executeCode = useCallback(async () => { if (isExecuting) return; setIsExecuting(true); setOutput([]); setExecutionResult(null); try { const response = await fetch('http://localhost:3001/api/execute', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ language: selectedLanguage, source_code: code, workspace_id: 'web-editor' }) }); if (!response.ok) { throw new Error(`HTTP ${response.status}: ${response.statusText}`); } const result = await response.json(); setCurrentJobId(result.job_id); // Connect WebSocket for streaming output connectWebSocket(result.job_id); // Poll for final result pollJobResult(result.job_id); } catch (error) { console.error('Execution failed:', error); setOutput([{ line: `Error: ${error.message}`, stream: 'stderr', timestamp: new Date().toISOString() }]); setIsExecuting(false); } }, [code, selectedLanguage, isExecuting, connectWebSocket]); // Poll for job completion const pollJobResult = useCallback(async (jobId: string) => { const pollInterval = 1000; // 1 second const maxPolls = 60; // 60 seconds timeout let polls = 0; const poll = async () => { try { const response = await fetch(`http://localhost:3001/api/jobs/${jobId}`); const job = await response.json(); if (job.status === 'completed' || job.status === 'failed') { setExecutionResult(job.result); setIsExecuting(false); // Close WebSocket if (wsRef.current) { wsRef.current.close(); } return; } polls++; if (polls < maxPolls) { setTimeout(poll, pollInterval); } else { // Timeout setIsExecuting(false); setOutput(prev => [...prev, { line: 'Execution timeout - job may still be running', stream: 'stderr', timestamp: new Date().toISOString() }]); } } catch (error) { console.error('Polling error:', error); setIsExecuting(false); } }; setTimeout(poll, pollInterval); }, []); // Stop execution const stopExecution = useCallback(async () => { if (currentJobId) { try { await fetch(`http://localhost:3001/api/jobs/${currentJobId}`, { method: 'DELETE' }); } catch (error) { console.error('Failed to cancel job:', error); } } if (wsRef.current) { wsRef.current.close(); } setIsExecuting(false); setCurrentJobId(null); }, [currentJobId]); // Copy code to clipboard const copyCode = useCallback(() => { navigator.clipboard.writeText(code); }, [code]); // Download output const downloadOutput = useCallback(() => { const outputText = output.map(line => `[${line.timestamp}] ${line.stream}: ${line.line}` ).join('\n'); const blob = new Blob([outputText], { type: 'text/plain' }); const url = URL.createObjectURL(blob); const a = document.createElement('a'); a.href = url; a.download = `execution-output-${Date.now()}.txt`; a.click(); URL.revokeObjectURL(url); }, [output]); // Language change handler useEffect(() => { setCode(LANGUAGES[selectedLanguage as keyof typeof LANGUAGES].starter); }, [selectedLanguage]); // Cleanup WebSocket on unmount useEffect(() => { return () => { if (wsRef.current) { wsRef.current.close(); } }; }, []); return ( <div className="max-w-6xl mx-auto p-4 space-y-4"> {/* Header */} <div className="flex items-center justify-between"> <h1 className="text-2xl font-bold">Online Code Compiler</h1>  <Badge variant="outline" className="text-sm"> Real-time execution with Docker containers </Badge>  </div>  {/* Language Selection */} <Card> <CardContent className="p-4"> <Tabs value={selectedLanguage} onValueChange={setSelectedLanguage}> <TabsList className="grid w-full grid-cols-5"> {Object.entries(LANGUAGES).map(([lang, config]) => ( <TabsTrigger key={lang} value={lang} className="flex items-center gap-2"> <span>{config.icon}</span>  <span className="hidden sm:inline">{config.name}</span>  </TabsTrigger>  ))} </TabsList>  </Tabs>  </CardContent>  </Card>  {/* Code Editor */} <Card> <CardContent className="p-0"> <div className="border-b p-4 flex items-center justify-between"> <h3 className="font-semibold">Code Editor</h3>  <div className="flex items-center gap-2"> <Button variant="outline" size="sm" onClick={copyCode} > <Copy className="h-4 w-4 mr-2" /> Copy </Button>  <Button onClick={isExecuting ? stopExecution : executeCode} disabled={!code.trim()} variant={isExecuting ? "destructive" : "default"} > {isExecuting ? ( <> <Square className="h-4 w-4 mr-2" /> Stop </>  ) : ( <> <Play className="h-4 w-4 mr-2" /> Run {LANGUAGES[selectedLanguage as keyof typeof LANGUAGES].name} </>  )} </Button>  </div>  </div>  <CodeMirror value={code} onChange={(value) => setCode(value)} theme={githubDark} extensions={[LANGUAGES[selectedLanguage as keyof typeof LANGUAGES].ext]} className="text-sm" basicSetup={{ lineNumbers: true, foldGutter: true, dropCursor: false, allowMultipleSelections: false }} />  </CardContent>  </Card>  {/* Output Panel */} <Card> <CardContent className="p-0"> <div className="border-b p-4 flex items-center justify-between"> <div className="flex items-center gap-2"> <h3 className="font-semibold">Output</h3>  {isExecuting && ( <Badge variant="secondary" className="animate-pulse"> Executing... </Badge>  )} {executionResult && ( <Badge variant={executionResult.exit_code === 0 ? "default" : "destructive"} > Exit code: {executionResult.exit_code} </Badge>  )} </div>  <div className="flex items-center gap-2"> {output.length > 0 && ( <Button variant="outline" size="sm" onClick={downloadOutput} > <Download className="h-4 w-4 mr-2" /> Download </Button>  )} <Button variant="outline" size="sm" onClick={() => setOutput([])} > Clear </Button>  </div>  </div>  <div ref={outputRef} className="h-96 overflow-y-auto p-4 bg-gray-950 text-gray-100 font-mono text-sm" > {output.length === 0 ? ( <div className="text-gray-500 italic"> Click "Run" to execute your code. Output will appear here in real-time. </div>  ) : ( output.map((line, index) => ( <div key={index} className={`whitespace-pre-wrap ${ line.stream === 'stderr' ? 'text-red-400' : 'text-gray-100' }`} > {line.line} </div>  )) )} </div>  </CardContent>  </Card>  {/* Execution Statistics */} {executionResult && ( <Card> <CardContent className="p-4"> <h3 className="font-semibold mb-2">Execution Statistics</h3>  <div className="grid grid-cols-2 md:grid-cols-4 gap-4 text-sm"> <div> <span className="text-gray-500">Duration:</span>  <div className="font-mono">{executionResult.duration || 0}ms</div>  </div>  <div> <span className="text-gray-500">Exit Code:</span>  <div className="font-mono">{executionResult.exit_code}</div>  </div>  <div> <span className="text-gray-500">Language:</span>  <div className="font-mono">{selectedLanguage}</div>  </div>  <div> <span className="text-gray-500">Job ID:</span>  <div className="font-mono text-xs">{executionResult.job_id}</div>  </div>  </div>  </CardContent>  </Card>  )} </div>  ); } 

# Docker container security configuration version: '3.8' services: runner-python: image: python:3.11-slim security_opt: - no-new-privileges:true - seccomp:unconfined # May need custom seccomp profile cap_drop: - ALL cap_add: - SETGID - SETUID read_only: true tmpfs: - /tmp:exec,size=100m - /var/tmp:exec,size=100m ulimits: nproc: 64 # Limit number of processes nofile: 1024 # Limit open files memlock: 67108864 # Limit locked memory memory: 256m # Memory limit cpus: '0.5' # CPU limit pids_limit: 100 # Process limit networks: - isolated_network networks: isolated_network: driver: bridge internal: true # No external network access 

func (m *Manager) createSecureContainer(language, jobID string) error { containerConfig := &container.Config{ Image: m.config.Environments[language], Cmd: []string{"tail", "-f", "/dev/null"}, Env: []string{ "HOME=/tmp", "USER=runner", "SHELL=/bin/bash", }, WorkingDir: "/tmp/workspace", User: "1000:1000", // Non-root user // Resource limits Memory: 256 * 1024 * 1024, // 256MB MemorySwap: 256 * 1024 * 1024, // No swap CpuShares: 512, // Half CPU priority // Security options SecurityOpts: []string{ "no-new-privileges:true", "seccomp=unconfined", // or custom profile }, // Network isolation NetworkDisabled: true, } hostConfig := &container.HostConfig{ // Resource constraints Resources: container.Resources{ Memory: 256 * 1024 * 1024, MemorySwap: 256 * 1024 * 1024, CPUShares: 512, PidsLimit: 50, Ulimits: []*units.Ulimit{ {Name: "nproc", Soft: 32, Hard: 32}, {Name: "nofile", Soft: 256, Hard: 256}, }, }, // Security ReadonlyRootfs: true, CapDrop: []string{"ALL"}, CapAdd: []string{"SETGID", "SETUID"}, // Temporary filesystems Tmpfs: map[string]string{ "/tmp": "exec,size=100m", "/var/tmp": "exec,size=100m", }, // No privileged access Privileged: false, // Network isolation NetworkMode: "none", } // Create container resp, err := m.dockerClient.ContainerCreate( context.Background(), containerConfig, hostConfig, nil, // networking config nil, // platform fmt.Sprintf("runner-%s-%s", language, jobID), ) if err != nil { return fmt.Errorf("failed to create container: %w", err) } // Start container if err := m.dockerClient.ContainerStart( context.Background(), resp.ID, types.ContainerStartOptions{}, ); err != nil { return fmt.Errorf("failed to start container: %w", err) } return nil } 

class CodeSanitizer { constructor() { this.dangerousPatterns = { filesystem: [ /\bopen\s*\(\s*['"][\/\\]/, // File system access /\bfile\s*\(\s*['"][\/\\]/, // File operations /\bos\.system/, // OS commands /\bsubprocess/, // Process execution /\beval\s*\(/, // Code evaluation /\bexec\s*\(/, // Code execution ], network: [ /\bsocket\s*\(/, // Network sockets /\burllib/, // URL operations /\brequests\./, // HTTP requests /\bhttplib/, // HTTP library /\bfetch\s*\(/, // Fetch API ], system: [ /\bos\.getenv/, // Environment variables /\bprocess\.env/, // Node.js environment /\b__import__/, // Dynamic imports /\brequire\s*\(\s*['"]child_process['"]/, // Child process ] }; } analyze(code, language) { const issues = []; for (const [category, patterns] of Object.entries(this.dangerousPatterns)) { for (const pattern of patterns) { const matches = code.match(pattern); if (matches) { issues.push({ category, pattern: pattern.toString(), match: matches[0], severity: this.getSeverity(category) }); } } } return { safe: issues.length === 0, issues, score: this.calculateSafetyScore(issues) }; } getSeverity(category) { const severityMap = { filesystem: 'high', network: 'medium', system: 'high' }; return severityMap[category] || 'low'; } calculateSafetyScore(issues) { const weights = { high: 10, medium: 5, low: 1 }; const totalWeight = issues.reduce((sum, issue) => sum + weights[issue.severity], 0); return Math.max(0, 100 - totalWeight); } } // Usage in API app.post('/api/execute', validateCodeRequest, async (req, res) => { const sanitizer = new CodeSanitizer(); const analysis = sanitizer.analyze(req.body.source_code, req.body.language); if (!analysis.safe && analysis.score < 50) { return res.status(400).json({ error: 'Code contains potentially dangerous operations', issues: analysis.issues, safety_score: analysis.score }); } // Proceed with execution... }); 

# Docker network setup with restrictions docker network create --driver bridge \ --subnet=172.20.0.0/16 \ --opt com.docker.network.bridge.enable_icc=false \ --opt com.docker.network.bridge.enable_ip_masquerade=false \ isolated-execution # Firewall rules for container network iptables -I DOCKER-USER -s 172.20.0.0/16 -j DROP iptables -I DOCKER-USER -s 172.20.0.0/16 -d 172.20.0.0/16 -j ACCEPT 

type ContainerPool struct { pools map[string]*LanguagePool mutex sync.RWMutex logger *logrus.Logger } type LanguagePool struct { language string containers []*ContainerInstance available chan *ContainerInstance maxSize int currentSize int mutex sync.Mutex } type ContainerInstance struct { ID string Language string CreatedAt time.Time LastUsed time.Time InUse bool } func NewContainerPool(maxSize int, logger *logrus.Logger) *ContainerPool { return &ContainerPool{ pools: make(map[string]*LanguagePool), logger: logger, } } func (cp *ContainerPool) GetContainer(language string) (*ContainerInstance, error) { cp.mutex.RLock() pool, exists := cp.pools[language] cp.mutex.RUnlock() if !exists { cp.mutex.Lock() pool = &LanguagePool{ language: language, available: make(chan *ContainerInstance, 10), maxSize: 10, } cp.pools[language] = pool cp.mutex.Unlock() } // Try to get from available pool select { case container := <-pool.available: container.InUse = true container.LastUsed = time.Now() return container, nil default: // Create new container if under limit return cp.createNewContainer(pool) } } func (cp *ContainerPool) ReturnContainer(container *ContainerInstance) { cp.mutex.RLock() pool := cp.pools[container.Language] cp.mutex.RUnlock() container.InUse = false container.LastUsed = time.Now() // Clean container workspace cp.cleanContainerWorkspace(container) // Return to pool select { case pool.available <- container: // Successfully returned to pool default: // Pool is full, destroy container cp.destroyContainer(container) } } func (cp *ContainerPool) cleanContainerWorkspace(container *ContainerInstance) { // Execute cleanup commands in container cleanupCmd := []string{ "docker", "exec", container.ID, "bash", "-c", "rm -rf /tmp/workspace/* 2>/dev/null || true" } exec.Command(cleanupCmd[0], cleanupCmd[1:]...).Run() } 

type MemoryManager struct { totalMemory uint64 usedMemory uint64 containerMem map[string]uint64 mutex sync.RWMutex logger *logrus.Logger } func (mm *MemoryManager) AllocateMemory(containerID string, requested uint64) error { mm.mutex.Lock() defer mm.mutex.Unlock() // Check if allocation would exceed limits if mm.usedMemory + requested > mm.totalMemory * 80 / 100 { // 80% threshold return fmt.Errorf("insufficient memory: %d MB requested, %d MB available", requested/1024/1024, (mm.totalMemory-mm.usedMemory)/1024/1024) } mm.usedMemory += requested mm.containerMem[containerID] = requested mm.logger.Infof("Allocated %d MB to container %s", requested/1024/1024, containerID) return nil } func (mm *MemoryManager) ReleaseMemory(containerID string) { mm.mutex.Lock() defer mm.mutex.Unlock() if allocated, exists := mm.containerMem[containerID]; exists { mm.usedMemory -= allocated delete(mm.containerMem, containerID) mm.logger.Infof("Released %d MB from container %s", allocated/1024/1024, containerID) } } func (mm *MemoryManager) GetMemoryStats() map[string]interface{} { mm.mutex.RLock() defer mm.mutex.RUnlock() return map[string]interface{}{ "total_mb": mm.totalMemory / 1024 / 1024, "used_mb": mm.usedMemory / 1024 / 1024, "available_mb": (mm.totalMemory - mm.usedMemory) / 1024 / 1024, "utilization": float64(mm.usedMemory) / float64(mm.totalMemory) * 100, "active_containers": len(mm.containerMem), } }