[Feat]Redis 설정 및 Room 모듈 초기화

backend/package.json

@@ -25,6 +25,8 @@
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/platform-socket.io": "^10.4.6",
     "@nestjs/websockets": "^10.4.6",
+    "dotenv": "^16.4.5",
+    "ioredis": "^5.4.1",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
     "socket.io": "^4.8.1"

backend/src/app.module.ts

@@ -1,10 +1,14 @@
 import { Module } from "@nestjs/common";
 import { AppController } from "./app.controller";
 import { AppService } from "./app.service";
-import { SocketModule } from "./socket/socket.module";
+import { SocketModule } from "./signaling-server/socket.module";
+import { RoomModule } from "./room/room.module";
+import { RedisModule } from "./redis/redis.module";
+
+import "dotenv/config";
 
 @Module({
-    imports: [SocketModule],
+    imports: [SocketModule, RoomModule, RedisModule],
     controllers: [AppController],
     providers: [AppService],
 })

backend/src/config/redis.config.ts

@@ -0,0 +1,7 @@
+import "dotenv/config";
+
+export const redisConfig = {
+    host: process.env.REDIS_HOST,
+    port: parseInt(process.env.REDIS_PORT),
+    password: process.env.REDIS_PASSWORD,
+};

backend/src/redis/redis.module.ts

@@ -0,0 +1,7 @@
+import { Module } from "@nestjs/common";
+import { RedisService } from "./redis.service";
+
+@Module({
+    providers: [RedisService],
+})
+export class RedisModule {}

backend/src/redis/redis.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { RedisService } from "./redis.service";
+
+describe("RedisService", () => {
+    let service: RedisService;
+
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+            providers: [RedisService],
+        }).compile();
+
+        service = module.get<RedisService>(RedisService);
+    });
+
+    it("should be defined", () => {
+        expect(service).toBeDefined();
+    });
+});

backend/src/redis/redis.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from "@nestjs/common";
+import Redis from "ioredis";
+import { redisConfig } from "../config/redis.config";
+
+@Injectable()
+export class RedisService {
+    private readonly client: Redis;
+
+    constructor() {
+        this.client = new Redis({
+            host: redisConfig.host,
+            port: redisConfig.port,
+            password: redisConfig.password,
+        });
+    }
+    getClient(): Redis {
+        return this.client;
+    }
+}

backend/src/room/room.gateway.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { RoomGateway } from "./room.gateway";
+
+describe("RoomGateway", () => {
+    let gateway: RoomGateway;
+
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+            providers: [RoomGateway],
+        }).compile();
+
+        gateway = module.get<RoomGateway>(RoomGateway);
+    });
+
+    it("should be defined", () => {
+        expect(gateway).toBeDefined();
+    });
+});

backend/src/room/room.gateway.ts

@@ -0,0 +1,108 @@
+import {
+    WebSocketGateway,
+    WebSocketServer,
+    OnGatewayConnection,
+    OnGatewayDisconnect,
+    SubscribeMessage,
+    MessageBody,
+} from "@nestjs/websockets";
+import { Server, Socket } from "socket.io";
+import { RoomService } from "./room.service";
+
+const EVENT_NAME = {
+    CREATE_ROOM: "create_room",
+    JOIN_ROOM: "join_room",
+    MASTER_CHANGED: "master_changed",
+    FINISH_ROOM: "finish_room",
+    REACTION: "reaction",
+
+    USER_EXIT: "user_exit",
+    ROOM_FULL: "room_full",
+    ALL_USERS: "all_users",
+} as const;
+
+interface User {
+    id: string;
+    nickname: string;
+}
+
+@WebSocketGateway({
+    cors: {
+        origin: "*", // CORS 설정
+    },
+})
+@WebSocketGateway()
+export class RoomGateway implements OnGatewayConnection, OnGatewayDisconnect {
+    @WebSocketServer()
+    server: Server;
+
+    constructor(private readonly roomService: RoomService) {}
+
+    private users: { [key: string]: User[] } = {};
+    private socketToRoom: { [key: string]: string } = {};
+    private maximum = 5;
+
+    handleConnection(client: Socket) {
+        console.log(`Client connected in room: ${client.id}`);
+    }
+
+    handleDisconnect(client: Socket): any {
+        console.log(`Client disconnected in room: ${client.id}`);
+        const roomID = this.socketToRoom[client.id];
+        if (roomID) {
+            const room = this.users[roomID];
+            if (room) {
+                this.users[roomID] = room.filter(
+                    (user) => user.id !== client.id
+                );
+                if (this.users[roomID].length === 0) {
+                    delete this.users[roomID];
+                } else {
+                    this.server.to(roomID).emit(EVENT_NAME.USER_EXIT, { id: client.id });
+                }
+            }
+        }
+    }
+
+    @SubscribeMessage(EVENT_NAME.CREATE_ROOM)
+    async handleCreateRoom(client: Socket, data: { title }) {
+        try {
+            const roomId = await this.roomService.createRoom(
+                data.title,
+                client.id
+            );
+            this.server.emit(`room_created`, { roomId });
+        } catch(error) {
+            console.error(error);
+            return null;
+        }
+    }
+
+
+    @SubscribeMessage(EVENT_NAME.JOIN_ROOM)
+    handleJoinRoom(client: Socket, data: { room: string; nickname: string }) {
+        if (this.users[data.room]) {
+            if (this.users[data.room].length === this.maximum) {
+                client.emit(EVENT_NAME.ROOM_FULL);
+                return;
+            }
+            this.users[data.room].push({
+                id: client.id,
+                nickname: data.nickname,
+            });
+        } else {
+            this.users[data.room] = [
+                { id: client.id, nickname: data.nickname },
+            ];
+        }
+
+        this.socketToRoom[client.id] = data.room;
+        client.join(data.room);
+        console.log(`[${data.room}]: ${client.id} enter`);
+
+        const usersInThisRoom = this.users[data.room].filter(
+            (user) => user.id !== client.id
+        );
+        client.emit(EVENT_NAME.ALL_USERS, usersInThisRoom);
+    }
+}

