Set up handlers for match, queue and websocket

Author: ruiqi7

backend/matching-service/app.ts

@@ -9,7 +9,7 @@ import matchingRoutes from "./src/routes/matchingRoutes.ts";
 
 dotenv.config();
 
-const allowedOrigins = process.env.ORIGINS
+export const allowedOrigins = process.env.ORIGINS
   ? process.env.ORIGINS.split(",")
   : ["http://localhost:5173", "http://127.0.0.1:5173"];
 

backend/matching-service/package-lock.json

@@ -18,6 +18,7 @@
     "express": "^4.21.1",
     "socket.io": "^4.8.0",
     "swagger-ui-express": "^5.0.1",
+    "uuid": "^10.0.0",
     "yaml": "^2.5.1"
   },
   "devDependencies": {
@@ -29,6 +30,7 @@
     "@types/socket.io": "^3.0.2",
     "@types/supertest": "^6.0.2",
     "@types/swagger-ui-express": "^4.1.6",
+    "@types/uuid": "^10.0.0",
     "cross-env": "^7.0.3",
     "eslint": "^9.12.0",
     "globals": "^15.11.0",

backend/matching-service/package.json

@@ -1,11 +1,20 @@
 import http from "http";
-import app from "./app.ts";
-import Websocket from "./src/websocket/websocket.ts";
-import { handleMatchRequest } from "./src/websocket/websocketHandlers.ts";
+import app, { allowedOrigins } from "./app.ts";
+import { handleWebsocketMatchEvents } from "./src/handlers/websocketHandler.ts";
+import { Server } from "socket.io";
 
 const server = http.createServer(app);
-const io = Websocket.getInstance(server);
-io.initSocketHandlers([{ path: "/matching", handler: handleMatchRequest }]);
+export const io = new Server(server, {
+  cors: {
+    origin: allowedOrigins,
+    methods: ["GET", "POST"],
+  },
+  connectionStateRecovery: {},
+});
+
+io.on("connection", (socket) => {
+  handleWebsocketMatchEvents(socket);
+});
 
 const PORT = process.env.PORT || 3002;
 

backend/matching-service/server.ts

@@ -0,0 +1,98 @@
+import { io } from "../../server";
+import { Match, MatchItem, MatchRequest } from "../types/matchTypes";
+import { v4 as uuidv4 } from "uuid";
+import {
+  MATCH_ACCEPTANCE_TIMEOUT,
+  MATCH_FOUND,
+  MATCH_SUCCESSFUL,
+  MATCH_TIMEOUT,
+  MATCH_UNSUCCESSFUL,
+} from "../utils/constants";
+import { appendToMatchQueue } from "./queueHandler";
+import { Socket } from "socket.io";
+
+const matches: Match = {};
+
+export const createMatchItem = (socket: Socket, matchRequest: MatchRequest) => {
+  const { user, complexities, categories, languages, timeout } = matchRequest;
+
+  const matchTimeout = setTimeout(() => {
+    socket.emit(MATCH_TIMEOUT);
+  }, timeout * 1000);
+
+  const matchQueueItem: MatchItem = {
+    socket: socket,
+    user: user,
+    complexities: complexities,
+    categories: categories,
+    languages: languages,
+    timeout: matchTimeout,
+    acceptedMatch: false,
+  };
+
+  appendToMatchQueue(matchQueueItem);
+};
+
+export const createMatch = (matchItems: MatchItem[]) => {
+  const matchItem1 = matchItems[0];
+  const matchItem2 = matchItems[1];
+
+  clearTimeout(matchItem1.timeout);
+  clearTimeout(matchItem2.timeout);
+
+  const matchId = uuidv4();
+  matches[matchId] = {
+    item1: matchItem1,
+    item2: matchItem2,
+    timeout: null,
+    accepted: false,
+  };
+
+  matchItem1.socket.join(matchId);
+  matchItem2.socket.join(matchId);
+  io.to(matchId).emit(MATCH_FOUND, {
+    matchId: matchId,
+    user1: matchItem1.user,
+    user2: matchItem2.user,
+  });
+};
+
+export const setMatchTimeout = (matchId: string) => {
+  const match = matches[matchId];
+  if (!match) {
+    return;
+  }
+
+  const timeout = setTimeout(() => {
+    io.to(matchId).emit(MATCH_UNSUCCESSFUL);
+    delete matches[matchId];
+  }, MATCH_ACCEPTANCE_TIMEOUT);
+
+  match.timeout = timeout;
+};
+
+export const handleMatchAcceptance = (matchId: string) => {
+  const match = matches[matchId];
+  if (!match) {
+    return;
+  }
+
+  if (match.accepted) {
+    clearTimeout(match.timeout!);
+    io.to(matchId).emit(MATCH_SUCCESSFUL);
+    delete matches[matchId];
+  } else {
+    match.accepted = true;
+  }
+};
+
+export const handleMatchDecline = (matchId: string) => {
+  const match = matches[matchId];
+  if (!match) {
+    return;
+  }
+
+  clearTimeout(match.timeout!);
+  io.to(matchId).emit(MATCH_UNSUCCESSFUL);
+  delete matches[matchId];
+};

backend/matching-service/src/handlers/matchHandler.ts

@@ -0,0 +1,36 @@
+import { MatchItem } from "../types/matchTypes";
+import { createMatch } from "./matchHandler";
+
+/* Basic queue set-up for websocket testing (feel free to replace with the actual queueing mechanism) */
+
+const matchQueue: MatchItem[] = [];
+
+setInterval(() => {
+  findMatch();
+}, 5000);
+
+const findMatch = () => {
+  if (matchQueue.length < 2) {
+    return;
+  }
+
+  const matchedItems = [];
+  while (matchedItems.length < 2 && matchQueue.length > 0) {
+    const matchItem = matchQueue.shift()!;
+    if (matchItem.socket.connected) {
+      matchedItems.push(matchItem);
+    }
+  }
+
+  if (matchedItems.length === 2) {
+    createMatch(matchedItems);
+  } else {
+    matchedItems.reverse().forEach((item) => matchQueue.unshift(item));
+  }
+};
+
+export const appendToMatchQueue = (item: MatchItem) => {
+  if (!matchQueue.find((queueItem) => queueItem.user.id === item.user.id)) {
+    matchQueue.push(item);
+  }
+};

backend/matching-service/src/handlers/queueHandler.ts

@@ -0,0 +1,32 @@
+import { Socket } from "socket.io";
+import {
+  MATCH_ACCEPTED,
+  MATCH_DECLINED,
+  MATCH_RECEIVED,
+  MATCH_REQUEST,
+} from "../utils/constants";
+import { MatchRequest } from "../types/matchTypes";
+import {
+  createMatchItem,
+  handleMatchAcceptance,
+  handleMatchDecline,
+  setMatchTimeout,
+} from "./matchHandler";
+
+export const handleWebsocketMatchEvents = (socket: Socket) => {
+  socket.on(MATCH_REQUEST, (matchRequest: MatchRequest) => {
+    createMatchItem(socket, matchRequest);
+  });
+
+  socket.on(MATCH_RECEIVED, (matchId: string) => {
+    setMatchTimeout(matchId);
+  });
+
+  socket.on(MATCH_ACCEPTED, (matchId: string) => {
+    handleMatchAcceptance(matchId);
+  });
+
+  socket.on(MATCH_DECLINED, (matchId: string) => {
+    handleMatchDecline(matchId);
+  });
+};

backend/matching-service/src/handlers/websocketHandler.ts

@@ -0,0 +1,34 @@
+import { Socket } from "socket.io";
+
+export interface MatchUser {
+  id: string;
+  username: string;
+  profile: string;
+}
+
+export interface MatchRequest {
+  user: MatchUser;
+  complexities: string[];
+  categories: string[];
+  languages: string[];
+  timeout: number;
+}
+
+export interface MatchItem {
+  socket: Socket;
+  user: MatchUser;
+  complexities: string[];
+  categories: string[];
+  languages: string[];
+  timeout: NodeJS.Timeout;
+  acceptedMatch: boolean;
+}
+
+export interface Match {
+  [id: string]: {
+    item1: MatchItem;
+    item2: MatchItem;
+    timeout: NodeJS.Timeout | null;
+    accepted: boolean;
+  };
+}

backend/matching-service/src/types/matchTypes.ts

@@ -0,0 +1,11 @@
+/* Websocket Match Events */
+export const MATCH_REQUEST = "match_request";
+export const MATCH_TIMEOUT = "match_timeout";
+export const MATCH_FOUND = "match_found";
+export const MATCH_RECEIVED = "match_received";
+export const MATCH_ACCEPTED = "match_accepted";
+export const MATCH_DECLINED = "match_declined";
+export const MATCH_SUCCESSFUL = "match_successful";
+export const MATCH_UNSUCCESSFUL = "match_unsuccessful";
+
+export const MATCH_ACCEPTANCE_TIMEOUT = 10000;