Arnab-Afk/monaco
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

working socket integration

Browse Source
This commit is contained in:
Arnab-Afk
2025-04-21 21:03:59 +05:30
parent c143efa70e
commit 4453e69e68
22 changed files with 2070 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
Frontend/src/components/EditorArea.jsx
View File

@@ -8,6 +8,7 @@ import {
} from "lucide-react";
import Sidebar from "./Sidebar";
import Panel from "./Panel"; // Import Panel component
import WebSocketTerminal from "./WebSocketTerminal"; // Import WebSocket Terminal
const EditorArea = ({
sidebarVisible = true,
@@ -64,6 +65,10 @@ const EditorArea = ({
const [userInput, setUserInput] = useState("");
// Add a new state for waiting for input
const [waitingForInput, setWaitingForInput] = useState(false);
// Add a new state for tracking the active submission ID
const [activeRunningSubmissionId, setActiveRunningSubmissionId] = useState(null);
// Add a state to toggle between regular and WebSocket terminals
const [useWebSocket, setUseWebSocket] = useState(false);
// Focus the input when new file modal opens
useEffect(() => {
@@ -507,7 +512,7 @@ Happy coding!`;
width: `calc(100% - ${sidebarVisible ? sidebarWidth : 0}px)`
};
// Modify the handleRunCode function to prompt for input first
// Modified handleRunCode to start execution immediately
const handleRunCode = async () => {
if (!activeFile) return;
@@ -517,58 +522,47 @@ Happy coding!`;
setPanelVisible(true);
}
// Set state to waiting for input
setWaitingForInput(true);
// Reset states
setIsRunning(true);
setWaitingForInput(false);
setActiveRunningFile(activeFile.id);
setActiveRunningSubmissionId(null);
setUserInput('');
// Clear previous output and add new command
// Get language from file extension
const fileExtension = activeFile.id.split('.').pop().toLowerCase();
const language = getLanguageFromExtension(fileExtension);
// If using WebSocket mode, we'll use the WebSocketTerminal component
if (useWebSocket) {
// Just set the running state, the WebSocketTerminal will handle the rest
return;
}
// Regular HTTP mode - use polling
// Clear previous output and add new command
const newOutput = [
{ type: 'command', content: `$ run ${activeFile.id}` },
{ type: 'output', content: '------- PROGRAM EXECUTION -------' },
{ type: 'output', content: `Language: ${language}` },
{ type: 'output', content: 'Waiting for input (press Enter if no input is needed)...' }
{ type: 'output', content: 'Executing code...' }
];
setTerminalOutput(newOutput);
};
// Add a new function to handle input submission
const handleInputSubmit = async () => {
if (!activeFile || !waitingForInput) return;
// Set running state
setIsRunning(true);
setWaitingForInput(false);
// Add message that we're running with the input
if (userInput) {
setTerminalOutput(prev => [
...prev,
{ type: 'input', content: userInput }
]);
} else {
setTerminalOutput(prev => [
...prev,
{ type: 'output', content: 'Running without input...' }
]);
}
// Use API URL from environment variable
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8080';
try {
// Now make the API call with the input that was entered
// Submit the code for execution immediately
const submitResponse = await fetch(`${apiUrl}/submit`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
language: getLanguageFromExtension(activeFile.id.split('.').pop().toLowerCase()),
language: getLanguageFromExtension(fileExtension),
code: activeFile.content,
input: userInput
input: '' // No initial input
}),
});
@@ -577,11 +571,81 @@ Happy coding!`;
}
const { id } = await submitResponse.json();
setActiveRunningSubmissionId(id);
setTerminalOutput(prev => [...prev, { type: 'output', content: `Job submitted with ID: ${id}` }]);
// Step 2: Poll for status until completed or failed
// Start polling for status and output
pollForStatusAndOutput(id);
} catch (error) {
setTerminalOutput(prev => [...prev, { type: 'warning', content: `Error: ${error.message}` }]);
setIsRunning(false);
setActiveRunningSubmissionId(null);
}
};
// Toggle between WebSocket and HTTP modes
const toggleWebSocketMode = () => {
setUseWebSocket(!useWebSocket);
};
// Simplified handleInputSubmit to only handle interactive input
const handleInputSubmit = async () => {
if (!waitingForInput || !activeRunningSubmissionId) return;
// Store the input value before clearing it
const inputValue = userInput;
// Clear the input field and reset waiting state immediately for better UX
setUserInput('');
setWaitingForInput(false);
// Add the input to the terminal immediately
setTerminalOutput(prev => [
...prev,
{ type: 'input', content: inputValue }
]);
// Use API URL from environment variable
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8080';
try {
// Submit input to the running program
const submitInputResponse = await fetch(`${apiUrl}/submit-input`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
id: activeRunningSubmissionId,
input: inputValue
}),
});
if (!submitInputResponse.ok) {
throw new Error(`Server error: ${submitInputResponse.status}`);
}
// Wait for a moment to allow the program to process the input
await new Promise(resolve => setTimeout(resolve, 500));
// Poll for status and check if we need more input
pollForStatusAndOutput(activeRunningSubmissionId);
} catch (error) {
setTerminalOutput(prev => [...prev, { type: 'warning', content: `Error: ${error.message}` }]);
setIsRunning(false);
setActiveRunningSubmissionId(null);
}
};
// Add a function to poll for status and output
const pollForStatusAndOutput = async (id) => {
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8080';
try {
// Step 2: Poll for status until completed, failed, or waiting_for_input
let status = 'pending';
while (status !== 'completed' && status !== 'failed') {
while (status !== 'completed' && status !== 'failed' && status !== 'waiting_for_input') {
// Add a small delay between polls
await new Promise(resolve => setTimeout(resolve, 1000));
@@ -609,6 +673,90 @@ Happy coding!`;
});
}
// Check if we're waiting for input
if (status === 'waiting_for_input') {
// Get the current output to display to the user
const resultResponse = await fetch(`${apiUrl}/result?id=${id}`);
if (resultResponse.ok) {
const { output } = await resultResponse.json();
// Process the output to show what's happened so far
const outputLines = [];
let promptText = '';
// Split by lines and process each line
const lines = output.split('\n');
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
if (line.startsWith('[Input] ')) {
// This is an input line
outputLines.push({
type: 'input',
content: line.substring(8) // Remove the '[Input] ' prefix
});
} else if (line === '[WAITING_FOR_INPUT]') {
// This is a marker for waiting for input
// If there's a line before this, it's likely the prompt
if (i > 0 && lines[i-1].trim() !== '') {
promptText = lines[i-1];
}
continue;
} else if (line.trim() !== '') {
// This is a regular output line
outputLines.push({
type: 'output',
content: line
});
}
}
// Update the terminal with the current output
if (outputLines.length > 0) {
setTerminalOutput(prev => {
// Keep only the essential lines to avoid duplication
const essentialLines = prev.filter(line =>
line.type === 'command' ||
line.content.includes('PROGRAM EXECUTION') ||
line.content.includes('Language:') ||
line.content.includes('Job submitted') ||
line.content.includes('Status:') ||
line.content === 'Executing code...'
);
return [...essentialLines, ...outputLines];
});
}
// Now set the waiting for input state
setWaitingForInput(true);
// Add a message indicating we're waiting for input
setTerminalOutput(prev => {
// Remove any existing waiting message
const filteredPrev = prev.filter(line =>
line.content !== 'Waiting for input...'
);
// Add the prompt text if available
if (promptText) {
return [...filteredPrev, {
type: 'prompt',
content: promptText
}, {
type: 'output',
content: 'Waiting for input...'
}];
} else {
return [...filteredPrev, {
type: 'output',
content: 'Waiting for input...'
}];
}
});
}
return;
}
// Get the result for both completed and failed status
const resultResponse = await fetch(`${apiUrl}/result?id=${id}`);
if (!resultResponse.ok) {
@@ -653,11 +801,16 @@ Happy coding!`;
console.error('Code execution failed:', output);
}
// Reset state
setIsRunning(false);
setWaitingForInput(false);
setActiveRunningSubmissionId(null);
} catch (error) {
setTerminalOutput(prev => [...prev, { type: 'warning', content: `Error: ${error.message}` }]);
} finally {
// Set running state to false
setIsRunning(false);
setWaitingForInput(false);
setActiveRunningSubmissionId(null);
}
};
@@ -791,15 +944,38 @@ Happy coding!`;
title="Run code"
>
{isRunning ? <Loader size={16} className="animate-spin" /> : <Play size={16} />}
</button>
<button
className="terminal-toggle-button"
onClick={togglePanel} // Use the new function
onClick={togglePanel}
title="Toggle terminal"
>
<Terminal size={16} />
</button>
<button
className={`websocket-toggle-button ${useWebSocket ? 'active' : ''}`}
onClick={toggleWebSocketMode}
title={`${useWebSocket ? 'Disable' : 'Enable'} WebSocket mode`}
>
<svg
xmlns="http://www.w3.org/2000/svg"
width="16"
height="16"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
>
<path d="M5 12s2-3 5-3 5 3 5 3-2 3-5 3-5-3-5-3z"></path>
<circle cx="12" cy="12" r="1"></circle>
<path d="M2 4l3 3"></path>
<path d="M22 4l-3 3"></path>
<path d="M2 20l3-3"></path>
<path d="M22 20l-3-3"></path>
</svg>
</button>
</>
)}
</div>
@@ -858,6 +1034,15 @@ Happy coding!`;
document.addEventListener("mouseup", onMouseUp);
}}
/>
{useWebSocket && activeFile ? (
<div style={{ height: panelHeight + 'px' }}>
<WebSocketTerminal
code={activeFile.content}
language={getLanguageFromExtension(activeFile.id.split('.').pop().toLowerCase())}
onClose={togglePanel}
/>
</div>
) : (
<Panel
height={panelHeight}
terminalOutput={terminalOutput}
@@ -870,6 +1055,7 @@ Happy coding!`;
onUserInputChange={setUserInput}
onInputSubmit={handleInputSubmit}
/>
)}
</>
)}