backend/src/room/room.model.ts

@@ -0,0 +1,6 @@
+export interface Room {
+    title: string;
+    createdAt: number;
+    members: string[];
+    host: string;
+}

backend/src/room/room.module.ts

@@ -0,0 +1,9 @@
+import { Module } from "@nestjs/common";
+import { RoomService } from "./room.service";
+import { RoomGateway } from "./room.gateway";
+import { RedisService } from "../redis/redis.service";
+
+@Module({
+    providers: [RoomService, RoomGateway, RedisService],
+})
+export class RoomModule {}

backend/src/room/room.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { RoomService } from "./room.service";
+
+describe("RoomService", () => {
+    let service: RoomService;
+
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+            providers: [RoomService],
+        }).compile();
+
+        service = module.get<RoomService>(RoomService);
+    });
+
+    it("should be defined", () => {
+        expect(service).toBeDefined();
+    });
+});

backend/src/room/room.service.ts

@@ -0,0 +1,25 @@
+import { Injectable } from "@nestjs/common";
+import { RedisService } from "../redis/redis.service";
+import { Room } from "./room.model";
+import { generateRoomId } from "../utils/generateRoomId";
+import { HOUR } from "../utils/time";
+
+@Injectable()
+export class RoomService {
+    constructor(private readonly redisService: RedisService) {}
+
+    async createRoom(title: string, socketId: string) {
+        const client = this.redisService.getClient();
+        const roomId = generateRoomId();
+
+        await client.hset(`room:${roomId}`, {
+            title: title,
+            createdAt: Date.now(),
+            members: [socketId],
+            host: socketId,
+        } as Room);
+
+        await client.expire(`room:${roomId}`, 6 * HOUR);
+        return roomId;
+    }
+}

backend/src/signaling-server/socket.gateway.ts

@@ -0,0 +1,74 @@
+import {
+    WebSocketGateway,
+    WebSocketServer,
+    OnGatewayConnection,
+    OnGatewayDisconnect,
+    SubscribeMessage,
+    MessageBody,
+} from "@nestjs/websockets";
+import { Server } from "socket.io";
+
+@WebSocketGateway({
+    cors: {
+        origin: "*", // CORS 설정
+    },
+})
+export class SocketGateway implements OnGatewayConnection, OnGatewayDisconnect {
+    @WebSocketServer()
+    server: Server;
+
+    handleConnection(socket: any) {
+        console.log(`Client connected in signaling server: ${socket.id}`);
+    }
+
+    handleDisconnect(socket: any) {
+        console.log(`Client disconnected signaling server: ${socket.id}`);
+    }
+
+    @SubscribeMessage("offer")
+    handleOffer(
+        @MessageBody()
+        data: {
+            offerReceiveID: string;
+            sdp: any;
+            offerSendID: string;
+            offerSendNickname: string;
+        }
+    ) {
+        this.server.to(data.offerReceiveID).emit("getOffer", {
+            sdp: data.sdp,
+            offerSendID: data.offerSendID,
+            offerSendNickname: data.offerSendNickname,
+        });
+    }
+
+    @SubscribeMessage("answer")
+    handleAnswer(
+        @MessageBody()
+        data: {
+            answerReceiveID: string;
+            sdp: any;
+            answerSendID: string;
+        }
+    ) {
+        this.server.to(data.answerReceiveID).emit("getAnswer", {
+            sdp: data.sdp,
+            answerSendID: data.answerSendID,
+        });
+    }
+
+    @SubscribeMessage("candidate")
+    handleCandidate(
+        @MessageBody()
+        data: {
+            candidateReceiveID: string;
+            candidate: any;
+            candidateSendID: string;
+        }
+    ) {
+        this.server.to(data.candidateReceiveID).emit("getCandidate", {
+            candidate: data.candidate,
+            candidateSendID: data.candidateSendID,
+        });
+    }
+}