Feedback

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+.env
+.vscode/

README.md

@@ -1,7 +1,21 @@
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/bzPrOe11)
 # CS3219 Project (PeerPrep) - AY2425S1
-## Group: Gxx
+## Group: G46
 
 ### Note: 
 - You can choose to develop individual microservices within separate folders within this repository **OR** use individual repositories (all public) for each microservice. 
 - In the latter scenario, you should enable sub-modules on this GitHub classroom repository to manage the development/deployment **AND** add your mentor to the individual repositories as a collaborator. 
 - The teaching team should be given access to the repositories as we may require viewing the history of the repository in case of any disputes or disagreements. 
+
+### Run PeerPrep with docker-compose:
+Prerequisite: Ensure that Docker is installed and running.
+1. Clone the repository.
+2. Ensure that the respective `.env` files for all microservices, and the frontend, have been added in.
+3. In any IDE or terminal, `cd` to the project root directory, and run the following commands:
+    - `docker-compose build --no-cache` to build the images
+    - `docker-compose up -d` to run the web app on `localhost:3000`
+    - `docker-compose down` to stop running the containers
+
+### Production Deployment of PeerPrep
+- The production build and deployment of PeerPrep is located under the `deployment` branch.
+- Deployment link: http://g46-peerprep-env.eba-u9cm3q7g.ap-southeast-1.elasticbeanstalk.com/

backend/api-gateway/.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+npm-debug.log

backend/api-gateway/.env.sample

@@ -0,0 +1,5 @@
+PORT=8000
+
+QUESTION_SERVICE_URL=
+USER_SERVICE_URL=
+COLLABORATION_SERVICE_URL=

backend/api-gateway/Dockerfile

@@ -0,0 +1,20 @@
+# Use an official Node.js runtime as a parent image
+FROM node:20-alpine
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy package.json and package-lock.json
+COPY package*.json ./
+
+# Install any dependencies
+RUN npm install
+
+# Bundle app source inside the Docker image
+COPY . .
+
+# Make port 8000 available to the world outside this container
+EXPOSE 8000
+
+# Define the command to run your app
+CMD ["npm", "start"]

backend/api-gateway/handler/socketHandler.js