4
Frontend/src/components/Panel.jsx
View File

@@ -28,9 +28,10 @@ const Panel = ({
// Render output from EditorArea when available
<>
{terminalOutput.map((line, index) => (
<div key={index} className={`terminal-line ${line.type === 'warning' ? 'terminal-warning' : line.type === 'input' ? 'terminal-input-line' : 'terminal-output'}`}>
<div key={index} className={`terminal-line ${line.type === 'warning' ? 'terminal-warning' : line.type === 'input' ? 'terminal-input-line' : line.type === 'prompt' ? 'terminal-prompt-line' : 'terminal-output'}`}>
{line.type === 'command' ? <span className="terminal-prompt">$</span> : ''}
{line.type === 'input' ? <span className="terminal-input-marker">[Input]</span> : ''}
{line.type === 'prompt' ? <span className="terminal-prompt-marker">&gt;</span> : ''}
{line.content}
</div>
))}
@@ -40,6 +41,7 @@ const Panel = ({
<span className="terminal-input-marker">Input Required:</span>
</div>
<div className="terminal-input-wrapper">
<div className="terminal-input-prompt">&gt;</div>
<input
type="text"
className="terminal-input"

239
Frontend/src/components/WebSocketTerminal.jsx Normal file
View File

@@ -0,0 +1,239 @@
import React, { useState, useEffect, useRef } from 'react';
const WebSocketTerminal = ({ code, language, onClose }) => {
const [connected, setConnected] = useState(false);
const [output, setOutput] = useState([]);
const [input, setInput] = useState('');
const [submissionId, setSubmissionId] = useState(null);
const wsRef = useRef(null);
const outputRef = useRef(null);
// Auto-scroll to bottom of output
useEffect(() => {
if (outputRef.current) {
outputRef.current.scrollTop = outputRef.current.scrollHeight;
}
}, [output]);
// Connect to WebSocket on component mount
useEffect(() => {
// Use API URL from environment variable
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8080';
const wsUrl = apiUrl.replace('http://', 'ws://').replace('https://', 'wss://');
// Create WebSocket connection
wsRef.current = new WebSocket(`${wsUrl}/ws`);
// Connection opened
wsRef.current.addEventListener('open', () => {
setConnected(true);
setOutput(prev => [...prev, { type: 'system', content: 'Connected to server' }]);
// Send the code submission
const submission = {
language,
code
};
wsRef.current.send(JSON.stringify(submission));
});
// Listen for messages
wsRef.current.addEventListener('message', (event) => {
const message = event.data;
// Check if this is a submission ID message
if (message.startsWith('Submission ID: ')) {
const id = message.substring('Submission ID: '.length);
setSubmissionId(id);
setOutput(prev => [...prev, { type: 'system', content: `Execution started with ID: ${id}` }]);
return;
}
// Regular output
setOutput(prev => [...prev, { type: 'output', content: message }]);
});
// Connection closed
wsRef.current.addEventListener('close', () => {
setConnected(false);
setOutput(prev => [...prev, { type: 'system', content: 'Disconnected from server' }]);
});
// Connection error
wsRef.current.addEventListener('error', (error) => {
console.error('WebSocket error:', error);
setOutput(prev => [...prev, { type: 'error', content: 'Connection error' }]);
});
// Clean up on unmount
return () => {
if (wsRef.current) {
wsRef.current.close();
}
};
}, [code, language]);
// Handle input submission
const handleInputSubmit = (e) => {
e.preventDefault();
if (!input.trim() || !connected) return;
// Send input to server
wsRef.current.send(input);
// Add input to output display
setOutput(prev => [...prev, { type: 'input', content: input }]);
// Clear input field
setInput('');
};
return (
<div className="websocket-terminal">
<div className="terminal-header">
<div className="terminal-title">
{connected ? 'Connected' : 'Disconnected'}
{submissionId && ` - Execution ID: ${submissionId}`}
</div>
<button className="terminal-close" onClick={onClose}>×</button>
</div>
<div className="terminal-output" ref={outputRef}>
{output.map((line, index) => (
<div key={index} className={`terminal-line ${line.type}`}>
{line.type === 'input' && <span className="input-prefix">&gt; </span>}
{line.content}
</div>
))}
</div>
<form className="terminal-input-form" onSubmit={handleInputSubmit}>
<input
type="text"
value={input}
onChange={(e) => setInput(e.target.value)}
placeholder="Enter input..."
disabled={!connected}
className="terminal-input-field"
/>
<button
type="submit"
disabled={!connected}
className="terminal-input-submit"
>
Send
</button>
</form>
<style jsx>{`
.websocket-terminal {
display: flex;
flex-direction: column;
height: 100%;
background-color: #1e1e1e;
color: #d4d4d4;
font-family: 'Consolas', monospace;
border-radius: 4px;
overflow: hidden;
}
.terminal-header {
display: flex;
justify-content: space-between;
align-items: center;
padding: 8px 12px;
background-color: #252526;
border-bottom: 1px solid #333;
}
.terminal-title {
font-size: 14px;
}
.terminal-close {
background: none;
border: none;
color: #d4d4d4;
font-size: 18px;
cursor: pointer;
}
.terminal-output {
flex: 1;
padding: 12px;
overflow-y: auto;
font-size: 14px;
line-height: 1.5;
}
.terminal-line {
margin-bottom: 4px;
white-space: pre-wrap;
word-break: break-word;
}
.terminal-line.system {
color: #569cd6;
}
.terminal-line.error {
color: #f44747;
}
.terminal-line.input {
color: #ce9178;
}
.input-prefix {
color: #569cd6;
font-weight: bold;
}
.terminal-input-form {
display: flex;
padding: 8px;
background-color: #252526;
border-top: 1px solid #333;
}
.terminal-input-field {
flex: 1;
background-color: #1e1e1e;
color: #d4d4d4;
border: 1px solid #3c3c3c;
border-radius: 4px;
padding: 8px 12px;
font-family: 'Consolas', monospace;
font-size: 14px;
}
.terminal-input-field:focus {
outline: none;
border-color: #007acc;
}
.terminal-input-submit {
margin-left: 8px;
background-color: #0e639c;
color: white;
border: none;
border-radius: 4px;
padding: 8px 16px;
cursor: pointer;
font-size: 14px;
}
.terminal-input-submit:hover {
background-color: #1177bb;
}
.terminal-input-submit:disabled {
background-color: #3c3c3c;
cursor: not-allowed;
}
`}</style>
</div>
);
};
export default WebSocketTerminal;

136
Frontend/src/index.css
View File

@@ -441,6 +441,17 @@ body {
font-weight: bold;
}
.terminal-prompt-marker {
color: #569cd6;
margin-right: 8px;
font-weight: bold;
}
.terminal-prompt-line {
color: #569cd6;
font-weight: bold;
}
.terminal-input-line {
color: #4ec9b0;
background-color: rgba(78, 201, 176, 0.1);
@@ -875,7 +886,7 @@ body {
margin-right: 4px;
}
.terminal-toggle-button {
.terminal-toggle-button, .websocket-toggle-button {
background-color: transparent;
border: none;
color: #cccccc;
@@ -886,7 +897,12 @@ body {
align-items: center;
}
.terminal-toggle-button:hover {
.terminal-toggle-button:hover, .websocket-toggle-button:hover {
opacity: 1;
}
.websocket-toggle-button.active {
color: #4ec9b0;
opacity: 1;
}
@@ -969,6 +985,15 @@ body {
.terminal-input-wrapper {
margin-bottom: 8px;
display: flex;
align-items: center;
}
.terminal-input-prompt {
color: #4ec9b0;
font-weight: bold;
margin-right: 8px;
font-size: 18px;
}
.terminal-input-help {
@@ -977,6 +1002,113 @@ body {
font-style: italic;
}
/* WebSocket Terminal */
.websocket-terminal {
display: flex;
flex-direction: column;
height: 100%;
background-color: #1e1e1e;
color: #d4d4d4;
font-family: 'Consolas', monospace;
border-radius: 4px;
overflow: hidden;
}
.terminal-header {
display: flex;
justify-content: space-between;
align-items: center;
padding: 8px 12px;
background-color: #252526;
border-bottom: 1px solid #333;
}
.terminal-title {
font-size: 14px;
}
.terminal-close {
background: none;
border: none;
color: #d4d4d4;
font-size: 18px;
cursor: pointer;
}
.terminal-output {
flex: 1;
padding: 12px;
overflow-y: auto;
font-size: 14px;
line-height: 1.5;
}
.terminal-line {
margin-bottom: 4px;
white-space: pre-wrap;
word-break: break-word;
}
.terminal-line.system {
color: #569cd6;
}
.terminal-line.error {
color: #f44747;
}
.terminal-line.input {
color: #ce9178;
}
.input-prefix {
color: #569cd6;
font-weight: bold;
}
.terminal-input-form {
display: flex;
padding: 8px;
background-color: #252526;
border-top: 1px solid #333;
}
.terminal-input-field {
flex: 1;
background-color: #1e1e1e;
color: #d4d4d4;
border: 1px solid #3c3c3c;
border-radius: 4px;
padding: 8px 12px;
font-family: 'Consolas', monospace;
font-size: 14px;
}
.terminal-input-field:focus {
outline: none;
border-color: #007acc;
}
.terminal-input-submit {
margin-left: 8px;
background-color: #0e639c;
color: white;
border: none;
border-radius: 4px;
padding: 8px 16px;
cursor: pointer;
font-size: 14px;
}
.terminal-input-submit:hover {
background-color: #1177bb;
}
.terminal-input-submit:disabled {
background-color: #3c3c3c;
cursor: not-allowed;
}
.terminal-line.info {
color: #75beff;
}

1
backend/go.mod
View File

@@ -6,6 +6,7 @@ require github.com/stretchr/testify v1.9.0
require (
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/gorilla/websocket v1.5.3 // indirect
github.com/kr/pretty v0.3.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/rogpeppe/go-internal v1.12.0 // indirect

2
backend/go.sum
View File

@@ -1,6 +1,8 @@
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=

85
backend/handler/websocket.go Normal file
View File

@@ -0,0 +1,85 @@
package handler
import (
"encoding/json"
"log"
"net/http"
"github.com/arnab-afk/monaco/model"
"github.com/gorilla/websocket"
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
// Allow all origins for development
CheckOrigin: func(r *http.Request) bool { return true },
}
// WebSocketHandler handles WebSocket connections for code execution
func (h *Handler) WebSocketHandler(w http.ResponseWriter, r *http.Request) {
// Upgrade the HTTP connection to a WebSocket connection
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf("Failed to upgrade connection: %v", err)
return
}
// Read the initial message containing the code submission
_, message, err := conn.ReadMessage()
if err != nil {
log.Printf("Failed to read message: %v", err)
conn.Close()
return
}
// Parse the message as a code submission
var submission model.CodeSubmission
if err := json.Unmarshal(message, &submission); err != nil {
log.Printf("Failed to parse message: %v", err)
conn.WriteMessage(websocket.TextMessage, []byte("Error: Invalid submission format"))
conn.Close()
return
}
// Validate the submission
if submission.Code == "" {
conn.WriteMessage(websocket.TextMessage, []byte("Error: Code is required"))
conn.Close()
return
}
// Set default language if not provided
if submission.Language == "" {
submission.Language = "python" // Default to Python
}
// Validate language
supportedLanguages := map[string]bool{
"python": true,
"java": true,
"c": true,
"cpp": true,
}
if !supportedLanguages[submission.Language] {
conn.WriteMessage(websocket.TextMessage, []byte("Error: Unsupported language: "+submission.Language))
conn.Close()
return
}
// Generate a unique ID for the submission
submission.ID = h.generateID()
submission.Status = "pending"
// Store the submission
h.mu.Lock()
h.submissions[submission.ID] = &submission
h.mu.Unlock()
// Send the submission ID to the client
conn.WriteMessage(websocket.TextMessage, []byte("Submission ID: "+submission.ID))
// Execute the code with WebSocket communication
h.executionService.HandleWebSocket(conn, &submission)
}

8
backend/internal/api/handlers/handlers.go
View File

@@ -2,6 +2,7 @@ package handlers
import (
"encoding/json"
"fmt"
"net/http"
"sync"
"time"
@@ -225,9 +226,10 @@ func (h *Handler) SubmitInputHandler(w http.ResponseWriter, r *http.Request) {
return
}
// Check if the submission is waiting for input
if submission.Status != "waiting_for_input" {
http.Error(w, "Submission is not waiting for input", http.StatusBadRequest)
// Check if the submission is waiting for input or running
// We're more lenient here to handle race conditions
if submission.Status != "waiting_for_input" && submission.Status != "running" {
http.Error(w, fmt.Sprintf("Submission is not waiting for input (status: %s)", submission.Status), http.StatusBadRequest)
return
}

261
backend/internal/api/handlers/websocket.go Normal file
View File

@@ -0,0 +1,261 @@
package handlers
import (
"fmt"
"log"
"net/http"
"sync"
"time"
"github.com/arnab-afk/monaco/internal/executor"
"github.com/arnab-afk/monaco/internal/models"
"github.com/gorilla/websocket"
)
// WebSocketTerminal represents a terminal session over WebSocket
type WebSocketTerminal struct {
ID string
Conn *websocket.Conn
InputChan chan string
OutputChan chan string
Done chan struct{}
mu sync.Mutex
}
var (
// Configure the upgrader
upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
// Allow all origins for development
CheckOrigin: func(r *http.Request) bool { return true },
}
// Active terminal sessions
terminals = make(map[string]*WebSocketTerminal)
terminalsMu sync.Mutex
)
// TerminalHandler handles WebSocket connections for terminal sessions
func (h *Handler) TerminalHandler(w http.ResponseWriter, r *http.Request) {
// Upgrade the HTTP connection to a WebSocket connection
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf("Failed to upgrade connection: %v", err)
return
}
// Generate a unique ID for this terminal session
terminalID := executor.GenerateUUID()
// Create channels for communication
inputChan := make(chan string)
outputChan := make(chan string)
done := make(chan struct{})
// Create a new terminal session
terminal := &WebSocketTerminal{
ID: terminalID,
Conn: conn,
InputChan: inputChan,
OutputChan: outputChan,
Done: done,
}
// Store the terminal session
terminalsMu.Lock()
terminals[terminalID] = terminal
terminalsMu.Unlock()
// Send the terminal ID to the client
if err := conn.WriteJSON(map[string]string{"type": "terminal_id", "id": terminalID}); err != nil {
log.Printf("Failed to send terminal ID: %v", err)
conn.Close()
return
}
// Handle incoming messages (input from the client)
go func() {
defer func() {
close(done)
conn.Close()
// Remove the terminal from the map
terminalsMu.Lock()
delete(terminals, terminalID)
terminalsMu.Unlock()
log.Printf("Terminal session %s closed", terminalID)
}()
for {
// Read message from the WebSocket
messageType, message, err := conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
log.Printf("WebSocket error: %v", err)
}
return
}
// Handle different message types
if messageType == websocket.TextMessage {
// Parse the message
input := string(message)
// Send the input to the execution service
select {
case inputChan <- input:
// Input sent successfully
case <-done:
return
}
}
}
}()
// Handle outgoing messages (output to the client)
go func() {
for {
select {
case output := <-outputChan:
// Send the output to the client
err := conn.WriteMessage(websocket.TextMessage, []byte(output))
if err != nil {
log.Printf("Failed to write message: %v", err)
return
}
case <-done:
return
}
}
}()
// Keep the connection alive with ping/pong
go func() {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
return
}
case <-done:
return
}
}
}()
}
// ExecuteCodeWebSocket executes code and streams the output over WebSocket
func (h *Handler) ExecuteCodeWebSocket(w http.ResponseWriter, r *http.Request) {
// Upgrade the HTTP connection to a WebSocket connection
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf("Failed to upgrade connection: %v", err)
return
}
defer conn.Close()
// Read the initial message containing the code to execute
_, message, err := conn.ReadMessage()
if err != nil {
log.Printf("Failed to read message: %v", err)
return
}
// Parse the message into a code submission
var submission models.CodeSubmission
if err := submission.UnmarshalJSON(message); err != nil {
log.Printf("Failed to parse submission: %v", err)
conn.WriteJSON(map[string]string{"error": "Invalid submission format"})
return
}
// Generate a unique ID for the submission
submission.ID = executor.GenerateUUID()
submission.Status = "pending"
// Store the submission
h.mu.Lock()
h.submissions[submission.ID] = &submission
h.mu.Unlock()
// Create channels for communication
inputChan := make(chan string)
outputChan := make(chan string)
done := make(chan struct{})
// Set up the execution service to use these channels
h.executionService.SetupWebSocketChannels(&submission, inputChan, outputChan)
// Send the submission ID to the client
if err := conn.WriteJSON(map[string]string{"type": "submission_id", "id": submission.ID}); err != nil {
log.Printf("Failed to send submission ID: %v", err)
return
}
// Execute the code in a goroutine
go func() {
h.executionService.ExecuteCodeWebSocket(&submission)
close(done)
}()
// Handle incoming messages (input from the client)
go func() {
for {
select {
case <-done:
return
default:
// Read message from the WebSocket
_, message, err := conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
log.Printf("WebSocket error: %v", err)
}
return
}
// Send the input to the execution service
select {
case inputChan <- string(message):
// Input sent successfully
case <-done:
return
}
}
}
}()
// Handle outgoing messages (output to the client)
for {
select {
case output := <-outputChan:
// Send the output to the client
err := conn.WriteMessage(websocket.TextMessage, []byte(output))
if err != nil {
log.Printf("Failed to write message: %v", err)
return
}
case <-done:
// Execution completed
return
}
}
}
// GetTerminal returns a terminal session by ID
func GetTerminal(id string) (*WebSocketTerminal, error) {
terminalsMu.Lock()
defer terminalsMu.Unlock()
terminal, exists := terminals[id]
if !exists {
return nil, fmt.Errorf("terminal not found: %s", id)
}
return terminal, nil
}

22
backend/internal/executor/executor.go
View File

@@ -23,6 +23,9 @@ type ExecutionService struct {
mu sync.Mutex
// Map of submission ID to input channel for interactive programs
inputChannels map[string]chan string
// WebSocket channels for real-time communication
wsInputChannels map[string]chan string
wsOutputChannels map[string]chan string
}
// CodeExecutionJob represents a code execution job
@@ -36,6 +39,8 @@ func NewExecutionService() *ExecutionService {
return &ExecutionService{
queue: queue.NewJobQueue(5), // 5 concurrent workers
inputChannels: make(map[string]chan string),
wsInputChannels: make(map[string]chan string),
wsOutputChannels: make(map[string]chan string),
}
}
@@ -117,6 +122,15 @@ func (s *ExecutionService) executePython(submission *models.CodeSubmission) {
return
}
// Check if we should use interactive mode
if strings.Contains(submission.Code, "input(") {
// This code likely requires interactive input
submission.IsInteractive = true
s.executePythonInteractive(submission, tempDir)
return
}
// Non-interactive mode
// Create a file for input if provided
inputPath := ""
if submission.Input != "" {
@@ -184,6 +198,14 @@ func (s *ExecutionService) executeJavaScript(submission *models.CodeSubmission)
return
}
// Check if we should use interactive mode
if strings.Contains(submission.Code, "readline") && strings.Contains(submission.Code, "question") {
// This code likely requires interactive input
submission.IsInteractive = true
s.executeJavaScriptInteractive(submission, tempDir)
return
}
// Create a file for input if provided
inputPath := ""
if submission.Input != "" {

366
backend/internal/executor/interactive.go Normal file
View File

@@ -0,0 +1,366 @@
package executor
import (
"bufio"
"context"
"fmt"
"log"
"os"
"os/exec"
"path/filepath"
"time"
"github.com/arnab-afk/monaco/internal/models"
)
// executePythonInteractive runs Python code in interactive mode
func (s *ExecutionService) executePythonInteractive(submission *models.CodeSubmission, tempDir string) {
log.Printf("[PYTHON-%s] Running Python in interactive mode", submission.ID)
// Create an input channel for this submission
inputChan := make(chan string)
s.mu.Lock()
s.inputChannels[submission.ID] = inputChan
s.mu.Unlock()
// Clean up when done
defer func() {
s.mu.Lock()
delete(s.inputChannels, submission.ID)
close(inputChan)
s.mu.Unlock()
}()
// Create a wrapper script that handles interactive input
wrapperPath := filepath.Join(tempDir, "wrapper.py")
wrapperCode := `
import sys
import os
import time
import traceback
# Load the user's code
with open('/code/code.py', 'r') as f:
user_code = f.read()
# Replace the built-in input function
original_input = input
def custom_input(prompt=''):
# Print the prompt without newline
sys.stdout.write(prompt)
sys.stdout.flush()
# Signal that we're waiting for input
sys.stdout.write('\n[WAITING_FOR_INPUT]\n')
sys.stdout.flush()
# Wait for input from the parent process
# Use a blocking read that won't raise EOFError
line = ''
while True:
try:
char = sys.stdin.read(1)
if char == '\n':
break
if char:
line += char
except:
# If any error occurs, wait a bit and try again
time.sleep(0.1)
continue
# Echo the input as if the user typed it
sys.stdout.write(line + '\n')
sys.stdout.flush()
return line
# Replace the built-in input function
input = custom_input
# Execute the user's code
try:
# Use globals and locals to ensure proper variable scope
exec(user_code, globals(), globals())
except Exception as e:
# Print detailed error information
sys.stdout.write(f'\nError: {str(e)}\n')
traceback.print_exc(file=sys.stdout)
sys.stdout.flush()
`
if err := os.WriteFile(wrapperPath, []byte(wrapperCode), 0644); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to write wrapper file: %v", err)
return
}
// Run the code in a Docker container
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) // Longer timeout for interactive
defer cancel()
// Start the container
cmd := exec.CommandContext(ctx, "docker", "run", "--rm", "-i",
"--network=none", // No network access
"--memory=100m", // Memory limit
"--cpu-period=100000", // CPU quota period
"--cpu-quota=10000", // 10% CPU
"--ulimit", "nofile=64:64", // File descriptor limits
"-v", tempDir+":/code", // Mount code directory
"python:3.9",
"python", "/code/wrapper.py")
// Get pipes for stdin and stdout
stdin, err := cmd.StdinPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdin pipe: %v", err)
return
}
stdout, err := cmd.StdoutPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdout pipe: %v", err)
return
}
// Start the command
if err := cmd.Start(); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to start command: %v", err)
return
}
// Set status to running
submission.Status = "running"
// Read output in a goroutine
go func() {
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
line := scanner.Text()
// Check if the program is waiting for input
if line == "[WAITING_FOR_INPUT]" {
// Update status to waiting for input
submission.Status = "waiting_for_input"
continue
}
// Add the output to the submission
submission.Output += line + "\n"
}
}()
// Handle input in a goroutine
go func() {
for input := range inputChan {
// Write the input to stdin
_, err := stdin.Write([]byte(input + "\n"))
if err != nil {
log.Printf("[ERROR] Failed to write to stdin: %v", err)
break
}
}
}()
// Wait for the command to complete
err = cmd.Wait()
// Update the submission status
if err != nil {
if ctx.Err() != nil {
submission.Status = "failed"
submission.Error = "Execution timed out"
} else {
submission.Status = "failed"
submission.Error = err.Error()
}
} else {
submission.Status = "completed"
}
submission.CompletedAt = time.Now()
log.Printf("[PYTHON-%s] Interactive execution completed", submission.ID)
}
// executeJavaScriptInteractive runs JavaScript code in interactive mode
func (s *ExecutionService) executeJavaScriptInteractive(submission *models.CodeSubmission, tempDir string) {
log.Printf("[JS-%s] Running JavaScript in interactive mode", submission.ID)
// Create an input channel for this submission
inputChan := make(chan string)
s.mu.Lock()
s.inputChannels[submission.ID] = inputChan
s.mu.Unlock()
// Clean up when done
defer func() {
s.mu.Lock()
delete(s.inputChannels, submission.ID)
close(inputChan)
s.mu.Unlock()
}()
// Create a wrapper script that handles interactive input
wrapperPath := filepath.Join(tempDir, "wrapper.js")
wrapperCode := `
const fs = require('fs');
const readline = require('readline');
// Load the user's code
const userCode = fs.readFileSync('/code/code.js', 'utf8');
// Create a custom readline interface
const originalReadline = readline.createInterface;
readline.createInterface = function(options) {
// Create a custom interface that intercepts input
const rl = originalReadline({
input: process.stdin,
output: process.stdout,
terminal: false
});
// Override the question method
const originalQuestion = rl.question;
rl.question = function(query, callback) {
// Print the prompt
process.stdout.write(query);
// Signal that we're waiting for input
process.stdout.write('\n[WAITING_FOR_INPUT]\n');
process.stdout.flush();
// Set up a more robust input handler
const onLine = (answer) => {
// Echo the input as if the user typed it
process.stdout.write(answer + '\n');
process.stdout.flush();
callback(answer);
};
// Handle input with error recovery
rl.once('line', onLine);
// Add error handler
rl.once('error', (err) => {
console.error('Input error:', err.message);
// Provide a default answer in case of error
callback('');
});
};
return rl;
};
// Capture uncaught exceptions
process.on('uncaughtException', (err) => {
console.error('Uncaught Exception:', err.message);
console.error(err.stack);
});
// Execute the user's code
try {
eval(userCode);
} catch (e) {
console.error('Error:', e.message);
console.error(e.stack);
}
`
if err := os.WriteFile(wrapperPath, []byte(wrapperCode), 0644); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to write wrapper file: %v", err)
return
}
// Run the code in a Docker container
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) // Longer timeout for interactive
defer cancel()
// Start the container
cmd := exec.CommandContext(ctx, "docker", "run", "--rm", "-i",
"--network=none", // No network access
"--memory=100m", // Memory limit
"--cpu-period=100000", // CPU quota period
"--cpu-quota=10000", // 10% CPU
"-v", tempDir+":/code", // Mount code directory
"node:18-alpine",
"node", "/code/wrapper.js")
// Get pipes for stdin and stdout
stdin, err := cmd.StdinPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdin pipe: %v", err)
return
}
stdout, err := cmd.StdoutPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdout pipe: %v", err)
return
}
// Start the command
if err := cmd.Start(); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to start command: %v", err)
return
}
// Set status to running
submission.Status = "running"
// Read output in a goroutine
go func() {
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
line := scanner.Text()
// Check if the program is waiting for input
if line == "[WAITING_FOR_INPUT]" {
// Update status to waiting for input
submission.Status = "waiting_for_input"
continue
}
// Add the output to the submission
submission.Output += line + "\n"
}
}()
// Handle input in a goroutine
go func() {
for input := range inputChan {
// Write the input to stdin
_, err := stdin.Write([]byte(input + "\n"))
if err != nil {
log.Printf("[ERROR] Failed to write to stdin: %v", err)
break
}
}
}()
// Wait for the command to complete
err = cmd.Wait()
// Update the submission status
if err != nil {
if ctx.Err() != nil {
submission.Status = "failed"
submission.Error = "Execution timed out"
} else {
submission.Status = "failed"
submission.Error = err.Error()
}
} else {
submission.Status = "completed"
}
submission.CompletedAt = time.Now()
log.Printf("[JS-%s] Interactive execution completed", submission.ID)
}

