Add more languages and fix "executing..." button

backend/collaboration-service/src/controllers/roomController.js

@@ -85,14 +85,15 @@ class RoomController {
   async fetchQuestionDetails(questionId) {
     try {
       const response = await axios.get(
-        `${config.QUESTION_SERVICE_URL}/v1/questions/${questionId}`,
+        `${config.QUESTION_SERVICE_URL}/v1/questions/${questionId}?includeArchived=true`,
         { timeout: 5000 }
       );
       return {
         _id: response.data._id,
         title: response.data.title,
         difficulty: response.data.difficulty,
         topic: response.data.topic,
+        status: response.data.status,
       };
     } catch (error) {
       if (error.response?.status === 404) {

backend/collaboration-service/src/http/codeExecutionRoutes.js

@@ -7,7 +7,7 @@ const router = express.Router();
 const RABBITMQ_URL = 'amqp://user:password@rabbitmq';
 const QUEUE_NAME = 'execution_jobs';
 
-const EXECUTION_TIMEOUT_MS = 30000 // 30s
+const EXECUTION_TIMEOUT_MS = 60000 // 60s
 const activeTimers = new Map()
 
 let mqChannel = null
@@ -59,6 +59,9 @@ router.post("/submit-code", async (req, res) => {
         }
 
         console.log(">>> Got code ", job)
+        roomManager.broadcastToRoom(room_id, {
+            type: "code-execution-started"
+        })
 
         // delete old timers
         if (activeTimers.has(room_id)) {

backend/collaboration-service/src/models/roomModel.js

@@ -18,7 +18,21 @@ const roomSchema = new mongoose.Schema(
     },
     programmingLanguage: {
       type: String,
-      enum: ["cpp", "java", "javascript", "python"],
+      enum: [
+        "c",
+        "cpp",
+        "csharp", 
+        "go",
+        "java", 
+        "javascript", 
+        "kotlin",
+        "php",
+        "python",
+        "ruby",
+        "rust",
+        "swift",
+        "typescript",
+      ],
       default: "python",
       required: true,
     },

backend/execution-service/src/worker.js

@@ -8,11 +8,12 @@ const PISTON_URL = process.env.PISTON_URL
 
 const MAX_RETRIES = 3
 const RETRY_DELAY_MS = 2000
-const PISTON_CALL_DELAY_MS = 10000
+const AXIOS_CONNECTION_TIMEOUT_MS = 2000
+const PISTON_EXECUTION_TIMEOUT_MS = 40000 // 40s
 
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 
-async function callPistonAPI(language, source_code) {
+async function callPistonAPI(language, source_code, timeout_ms) {
     try {
         const payload = {
             language: language,
@@ -21,10 +22,12 @@ async function callPistonAPI(language, source_code) {
                 {
                     content: source_code
                 }
-            ]
+            ],
+            run_timeout: 10000,
+            compile_timeout: 30000
         }
         const response = await axios.post(PISTON_URL, payload, {
-            timeout: PISTON_CALL_DELAY_MS
+            timeout: timeout_ms
         })
         return response.data
     } catch (error) {
@@ -55,29 +58,13 @@ async function resultCallback(result) {
  * @returns result: {room_id, isError, output}
  */
 async function processSubmission(submit) {
-    // If fail to connect Piston API for 3 times, then the submit is failed
     let result = {}
     result.room_id = submit.room_id
-    for (let i = 1; i <= MAX_RETRIES; i++) {
-        try {
-            const response = await callPistonAPI(submit.language, submit.source_code)
-
-            // set isError
-            if (response.run.status) { // runtime error
-                result.isError = true
-                // get readable message or output
-                result.output = response.run.message || response.run.output 
-            } else if (response.run.code !== 0) { // runcode != 0 error
-                result.isError = true
-                result.output = response.run.output
-            } else { // successfully run the code
-                result.isError = false
-                result.output = response.run.output
-            }
-
 
-            console.log(">>> Finish job", result)
-            return result
+    // first 2 time: check for connection
+    for (let i = 1; i <= MAX_RETRIES - 1; i++) {
+        try {
+            const response = await callPistonAPI(submit.language, submit.source_code, AXIOS_CONNECTION_TIMEOUT_MS)
         } catch (error) {
             if (error.response) {
                 const statusCode = error.response.status
@@ -88,26 +75,62 @@ async function processSubmission(submit) {
                     console.log(">>> Finish job (error)", result)
                     return result
                 } else {
-                    // rerun
+                    // piston temp error
                     console.log(">>> Piston api temporary error: ", statusCode)
                 }
-            } else {
-                // rerun
+            } else if (axios.isAxiosError(error) && error.code !== 'ECONNREFUSED') {
+                // timeout / no connection
                 console.log(">>> Piston api doesn't respond\n", error.message)
+            } else {
+                // ECONNREFUSED
+                console.log(">>> Piston api is dead (ECONNREFUSED)\n", error.message)
             }
-            if (i === MAX_RETRIES) {
-                break
+
+            // next try
+            const delay = RETRY_DELAY_MS * i;
+            console.log(`>>> Wait ${delay}ms before reconnect to Piston api`)
+            await sleep(delay)
+            continue
+        }
+        // if no error, quit try loop
+        break
+    }
+
+    // final try: timeout 40s
+    try {
+        const response = await callPistonAPI(submit.language, submit.source_code, PISTON_EXECUTION_TIMEOUT_MS)
+
+        // set isError
+        if (response.run.status) { // runtime error
+            result.isError = true
+            // get readable message or output
+            result.output = response.run.message || response.run.output 
+        } else if (response.run.code !== 0) { // runcode != 0 error
+            result.isError = true
+            result.output = response.run.output
+        } else { // successfully run the code
+            result.isError = false
+            result.output = response.run.output
+        }
+
+
+        console.log(">>> Finish job", result)
+        return result
+    } catch (error) {
+        if (error.response) {
+            const statusCode = error.response.status
+            if (statusCode >= 400 && statusCode < 500) {
+                result.isError = true
+                result.output = error.response.data.message
+                return result
             }
         }
-        const delay = RETRY_DELAY_MS * i;
-        console.log(`>>> Wait ${delay}ms before reconnect to Piston api`)
-        await sleep(delay)
+        // failed (after 3 tries)
+        result.isError = true
+        result.output = "Code execution service is unavailable. Please try again later."
+        console.log('>>> Failed job ', result)
+        return result
     }
-    // failed (after 3 tries)
-    result.isError = true
-    result.output = "Code execution service is unavailable. Please try again later."
-    console.log('>>> Failed job ', result)
-    return result
 }
 
 async function startWorker() {

backend/question-service/src/config/db.js

@@ -1,17 +1,66 @@
 const mongoose = require('mongoose')
-const Question = require('../models/questionModel')
+const { Question, Solution } = require('../models/questionModel')
 const seedData = require('../data/seed.json')
+const seedSolutions = require('../data/seed-solutions.json')
 
 const connectDB = async () => {
     try {
-        const con = await mongoose.connect(process.env.MONGODB_URI)
+        const con = await mongoose.connect(process.env.MONGO_URI)
         console.log(`MongoDB Connected: ${con.connection.host}`)
 
         const questionCount = await Question.countDocuments()
         if (questionCount === 0) {
             console.log('Database is empty, seeding with sample questions...')
-            await Question.insertMany(seedData)
+            const toInsert = seedData.map(s => ({ ...s, status: 'Active' }))
+            await Question.insertMany(toInsert)
             console.log(`Seeded ${seedData.length} questions`)
+            // sseed solutions that map to the seeded questions.
+            try {
+                const solCount = await Solution.countDocuments()
+                if (solCount === 0) {
+                    console.log('No solutions found, seeding sample solutions...')
+
+                    const qDocs = await Question.find({}, 'questionID title').lean()
+                    const titleToQID = {}
+                    qDocs.forEach(q => { if (q && q.title) titleToQID[q.title] = q.questionID })
+
+                    const toInsert = seedSolutions.map(s => {
+                        let mappedQID = s.questionID
+                        if (!mappedQID && s.questionTitle) mappedQID = titleToQID[s.questionTitle]
+                        if (!mappedQID) return null
+                        return {
+                            questionID: mappedQID,
+                            title: s.title || `${s.questionTitle || mappedQID} - solution`,
+                            difficulty: s.difficulty || null,
+                            topic: s.topic || null,
+                            language: s.language || 'JavaScript',
+                            code: s.code || '',
+                            explanation: s.explanation || '',
+                            timeComplexity: s.timeComplexity || null,
+                            spaceComplexity: s.spaceComplexity || null,
+                            mediaLink: s.mediaLink || null,
+                            status: s.status || 'Active'
+                        }
+                    }).filter(Boolean)
+
+                    if (toInsert.length === 0) {
+                        console.log('No seed solutions matched seeded questions, skipping solution auto-seed')
+                    } else {
+                        try {
+                            const inserted = await Solution.insertMany(toInsert, { ordered: false })
+                            console.log(`Seeded ${Array.isArray(inserted) ? inserted.length : (inserted && inserted.insertedCount) || 0} solutions`)
+                        } catch (bulkErr) {
+                            console.warn('Some errors occurred while inserting solution seeds:', bulkErr && bulkErr.message ? bulkErr.message : bulkErr)
+                            const finalCount = await Solution.countDocuments()
+                            console.log(`Database now contains ${finalCount} solutions`)
+                        }
+                    }
+                } else {
+                    console.log(`Database already contains ${solCount} solutions, skipping auto-seed for solutions`)
+                }
+            } catch (err) {
+                console.error('Error while auto-seeding solutions:', err)
+            }
         } else {
             console.log(`Database contains ${questionCount} questions`)
         }