@@ -0,0 +1,199 @@
+let socketMap = {};
+let matchingService, collaborationService;
+
+const handleSocketIO = (io) => {
+  io.on("connection", (socket) => {
+    console.log(`A user connected with socket ID: ${socket.id}`);
+
+    socket.on("matchingService", () => {
+      console.log(`matching service connected with socket ID: ${socket.id}`);
+      matchingService = socket.id;
+    });
+
+    socket.on("collaborationService", () => {
+      console.log(`collaboration service connected with socket ID: ${socket.id}`);
+      collaborationService = socket.id;
+    });
+
+    // Listen for the join_matching_queue event from the client
+    socket.on("join_matching_queue", async (data) => {
+      console.log(`New request for matching:`, data);
+      const { email } = data;
+
+      // Store the socket ID for the user
+      socketMap[email] = socket.id;
+
+      io.to(matchingService).emit("join_matching_queue", data);
+    });
+
+    // Listen for cancel_matching event from client
+    socket.on("cancel_matching", async (data) => {
+      console.log(`Cancelling matching for user:`, data.email);
+      const { email } = data;
+
+      // Store the socket ID for the user
+      socketMap[email] = socket.id;
+
+      io.to(matchingService).emit("cancel_matching", data);
+    });
+
+    socket.on("match_found", (data) => {
+      const { user1, user2, matchData, id } = data;
+
+      console.log("data", matchData);
+
+      // Notify both users about the match
+      io.to(socketMap[user1]).emit("match_found", {
+        data: matchData,
+        id,
+      });
+
+      io.to(socketMap[user2]).emit("match_found", {
+        data: matchData,
+        id,
+      });
+    });
+
+    socket.on("createSocketRoom", async ({ data, id, currentUser }) => {
+      console.log("create socket room");
+      // Store the socket id for the user
+      socketMap[currentUser] = socket.id;
+      socket.roomId = id;
+
+      socket.join(id);
+      console.log(`User with socket ID ${socket.id} joined room with ID ${id}`);
+
+      const room = io.sockets.adapter.rooms.get(id);
+      console.log("room", room.size);
+
+      io.to(collaborationService).emit("createSocketRoom", { data: data, id: id, roomSize: room.size });
+    });
+
+    socket.on("readyForCollab", async (data) => {
+      console.log("ready for collab");
+      const { id, questionData } = data;
+
+      io.in(id).emit("readyForCollab", data);
+
+      console.log(
+        `Room ${id} is ready. Collaboration question sent: ${questionData}`
+      );
+    });
+
+    socket.on("reconnecting", ({ id, currentUser }) => {
+      socketMap[currentUser] = socket.id;
+      socket.join(id);
+      console.log(
+        `User with socket ID ${socket.id} reconnected to room with ID ${id}`
+      );
+    });
+
+    socket.on("sendContent", (data) => {
+      io.to(collaborationService).emit("sendContent", data);
+    });
+
+    socket.on("receiveContent", ({ id, content }) => {
+      io.to(id).emit("receiveContent", { content: content });
+    });
+
+    socket.on("sendCode", (data) => {
+      io.to(collaborationService).emit("sendCode", data);
+    });
+
+    socket.on("receiveCode", ({ id, code }) => {
+      io.to(id).emit("receiveCode", { code: code });
+    });
+
+    socket.on("languageChange", (data) => {
+      io.to(collaborationService).emit("sendLanguageChange", data);
+    });
+
+    socket.on("receivelanguageChange", ({ id, language }) => {
+      io.to(id).emit("receivelanguageChange", { language: language });
+    });
+
+    socket.on("sendMessage", (data) => {
+      console.log("send chat message", data);
+      io.to(collaborationService).emit("sendMessage", data);
+    });
+
+    socket.on("receiveMessage", ({ id, message }) => {
+      io.to(id).emit("receiveMessage", { message: message });
+    });
+
+    socket.on("endSession", ({ id }) => {
+      console.log("endSession");
+      io.to(collaborationService).emit("endSession", { id: id });
+    });
+
+    socket.on("sessionEnded", ({ user1Email, user2Email, roomId }) => {
+      io.in(roomId).emit("sessionEnded", { user1Email: user1Email, user2Email: user2Email, roomId: roomId });
+
+      const user1 = socketMap[user1Email];
+      const user2 = socketMap[user2Email];
+      const user1Socket = io.sockets.sockets.get(user1);
+      const user2Socket = io.sockets.sockets.get(user2);
+      if (user1Socket) {
+        user1Socket.disconnect();
+      }
+      if (user2Socket) {
+        user2Socket.disconnect();
+      }
+    });
+
+    socket.on("submissionCount", ({ id, count, totalUsers }) => {
+      io.in(id).emit("submissionCount", { count, totalUsers });
+    });
+
+    socket.on("cancelendSession", ({ id }) => {
+      io.to(collaborationService).emit("cancelendSession", { id: id });
+    });
+
+    socket.on("userDisconnect", ({ id }) => {
+      io.to(collaborationService).emit("userDisconnect", { id: id });
+    });
+
+    socket.on("sendUserDisconnect", ({ id }) => {
+      io.in(id).emit("userDisconnect", { id: id });
+    });
+
+    socket.on("userReconnect", ({ id }) => {
+      io.to(collaborationService).emit("userReconnect", { id: id });
+    });
+
+    socket.on("sendUserReconnect", ({ id }) => {
+      io.in(id).emit("userReconnect", { id: id });
+    });
+
+    socket.on("reloadSession", ({ id }) => {
+      socket.join(id);
+      console.log(`Reloaded - User with socket ID ${socket.id} joined room with ID ${id}`);
+
+      io.to(collaborationService).emit("reloadSession", { id: id });
+    });
+
+    socket.on("receiveCount", ({ id }) => {
+      io.to(id).emit("receiveCount", { id: id });
+    });
+
+    // Handle disconnection
+    socket.on("disconnect", () => {
+      console.log(`User with socket ID ${socket.id} disconnected`);
+      io.to(collaborationService).emit("socketDisconnect", { roomId: socket.roomId });
+
+      socketMap = Object.fromEntries(
+        Object.entries(socketMap).filter(([key]) => key !== socket.id)
+      );
+
+      if (socket.roomId) {
+        socket.leave(socket.roomId);
+        console.log(`User with socket ID ${socket.id} disconnected, leaving ${socket.roomId}`);
+      } else {
+        console.log(`User with socket ID ${socket.id} disconnected`);
+      }
+    });
+  });
+};
+
+// Export user functions
+module.exports = { handleSocketIO };

backend/api-gateway/index.js

@@ -0,0 +1,57 @@
+// Author(s): Xiu Jia
+require("dotenv").config();
+
+const express = require("express");
+const cors = require("cors");
+const rateLimit = require('express-rate-limit');
+const http = require("http");
+const { Server } = require("socket.io");
+const { handleSocketIO } = require("./handler/socketHandler.js");
+const apiRoute = require("./routes/apiGatewayRoute.js");
+
+const port = process.env.PORT || 8000;
+
+// Create an instance of Express app
+const app = express();
+const server = http.createServer(app);
+
+// Initialize the Socket.IO server
+const io = new Server(server, {
+  cors: {
+    origin: "*", // Allow all origins, adjust as needed
+    methods: ["GET", "POST"],
+  },
+});
+
+handleSocketIO(io);
+
+app.use(express.json());
+app.use(cors());
+
+// Define a rate limiter with options
+const apiLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100, // limit each IP to 100 requests per windowMs
+  message: 'Too many requests from this IP, please try again later.',
+
+  // Custom handler function for rate limit errors
+  handler: (req, res) => {
+    res.status(429).send({
+      error: 'You have exceeded the maximum allowed requests. Please wait a while and try again.',
+    });
+  },
+});
+
+app.use(apiLimiter);
+
+// default API from expressJS
+app.get("/", (req, res) => {
+  res.send("Welcome to the Express server!");
+});
+
+// Route
+app.use("/api", apiRoute);
+
+server.listen(port, () => {
+  console.log(`Server listening on port ${port}`);
+});