376
backend/internal/executor/websocket.go Normal file
View File

@@ -0,0 +1,376 @@
package executor
import (
"bufio"
"context"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"github.com/arnab-afk/monaco/internal/models"
)
// WebSocketSession represents a WebSocket execution session
type WebSocketSession struct {
Submission *models.CodeSubmission
InputChan chan string
OutputChan chan string
Done chan struct{}
}
// SetupWebSocketChannels sets up the channels for WebSocket communication
func (s *ExecutionService) SetupWebSocketChannels(submission *models.CodeSubmission, inputChan chan string, outputChan chan string) {
s.mu.Lock()
defer s.mu.Unlock()
// Store the channels in the service
s.wsInputChannels[submission.ID] = inputChan
s.wsOutputChannels[submission.ID] = outputChan
}
// ExecuteCodeWebSocket executes code and streams the output over WebSocket
func (s *ExecutionService) ExecuteCodeWebSocket(submission *models.CodeSubmission) {
log.Printf("[WS-%s] Starting WebSocket execution for %s code", submission.ID, submission.Language)
// Update submission status
submission.Status = "running"
submission.StartedAt = time.Now()
// Execute the code based on the language
switch strings.ToLower(submission.Language) {
case "python":
s.executePythonWebSocket(submission)
case "javascript":
s.executeJavaScriptWebSocket(submission)
case "go":
s.executeGoWebSocket(submission)
case "java":
s.executeJavaWebSocket(submission)
case "c":
s.executeCWebSocket(submission)
case "cpp":
s.executeCppWebSocket(submission)
default:
submission.Status = "failed"
submission.Error = fmt.Sprintf("Unsupported language: %s", submission.Language)
submission.CompletedAt = time.Now()
}
log.Printf("[WS-%s] Execution completed with status: %s", submission.ID, submission.Status)
}
// executePythonWebSocket executes Python code with WebSocket communication
func (s *ExecutionService) executePythonWebSocket(submission *models.CodeSubmission) {
log.Printf("[WS-PYTHON-%s] Preparing Python WebSocket execution", submission.ID)
// Create a temporary directory for the code
tempDir, err := os.MkdirTemp("", "monaco-ws-python-*")
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to create temp directory: %v", err)
return
}
defer os.RemoveAll(tempDir)
// Write the code to a file
codePath := filepath.Join(tempDir, "code.py")
if err := os.WriteFile(codePath, []byte(submission.Code), 0644); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to write code file: %v", err)
return
}
// Get the input and output channels
s.mu.Lock()
inputChan := s.wsInputChannels[submission.ID]
outputChan := s.wsOutputChannels[submission.ID]
s.mu.Unlock()
// Create a context with timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
// Run the code in a Docker container
cmd := exec.CommandContext(ctx, "docker", "run", "--rm", "-i",
"--network=none", // No network access
"--memory=100m", // Memory limit
"--cpu-period=100000", // CPU quota period
"--cpu-quota=10000", // 10% CPU
"--ulimit", "nofile=64:64", // File descriptor limits
"-v", tempDir+":/code", // Mount code directory
"python:3.9",
"python", "/code/code.py")
// Get pipes for stdin and stdout
stdin, err := cmd.StdinPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdin pipe: %v", err)
return
}
stdout, err := cmd.StdoutPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdout pipe: %v", err)
return
}
stderr, err := cmd.StderrPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stderr pipe: %v", err)
return
}
// Start the command
if err := cmd.Start(); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to start command: %v", err)
return
}
// Create a done channel to signal when the command is complete
done := make(chan struct{})
// Read from stdout and send to the output channel
go func() {
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
line := scanner.Text()
select {
case outputChan <- line + "\n":
// Output sent successfully
case <-done:
return
}
}
}()
// Read from stderr and send to the output channel
go func() {
scanner := bufio.NewScanner(stderr)
for scanner.Scan() {
line := scanner.Text()
select {
case outputChan <- "ERROR: " + line + "\n":
// Error sent successfully
case <-done:
return
}
}
}()
// Read from the input channel and write to stdin
go func() {
for {
select {
case input := <-inputChan:
// Write the input to stdin
_, err := io.WriteString(stdin, input+"\n")
if err != nil {
log.Printf("[WS-PYTHON-%s] Failed to write to stdin: %v", submission.ID, err)
return
}
case <-done:
return
}
}
}()
// Wait for the command to complete
err = cmd.Wait()
close(done)
// Update the submission status
if err != nil {
if ctx.Err() != nil {
submission.Status = "failed"
submission.Error = "Execution timed out"
} else {
submission.Status = "failed"
submission.Error = err.Error()
}
} else {
submission.Status = "completed"
}
submission.CompletedAt = time.Now()
log.Printf("[WS-PYTHON-%s] WebSocket execution completed", submission.ID)
}
// executeJavaScriptWebSocket executes JavaScript code with WebSocket communication
func (s *ExecutionService) executeJavaScriptWebSocket(submission *models.CodeSubmission) {
log.Printf("[WS-JS-%s] Preparing JavaScript WebSocket execution", submission.ID)
// Create a temporary directory for the code
tempDir, err := os.MkdirTemp("", "monaco-ws-js-*")
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to create temp directory: %v", err)
return
}
defer os.RemoveAll(tempDir)
// Write the code to a file
codePath := filepath.Join(tempDir, "code.js")
if err := os.WriteFile(codePath, []byte(submission.Code), 0644); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to write code file: %v", err)
return
}
// Get the input and output channels
s.mu.Lock()
inputChan := s.wsInputChannels[submission.ID]
outputChan := s.wsOutputChannels[submission.ID]
s.mu.Unlock()
// Create a context with timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
// Run the code in a Docker container
cmd := exec.CommandContext(ctx, "docker", "run", "--rm", "-i",
"--network=none", // No network access
"--memory=100m", // Memory limit
"--cpu-period=100000", // CPU quota period
"--cpu-quota=10000", // 10% CPU
"-v", tempDir+":/code", // Mount code directory
"node:18-alpine",
"node", "/code/code.js")
// Get pipes for stdin and stdout
stdin, err := cmd.StdinPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdin pipe: %v", err)
return
}
stdout, err := cmd.StdoutPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stdout pipe: %v", err)
return
}
stderr, err := cmd.StderrPipe()
if err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to get stderr pipe: %v", err)
return
}
// Start the command
if err := cmd.Start(); err != nil {
submission.Status = "failed"
submission.Error = fmt.Sprintf("Failed to start command: %v", err)
return
}
// Create a done channel to signal when the command is complete
done := make(chan struct{})
// Read from stdout and send to the output channel
go func() {
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
line := scanner.Text()
select {
case outputChan <- line + "\n":
// Output sent successfully
case <-done:
return
}
}
}()
// Read from stderr and send to the output channel
go func() {
scanner := bufio.NewScanner(stderr)
for scanner.Scan() {
line := scanner.Text()
select {
case outputChan <- "ERROR: " + line + "\n":
// Error sent successfully
case <-done:
return
}
}
}()
// Read from the input channel and write to stdin
go func() {
for {
select {
case input := <-inputChan:
// Write the input to stdin
_, err := io.WriteString(stdin, input+"\n")
if err != nil {
log.Printf("[WS-JS-%s] Failed to write to stdin: %v", submission.ID, err)
return
}
case <-done:
return
}
}
}()
// Wait for the command to complete
err = cmd.Wait()
close(done)
// Update the submission status
if err != nil {
if ctx.Err() != nil {
submission.Status = "failed"
submission.Error = "Execution timed out"
} else {
submission.Status = "failed"
submission.Error = err.Error()
}
} else {
submission.Status = "completed"
}
submission.CompletedAt = time.Now()
log.Printf("[WS-JS-%s] WebSocket execution completed", submission.ID)
}
// executeGoWebSocket executes Go code with WebSocket communication
func (s *ExecutionService) executeGoWebSocket(submission *models.CodeSubmission) {
// Implementation similar to executePythonWebSocket but for Go
// For brevity, this is left as a placeholder
submission.Status = "failed"
submission.Error = "WebSocket execution for Go not implemented yet"
}
// executeJavaWebSocket executes Java code with WebSocket communication
func (s *ExecutionService) executeJavaWebSocket(submission *models.CodeSubmission) {
// Implementation similar to executePythonWebSocket but for Java
// For brevity, this is left as a placeholder
submission.Status = "failed"
submission.Error = "WebSocket execution for Java not implemented yet"
}
// executeCWebSocket executes C code with WebSocket communication
func (s *ExecutionService) executeCWebSocket(submission *models.CodeSubmission) {
// Implementation similar to executePythonWebSocket but for C
// For brevity, this is left as a placeholder
submission.Status = "failed"
submission.Error = "WebSocket execution for C not implemented yet"
}
// executeCppWebSocket executes C++ code with WebSocket communication
func (s *ExecutionService) executeCppWebSocket(submission *models.CodeSubmission) {
// Implementation similar to executePythonWebSocket but for C++
// For brevity, this is left as a placeholder
submission.Status = "failed"
submission.Error = "WebSocket execution for C++ not implemented yet"
}

