Merge pull request #7 from boostcampwm-2024/dev-be

[Deploy] dev-be to prod-be

Author: hoeeeeeh

backend/chatServer/src/app.module.ts

@@ -1,9 +1,11 @@
 import { Module } from '@nestjs/common';
 import { ChatModule } from './chat/chat.module';
 import { RoomModule } from './room/room.module';
+import { UserModule } from './user/user.module';
+import { RedisModule } from './redis/redis.module';
 
 @Module({
-  imports: [ChatModule, RoomModule],
+  imports: [ChatModule, RoomModule, UserModule, RedisModule],
   providers: [],
 })
 export class AppModule {

backend/chatServer/src/chat/chat.gateway.ts

@@ -19,7 +19,6 @@ import {
 } from '../event/dto/IncomingMessage.dto';
 import { JoiningRoomDto } from '../event/dto/JoiningRoom.dto';
 import { RoomService } from '../room/room.service';
-import { createAdapter } from '@socket.io/redis-adapter';
 import { BlacklistGuard, HostGuard, MessageGuard } from './chat.guard';
 import { LeavingRoomDto } from '../event/dto/LeavingRoom.dto';
 import {
@@ -29,18 +28,21 @@ import {
 } from '../event/dto/OutgoingMessage.dto';
 import { QuestionDto } from '../event/dto/Question.dto';
 import { ChatException, CHATTING_SOCKET_ERROR } from './chat.error';
+import { RedisAdapterFactory } from '../redis/redis-adapter.factory';
 
 @WebSocketGateway({
   cors: true,
   pingInterval: 30000,
   pingTimeout: 10000,
 })
 export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
-  constructor(private roomService: RoomService) {};
+  constructor(
+    private roomService: RoomService,
+    private adapterFactory: RedisAdapterFactory) {};
 
-  async afterInit() {
-    const { pubClient, subClient } = this.roomService.getPubSubClients();
-    const redisAdapter = createAdapter(pubClient, subClient);
+  afterInit() {
+    // const adapterConstructor = this.adapterFactory.createAdapter();
+    const redisAdapter = this.adapterFactory.createAdapter();
     this.server.adapter(redisAdapter);
     console.log('Redis adapter set');
   }
@@ -51,7 +53,7 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
 
   async handleConnection(client: Socket) {
     console.log(`Client connected: ${client.id}`);
-    const user = await this.roomService.createUser(client);
+    const user = await this.roomService.addUser(client);
     console.log(user);
 
     /*
@@ -121,6 +123,10 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
     } else {
       // 나를 제외한, 방에 있는 모든 사람에게는 owner : user 로 보내고
       console.log('people', this.server.sockets.adapter.rooms.get(roomId));
+
+      // TODO: redis-adapter + redis-cluster 특성 상,
+      //  redis 모든 노드에게 이벤트가 전파될 것이므로 이벤트를 두 번에 나누어서 보내는 것은 부하가 2배가 될 것 같다.
+
       client.emit(CHATTING_SOCKET_RECEIVE_EVENT.NORMAL, { ...normalOutgoingMessage, owner: 'me' });
       client.broadcast.to(roomId).emit(CHATTING_SOCKET_RECEIVE_EVENT.NORMAL, {
         ...normalOutgoingMessage,

backend/chatServer/src/chat/chat.module.ts

@@ -2,9 +2,10 @@ import { Module } from '@nestjs/common';
 import { ChatGateway } from './chat.gateway';
 import { RoomModule } from '../room/room.module';
 import { BlacklistGuard, HostGuard, MessageGuard } from './chat.guard';
+import { RedisModule } from '../redis/redis.module';
 
 @Module({
-  imports: [RoomModule],
+  imports: [RoomModule, RedisModule],
   providers: [ChatGateway, MessageGuard, BlacklistGuard, HostGuard],
 })
 export class ChatModule {}

backend/chatServer/src/redis/redis-adapter.factory.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+import { RedisClientFactory } from './redis-client.factory';
+import { createAdapter } from '@socket.io/redis-adapter';
+
+@Injectable()
+export class RedisAdapterFactory {
+  constructor(private readonly redisClient: RedisClientFactory) {}
+
+  createAdapter() {
+    const pubClient = this.redisClient.createClient();
+    const subClient = this.redisClient.createClient();
+    return createAdapter(pubClient, subClient);
+  }
+}

backend/chatServer/src/redis/redis-client.factory.ts

@@ -0,0 +1,35 @@
+import { Injectable, OnModuleDestroy } from '@nestjs/common';
+import { Cluster, Redis } from 'ioredis';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+// 현재 파일의 URL을 파일 경로로 변환
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 상위 디렉터리의 .env 파일을 불러오기
+dotenv.config({ path: path.resolve(__dirname, '../../.env') });
+const REDIS_CONFIG = JSON.parse(process.env.REDIS_CONFIG!);
+
+
+@Injectable()
+export class RedisClientFactory implements OnModuleDestroy{
+  redisClientList: Cluster[] = [];
+
+  async onModuleDestroy(){
+    if (this.redisClientList) {
+      const quitPromise = this.redisClientList.map((redisClient) =>
+        redisClient.quit().catch((err) => console.error(err)));
+      await Promise.all(quitPromise);
+      console.log('Redis connection closed');
+    }
+  }
+
+  createClient() {
+    const newRedisClient = new Redis.Cluster(REDIS_CONFIG);
+    this.redisClientList.push(newRedisClient);
+    return newRedisClient;
+  }
+}

backend/chatServer/src/redis/redis.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { RedisAdapterFactory } from './redis-adapter.factory';
+import { RedisClientFactory } from './redis-client.factory';
+
+@Module({
+  providers: [RedisAdapterFactory, RedisClientFactory],
+  exports: [RedisAdapterFactory, RedisClientFactory],
+})
+export class RedisModule {}

backend/chatServer/src/room/room.interface.ts

@@ -1,8 +1,11 @@
 import { Module } from '@nestjs/common';
 import { RoomService } from './room.service';
 import { RoomRepository } from './room.repository';
+import { UserModule } from '../user/user.module';
+import { RedisModule } from '../redis/redis.module';
 
 @Module({
+  imports: [UserModule, RedisModule],
   providers: [RoomService, RoomRepository],
   exports: [RoomService, RoomRepository],
 })

backend/chatServer/src/room/room.module.ts

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { Cluster } from 'ioredis';
 import { QuestionDto } from '../event/dto/Question.dto';
 import { ChatException, CHATTING_SOCKET_ERROR } from '../chat/chat.error';
-import { User } from './user.interface';
+import { User } from '../user/user.dto';
 
 type USER_AGENT = string;
 

backend/chatServer/src/room/room.repository.ts

@@ -1,186 +1,131 @@
-import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
-import { Cluster, Redis } from 'ioredis';
-import { createAdapter } from '@socket.io/redis-adapter';
-import { User } from './user.interface';
-import { getRandomAdjective, getRandomBrightColor, getRandomNoun } from '../utils/random';
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { Cluster } from 'ioredis';
 import { RoomRepository } from './room.repository';
 import { QuestionDto } from '../event/dto/Question.dto';
 
-import dotenv from 'dotenv';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
 import { ChatException, CHATTING_SOCKET_ERROR } from '../chat/chat.error';
 import { Socket } from 'socket.io';
-
-// 현재 파일의 URL을 파일 경로로 변환
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// 상위 디렉터리의 .env 파일을 불러오기
-dotenv.config({ path: path.resolve(__dirname, '../../.env') });
-const REDIS_CONFIG = JSON.parse(process.env.REDIS_CONFIG!);
-
-function createRandomNickname(){
-  return `${getRandomAdjective()} ${getRandomNoun()}`;
-}
-
-function createRandomUserInstance(address: string, userAgent: string): User {
-  return {
-    address,
-    userAgent,
-    nickname: createRandomNickname(),
-    color: getRandomBrightColor(),
-    entryTime: new Date().toISOString()
-  };
-}
+import { UserFactory } from '../user/user.factory';
+import { RedisClientFactory } from '../redis/redis-client.factory';
 
 @Injectable()
-export class RoomService implements OnModuleInit, OnModuleDestroy {
-  redisAdapter: ReturnType<typeof createAdapter>;
-  redisClient: Cluster;
-
-  constructor(private redisRepository: RoomRepository) {
-    this.redisClient = new Redis.Cluster(REDIS_CONFIG);
-    this.redisAdapter = createAdapter(this.redisClient, this.redisClient);
-  }
-
-  async onModuleInit(){
-    const redisClient = new Redis.Cluster(REDIS_CONFIG);
-    this.redisRepository.injectClient(redisClient);
-  }
-
-  async onModuleDestroy(){
-    if (this.redisClient) {
-      await this.redisClient.quit();
-      console.log('Redis connection closed');
-    }
-  }
+export class RoomService implements OnModuleInit {
+  redisClient: Cluster | undefined;
+  constructor(private readonly redisClientFactory: RedisClientFactory, private roomRepository: RoomRepository, private userFactory: UserFactory) {}
 
-  getClient(): Cluster {
-    return this.redisClient;
+  async onModuleInit() {
+    this.redisClient = this.redisClientFactory.createClient();
+    this.roomRepository.injectClient(this.redisClient);
   }
 
-  getPubSubClients(): { pubClient: Cluster; subClient: Cluster } {
-    const pubClient = this.redisClient.duplicate();
-    const subClient = this.redisClient.duplicate();
-
-    return { pubClient, subClient };
-  }
-
-  get adapter(): ReturnType<typeof createAdapter> {
-    return this.redisAdapter;
-  }
-
-
   // 방 생성
   async createRoom(roomId: string, hostId: string) {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (roomExists) return false;
 
     // roomId: hostId 로, room 에 hostId 지정
-    await this.redisRepository.createNewRoom(roomId, hostId);
+    await this.roomRepository.createNewRoom(roomId, hostId);
     console.log(`${hostId} 가 room: ${roomId} 을 만들었습니다.`);
     return true;
   }
 
   // 방 삭제
   async deleteRoom(roomId: string) {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
-    await this.redisRepository.deleteRoom(roomId);
+    await this.roomRepository.deleteRoom(roomId);
   }
 
   async addQuestion(roomId: string, question: Omit<QuestionDto, 'questionId'>){
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
 
-    return await this.redisRepository.addQuestionToRoom(roomId, question);
+    return await this.roomRepository.addQuestionToRoom(roomId, question);
   }
 
   // 질문 추가
   async addQuestionAndReturnQuestion(
     roomId: string,
     question: Omit<QuestionDto, 'questionId'>,
   ): Promise<QuestionDto> {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
 
-    return await this.redisRepository.addQuestionToRoom(roomId, question);
+    return await this.roomRepository.addQuestionToRoom(roomId, question);
   }
 
   // 특정 질문 완료 처리
   async markQuestionAsDone(roomId: string, questionId: number) {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
 
-    const markedQuestion = await this.redisRepository.markQuestionAsDone(roomId, questionId);
+    const markedQuestion = await this.roomRepository.markQuestionAsDone(roomId, questionId);
     if (!markedQuestion) throw new ChatException(CHATTING_SOCKET_ERROR.QUESTION_EMPTY, roomId);
     return markedQuestion;
   }
 
   // 방에 속한 모든 질문 조회
   async getQuestions(roomId: string): Promise<QuestionDto[]> {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
 
-    return this.redisRepository.getQuestionsAll(roomId);
+    return this.roomRepository.getQuestionsAll(roomId);
   }
 
   async getQuestionsNotDone(roomId: string): Promise<QuestionDto[]> {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
 
-    return this.redisRepository.getQuestionsUnmarked(roomId);
+    return this.roomRepository.getQuestionsUnmarked(roomId);
   }
 
   // 특정 질문 조회
   async getQuestion(roomId: string, questionId: number): Promise<QuestionDto> {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
-    return this.redisRepository.getQuestion(roomId, questionId);
+    return this.roomRepository.getQuestion(roomId, questionId);
   }
 
   // 유저 생성
-  async createUser(socket: Socket) {
+  async addUser(socket: Socket) {
     const clientId = socket.id;
     const address = socket.handshake.address.replaceAll('::ffff:', '');
     const userAgent = socket.handshake.headers['user-agent'];
 
     if(!address || !userAgent) throw new ChatException(CHATTING_SOCKET_ERROR.INVALID_USER);
 
-    const newUser = createRandomUserInstance(address, userAgent);
-    const isCreatedDone = await this.redisRepository.createUser(clientId, newUser);
+    const newUser = this.userFactory.createUserInstance(address, userAgent);
+    const isCreatedDone = await this.roomRepository.createUser(clientId, newUser);
     if(!isCreatedDone) throw new ChatException(CHATTING_SOCKET_ERROR.INVALID_USER);
     console.log(newUser);
     return newUser;
   }
 
   // 유저 삭제
   async deleteUser(clientId: string) {
-    return await this.redisRepository.deleteUser(clientId);
+    return await this.roomRepository.deleteUser(clientId);
   }
 
   // 특정 유저 조회
   async getUserByClientId(clientId: string) {
-    const user = this.redisRepository.getUser(clientId);
+    const user = this.roomRepository.getUser(clientId);
     return user;
   }
 
   async getHostOfRoom(roomId: string) {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) throw new ChatException(CHATTING_SOCKET_ERROR.ROOM_EMPTY, roomId);
-    return await this.redisRepository.getHost(roomId);
+    return await this.roomRepository.getHost(roomId);
   }
 
   async getUserBlacklist(roomId: string, address: string) {
-    const roomExists = await this.redisRepository.isRoomExisted(roomId);
+    const roomExists = await this.roomRepository.isRoomExisted(roomId);
     if (!roomExists) return [];
 
-    return await this.redisRepository.getUserBlacklist(roomId, address);
+    return await this.roomRepository.getUserBlacklist(roomId, address);
   }
 
   async addUserToBlacklist(roomId: string, address: string, userAgent: string){
-    return await this.redisRepository.addUserBlacklistToRoom(roomId, address, userAgent);
+    return await this.roomRepository.addUserBlacklistToRoom(roomId, address, userAgent);
   }
 }