1
backend/main.go
View File

@@ -51,6 +51,7 @@ func main() {
http.HandleFunc("/status", corsMiddleware(loggingMiddleware(h.StatusHandler)))
http.HandleFunc("/result", corsMiddleware(loggingMiddleware(h.ResultHandler)))
http.HandleFunc("/queue-stats", corsMiddleware(loggingMiddleware(h.QueueStatsHandler)))
http.HandleFunc("/ws", corsMiddleware(h.WebSocketHandler)) // WebSocket doesn't need logging middleware
port := ":8080"
log.Printf("Server started at %s", port)

229
backend/service/execution.go
View File

@@ -1,6 +1,8 @@
package service
import (
"bufio"
"context"
"fmt"
"io"
"log"
@@ -14,19 +16,24 @@ import (
"github.com/arnab-afk/monaco/model"
"github.com/arnab-afk/monaco/queue"
"github.com/gorilla/websocket"
)
// ExecutionService handles code execution for multiple languages
type ExecutionService struct {
mu sync.Mutex
queue *queue.JobQueue
wsConnections map[string]*websocket.Conn // Map of submission ID to WebSocket connection
wsInputChannels map[string]chan string // Map of submission ID to input channel
}
// NewExecutionService creates a new execution service
func NewExecutionService() *ExecutionService {
log.Println("Initializing execution service with 3 concurrent workers")
return &ExecutionService{
queue: queue.NewJobQueue(35), // 3 concurrent executions max
queue: queue.NewJobQueue(3), // 3 concurrent executions max
wsConnections: make(map[string]*websocket.Conn),
wsInputChannels: make(map[string]chan string),
}
}
@@ -483,3 +490,223 @@ func (s *ExecutionService) GetQueueStats() map[string]int {
stats["queue_length"], stats["running_jobs"], stats["max_workers"])
return stats
}
// HandleWebSocket handles a WebSocket connection for a code submission
func (s *ExecutionService) HandleWebSocket(conn *websocket.Conn, submission *model.CodeSubmission) {
// Store the WebSocket connection
s.mu.Lock()
s.wsConnections[submission.ID] = conn
// Create an input channel for this submission
inputChan := make(chan string, 10) // Buffer size of 10
s.wsInputChannels[submission.ID] = inputChan
s.mu.Unlock()
// Clean up when done
defer func() {
s.mu.Lock()
delete(s.wsConnections, submission.ID)
delete(s.wsInputChannels, submission.ID)
s.mu.Unlock()
conn.Close()
}()
// Start a goroutine to read input from the WebSocket
go func() {
for {
// Read message from WebSocket
messageType, message, err := conn.ReadMessage()
if err != nil {
log.Printf("[WS-%s] Error reading message: %v", submission.ID, err)
break
}
// Only process text messages
if messageType == websocket.TextMessage {
// Send the input to the input channel
inputChan <- string(message)
}
}
}()
// Execute the code
submission.Status = "running"
submission.StartedAt = time.Now()
log.Printf("[WS-JOB-%s] Starting WebSocket execution for language: %s",
submission.ID, submission.Language)
// Execute the code based on the language
s.executeLanguageSpecificWithWebSocket(submission, inputChan, conn)
}
// executeLanguageSpecificWithWebSocket runs code in the appropriate language with WebSocket I/O
func (s *ExecutionService) executeLanguageSpecificWithWebSocket(submission *model.CodeSubmission, inputChan chan string, conn *websocket.Conn) {
log.Printf("[WS-EXEC-%s] Selecting execution environment for language: %s",
submission.ID, submission.Language)
switch submission.Language {
case "python":
log.Printf("[WS-EXEC-%s] Executing Python code", submission.ID)
s.executePythonWithWebSocket(submission, inputChan, conn)
case "java":
log.Printf("[WS-EXEC-%s] Executing Java code", submission.ID)
s.executeJavaWithWebSocket(submission, inputChan, conn)
case "c":
log.Printf("[WS-EXEC-%s] Executing C code", submission.ID)
s.executeCWithWebSocket(submission, inputChan, conn)
case "cpp":
log.Printf("[WS-EXEC-%s] Executing C++ code", submission.ID)
s.executeCppWithWebSocket(submission, inputChan, conn)
default:
log.Printf("[WS-EXEC-%s] ERROR: Unsupported language: %s", submission.ID, submission.Language)
submission.Status = "failed"
output := "Unsupported language: " + submission.Language
submission.Output = output
// Send error message to WebSocket
conn.WriteMessage(websocket.TextMessage, []byte(output))
}
// Update submission status
submission.CompletedAt = time.Now()
submission.Status = "completed"
}
// executePythonWithWebSocket runs Python code with WebSocket for I/O
func (s *ExecutionService) executePythonWithWebSocket(submission *model.CodeSubmission, inputChan chan string, conn *websocket.Conn) {
log.Printf("[WS-PYTHON-%s] Preparing Python WebSocket execution", submission.ID)
startTime := time.Now()
// Send initial message to client
conn.WriteMessage(websocket.TextMessage, []byte("Starting Python execution...\n"))
// Create a command to run Python in a Docker container
cmd := exec.Command("docker", "run", "--rm", "-i",
"--network=none", // No network access
"--memory=100m", // Memory limit
"--cpu-period=100000", // CPU quota period
"--cpu-quota=10000", // 10% CPU
"--ulimit", "nofile=64:64", // File descriptor limits
"python:3.9", "python", "-c", submission.Code)
// Get stdin pipe
stdin, err := cmd.StdinPipe()
if err != nil {
log.Printf("[WS-PYTHON-%s] Failed to create stdin pipe: %v", submission.ID, err)
conn.WriteMessage(websocket.TextMessage, []byte("Error: Failed to create stdin pipe\n"))
return
}
// Get stdout and stderr pipes
stdout, err := cmd.StdoutPipe()
if err != nil {
log.Printf("[WS-PYTHON-%s] Failed to create stdout pipe: %v", submission.ID, err)
conn.WriteMessage(websocket.TextMessage, []byte("Error: Failed to create stdout pipe\n"))
return
}
stderr, err := cmd.StderrPipe()
if err != nil {
log.Printf("[WS-PYTHON-%s] Failed to create stderr pipe: %v", submission.ID, err)
conn.WriteMessage(websocket.TextMessage, []byte("Error: Failed to create stderr pipe\n"))
return
}
// Start the command
if err := cmd.Start(); err != nil {
log.Printf("[WS-PYTHON-%s] Failed to start command: %v", submission.ID, err)
conn.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("Error: Failed to start command: %v\n", err)))
return
}
// Create a context with timeout
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
// Create a channel to signal when the command is done
done := make(chan struct{})
// Start a goroutine to handle command completion
go func() {
err := cmd.Wait()
if err != nil {
log.Printf("[WS-PYTHON-%s] Command failed: %v", submission.ID, err)
conn.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("\nExecution failed: %v\n", err)))
} else {
log.Printf("[WS-PYTHON-%s] Command completed successfully", submission.ID)
conn.WriteMessage(websocket.TextMessage, []byte("\nExecution completed successfully\n"))
}
close(done)
}()
// Start a goroutine to read from stdout and stderr
go func() {
scanner := bufio.NewScanner(io.MultiReader(stdout, stderr))
for scanner.Scan() {
line := scanner.Text()
log.Printf("[WS-PYTHON-%s] Output: %s", submission.ID, line)
conn.WriteMessage(websocket.TextMessage, []byte(line+"\n"))
}
}()
// Handle input from the WebSocket
go func() {
for {
select {
case input := <-inputChan:
log.Printf("[WS-PYTHON-%s] Received input: %s", submission.ID, input)
// Write the input to stdin
_, err := io.WriteString(stdin, input+"\n")
if err != nil {
log.Printf("[WS-PYTHON-%s] Failed to write to stdin: %v", submission.ID, err)
}
case <-ctx.Done():
return
case <-done:
return
}
}
}()
// Wait for the command to complete or timeout
select {
case <-ctx.Done():
log.Printf("[WS-PYTHON-%s] Execution timed out after 30 seconds", submission.ID)
conn.WriteMessage(websocket.TextMessage, []byte("\nExecution timed out after 30 seconds\n"))
cmd.Process.Kill()
case <-done:
// Command completed
}
elapsed := time.Since(startTime)
log.Printf("[WS-PYTHON-%s] Python execution completed in %v", submission.ID, elapsed)
// Update submission result
submission.CompletedAt = time.Now()
submission.Status = "completed"
}
// executeJavaWithWebSocket runs Java code with WebSocket for I/O
func (s *ExecutionService) executeJavaWithWebSocket(submission *model.CodeSubmission, inputChan chan string, conn *websocket.Conn) {
// For now, just send a message that this is not implemented
conn.WriteMessage(websocket.TextMessage, []byte("Java WebSocket execution not yet implemented\n"))
submission.Status = "failed"
submission.Output = "Java WebSocket execution not yet implemented"
}
// executeCWithWebSocket runs C code with WebSocket for I/O
func (s *ExecutionService) executeCWithWebSocket(submission *model.CodeSubmission, inputChan chan string, conn *websocket.Conn) {
// For now, just send a message that this is not implemented
conn.WriteMessage(websocket.TextMessage, []byte("C WebSocket execution not yet implemented\n"))
submission.Status = "failed"
submission.Output = "C WebSocket execution not yet implemented"
}
// executeCppWithWebSocket runs C++ code with WebSocket for I/O
func (s *ExecutionService) executeCppWithWebSocket(submission *model.CodeSubmission, inputChan chan string, conn *websocket.Conn) {
// For now, just send a message that this is not implemented
conn.WriteMessage(websocket.TextMessage, []byte("C++ WebSocket execution not yet implemented\n"))
submission.Status = "failed"
submission.Output = "C++ WebSocket execution not yet implemented"
}

2
backend/tmp/build-errors.log
View File

@@ -1 +1 @@
exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1
exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1

BIN
backend/tmp/main.exe Normal file
View File

Binary file not shown.

3
examples/basic_input.py Normal file
View File

@@ -0,0 +1,3 @@
# Very basic input example
name = input("What is your name? ")
print(f"Hello, {name}!")

41
examples/interactive_calculator.js Normal file
View File

@@ -0,0 +1,41 @@
// Interactive Calculator Example
// This demonstrates how the interactive input/output works
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
function calculator() {
console.log("Welcome to the Interactive Calculator!");
console.log("Enter 'q' to quit at any time.");
function promptUser() {
rl.question("Enter an expression (e.g., 2 + 3): ", (expression) => {
if (expression.toLowerCase() === 'q') {
console.log("Thank you for using the Interactive Calculator!");
rl.close();
return;
}
try {
// Safely evaluate the expression
const result = eval(expression);
console.log(`Result: ${result}`);
} catch (e) {
console.log(`Error: ${e.message}`);
console.log("Please try again with a valid expression.");
}
// Continue prompting
promptUser();
});
}
// Start the prompt loop
promptUser();
}
// Run the calculator
calculator();

24
examples/interactive_calculator.py Normal file
View File

@@ -0,0 +1,24 @@
# Interactive Calculator Example
# This demonstrates how the interactive input/output works
def calculator():
print("Welcome to the Interactive Calculator!")
print("Enter 'q' to quit at any time.")
while True:
expression = input("Enter an expression (e.g., 2 + 3): ")
if expression.lower() == 'q':
print("Thank you for using the Interactive Calculator!")
break
try:
# Safely evaluate the expression
result = eval(expression)
print(f"Result: {result}")
except Exception as e:
print(f"Error: {str(e)}")
print("Please try again with a valid expression.")
# Run the calculator
calculator()

22
examples/interactive_javascript.js Normal file
View File

@@ -0,0 +1,22 @@
// Interactive JavaScript Example
// This example demonstrates interactive input/output
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
rl.question('Enter your name: ', (name) => {
console.log(`Hello, ${name}!`);
rl.question('Enter your age: ', (age) => {
console.log(`You are ${age} years old.`);
rl.question('What is your favorite color? ', (color) => {
console.log(`Your favorite color is ${color}.`);
console.log('Thank you for using the interactive example!');
rl.close();
});
});
});

13
examples/interactive_python.py Normal file
View File

@@ -0,0 +1,13 @@
# Interactive Python Example
# This example demonstrates interactive input/output
name = input("Enter your name: ")
print(f"Hello, {name}!")
age = input("Enter your age: ")
print(f"You are {age} years old.")
favorite_color = input("What is your favorite color? ")
print(f"Your favorite color is {favorite_color}.")
print("Thank you for using the interactive example!")

5
examples/simple_input.py Normal file
View File

@@ -0,0 +1,5 @@
# Simple input example
name = input("Enter your name: ")
print(f"Hello, {name}!")
for i in range(5):
print(f"Count: {i}")