refactor: red lock 제거 후 redis 낙관적 락 적용

Author: ezcolin2

apps/backend/src/app.module.ts

@@ -20,7 +20,6 @@ import { WorkspaceModule } from './workspace/workspace.module';
 import { RoleModule } from './role/role.module';
 import { TasksModule } from './tasks/tasks.module';
 import { ScheduleModule } from '@nestjs/schedule';
-import { RedLockModule } from './red-lock/red-lock.module';
 
 @Module({
   imports: [
@@ -54,7 +53,6 @@ import { RedLockModule } from './red-lock/red-lock.module';
     WorkspaceModule,
     RoleModule,
     TasksModule,
-    RedLockModule,
   ],
   controllers: [AppController],
   providers: [AppService],

apps/backend/src/page/page.module.ts

@@ -6,14 +6,12 @@ import { Page } from './page.entity';
 import { PageRepository } from './page.repository';
 import { NodeModule } from '../node/node.module';
 import { WorkspaceModule } from '../workspace/workspace.module';
-import { RedLockModule } from '../red-lock/red-lock.module';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([Page]),
     forwardRef(() => NodeModule),
     WorkspaceModule,
-    RedLockModule,
   ],
   controllers: [PageController],
   providers: [PageService, PageRepository],

apps/backend/src/page/page.service.ts

@@ -8,7 +8,6 @@ import { UpdatePageDto } from './dtos/updatePage.dto';
 import { UpdatePartialPageDto } from './dtos/updatePartialPage.dto';
 import { PageNotFoundException } from '../exception/page.exception';
 import { WorkspaceNotFoundException } from '../exception/workspace.exception';
-import Redlock from 'redlock';
 
 const RED_LOCK_TOKEN = 'RED_LOCK';
 
@@ -18,20 +17,13 @@ export class PageService {
     private readonly pageRepository: PageRepository,
     private readonly nodeRepository: NodeRepository,
     private readonly workspaceRepository: WorkspaceRepository,
-    @Inject(RED_LOCK_TOKEN) private readonly redisLock: Redlock,
   ) {}
   /**
    * redis에 저장된 페이지 정보를 다음 과정을 통해 주기적으로 데이터베이스에 반영한다.
    *
    * 1. redis에서 해당 페이지의 title과 content를 가져온다.
    * 2. 데이터베이스에 해당 페이지의 title과 content를 갱신한다.
    * 3. redis에서 해당 페이지 정보를 삭제한다.
-   *
-   * 만약 1번 과정을 진행한 상태에서 page가 삭제된다면 오류가 발생한다.
-   * 위 과정을 진행하는 동안 page 정보 수정을 막기 위해 lock을 사용한다.
-   *
-   * 동기화를 위해 기존 페이지에 접근하여 수정하는 로직은 RedLock 알고리즘을 통해 락을 획득할 수 있을 때만 수행한다.
-   * 기존 페이지에 접근하여 연산하는 로직의 경우 RedLock 알고리즘을 사용하여 동시 접근을 방지한다.
    */
   async createPage(dto: CreatePageDto): Promise<Page> {
     const { title, content, workspaceId, x, y, emoji } = dto;
@@ -62,42 +54,29 @@ export class PageService {
   }
 
   async deletePage(id: number): Promise<void> {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${id.toString()}`], 1000);
-    try {
-      // 페이지를 삭제한다.
-      const deleteResult = await this.pageRepository.delete(id);
-
-      // 만약 삭제된 페이지가 없으면 페이지를 찾지 못한 것
-      if (!deleteResult.affected) {
-        throw new PageNotFoundException();
-      }
-    } finally {
-      // 락을 해제한다.
-      await lock.release();
+    // 페이지를 삭제한다.
+    const deleteResult = await this.pageRepository.delete(id);
+
+    // 만약 삭제된 페이지가 없으면 페이지를 찾지 못한 것
+    if (!deleteResult.affected) {
+      throw new PageNotFoundException();
     }
   }
 
   async updatePage(id: number, dto: UpdatePageDto): Promise<Page> {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${id.toString()}`], 1000);
-    try {
-      // 갱신할 페이지를 조회한다.
-      // 페이지를 조회한다.
-      const page = await this.pageRepository.findOneBy({ id });
-
-      // 페이지가 없으면 NotFound 에러
-      if (!page) {
-        throw new PageNotFoundException();
-      }
-      // 페이지 정보를 갱신한다.
-      const newPage = Object.assign({}, page, dto);
-
-      // 변경된 페이지를 저장
-      return await this.pageRepository.save(newPage);
-    } finally {
-      await lock.release();
+    // 갱신할 페이지를 조회한다.
+    // 페이지를 조회한다.
+    const page = await this.pageRepository.findOneBy({ id });
+
+    // 페이지가 없으면 NotFound 에러
+    if (!page) {
+      throw new PageNotFoundException();
     }
+    // 페이지 정보를 갱신한다.
+    const newPage = Object.assign({}, page, dto);
+
+    // 변경된 페이지를 저장
+    return await this.pageRepository.save(newPage);
   }
 
   async updateBulkPage(pages: UpdatePartialPageDto[]) {

apps/backend/src/red-lock/red-lock.module.ts

@@ -1,14 +1,13 @@
-import { Module, forwardRef } from '@nestjs/common';
+import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { RedisService } from './redis.service';
 import Redis from 'ioredis';
-import { RedLockModule } from '../red-lock/red-lock.module';
 
 // 의존성 주입할 때 redis client를 식별할 토큰
 const REDIS_CLIENT_TOKEN = 'REDIS_CLIENT';
 
 @Module({
-  imports: [ConfigModule, forwardRef(() => RedLockModule)], // ConfigModule 추가
+  imports: [ConfigModule], // ConfigModule 추가
   providers: [
     RedisService,
     {

apps/backend/src/redis/redis.module.ts

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { Inject } from '@nestjs/common';
 import Redis from 'ioredis';
-import Redlock from 'redlock';
 const REDIS_CLIENT_TOKEN = 'REDIS_CLIENT';
 const RED_LOCK_TOKEN = 'RED_LOCK';
 
@@ -27,7 +26,6 @@ export type RedisEdge = {
 export class RedisService {
   constructor(
     @Inject(REDIS_CLIENT_TOKEN) private readonly redisClient: Redis,
-    @Inject(RED_LOCK_TOKEN) private readonly redisLock: Redlock,
   ) {}
 
   async getAllKeys(pattern) {
@@ -46,32 +44,14 @@ export class RedisService {
   }
 
   async set(key: string, value: object) {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${key}`], 1000);
-    try {
-      await this.redisClient.hset(key, Object.entries(value));
-    } finally {
-      lock.release();
-    }
+    await this.redisClient.hset(key, Object.entries(value));
   }
 
   async setField(key: string, field: string, value: string) {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${key}`], 1000);
-    try {
-      return await this.redisClient.hset(key, field, value);
-    } finally {
-      lock.release();
-    }
+    return await this.redisClient.hset(key, field, value);
   }
 
   async delete(key: string) {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${key}`], 1000);
-    try {
-      return await this.redisClient.del(key);
-    } finally {
-      lock.release();
-    }
+    return await this.redisClient.del(key);
   }
 }

apps/backend/src/redis/redis.service.ts

@@ -24,7 +24,7 @@ export class TasksService {
     @InjectDataSource() private readonly dataSource: DataSource,
   ) {}
 
-  @Cron(CronExpression.EVERY_10_SECONDS)
+  @Cron(CronExpression.EVERY_30_SECONDS)
   async handleCron() {
     this.logger.log('스케줄러 시작');
     // 시작 시간
@@ -56,6 +56,8 @@ export class TasksService {
   }
 
   async migratePage(key: string) {
+    // 낙관적 락 적용
+    await this.redisClient.watch(key);
     const data = await this.redisClient.hgetall(key);
     const redisData = Object.fromEntries(
       Object.entries(data).map(([field, value]) => [field, value]),
@@ -110,6 +112,8 @@ export class TasksService {
   }
 
   async migrateNode(key: string) {
+    // 낙관적 락 적용
+    await this.redisClient.watch(key);
     const data = await this.redisClient.hgetall(key);
     const redisData = Object.fromEntries(
       Object.entries(data).map(([field, value]) => [field, value]),
@@ -163,6 +167,8 @@ export class TasksService {
   }
 
   async migrateEdge(key: string) {
+    // 낙관적 락 적용
+    await this.redisClient.watch(key);
     const data = await this.redisClient.hgetall(key);
     const redisData = Object.fromEntries(
       Object.entries(data).map(([field, value]) => [field, value]),

apps/backend/src/tasks/tasks.service.ts

@@ -1,14 +1,13 @@
-import { Module, forwardRef } from '@nestjs/common';
+import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { RedisService } from './redis.service';
 import Redis from 'ioredis';
-import { RedLockModule } from '../red-lock/red-lock.module';
 
 // 의존성 주입할 때 redis client를 식별할 토큰
 const REDIS_CLIENT_TOKEN = 'REDIS_CLIENT';
 
 @Module({
-  imports: [ConfigModule, forwardRef(() => RedLockModule)], // ConfigModule 추가
+  imports: [ConfigModule], // ConfigModule 추가
   providers: [
     RedisService,
     {

apps/websocket/src/red-lock/red-lock.module.ts

@@ -1,9 +1,7 @@
 import { Injectable } from '@nestjs/common';
 import { Inject } from '@nestjs/common';
 import Redis from 'ioredis';
-import Redlock from 'redlock';
 const REDIS_CLIENT_TOKEN = 'REDIS_CLIENT';
-const RED_LOCK_TOKEN = 'RED_LOCK';
 
 type RedisPage = {
   title?: string;
@@ -14,7 +12,6 @@ type RedisPage = {
 export class RedisService {
   constructor(
     @Inject(REDIS_CLIENT_TOKEN) private readonly redisClient: Redis,
-    @Inject(RED_LOCK_TOKEN) private readonly redisLock: Redlock,
   ) {}
 
   createStream() {
@@ -29,40 +26,22 @@ export class RedisService {
   }
 
   async set(key: string, value: object) {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${key}`], 1000);
-    try {
-      await this.redisClient.hset(key, Object.entries(value));
-    } finally {
-      lock.release();
-    }
+    await this.redisClient.hset(key, Object.entries(value));
   }
 
   async setFields(key: string, map: Record<string, string>) {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${key}`], 1000);
-    try {
-      // return await this.redisClient.hset(key, );
-      // fieldValueArr 배열을 평탄화하여 [field, value, field, value, ...] 형태로 변환
-      const flattenedFields = Object.entries(map).flatMap(([field, value]) => [
-        field,
-        value,
-      ]);
-
-      // hset을 통해 한 번에 여러 필드를 설정
-      return await this.redisClient.hset(key, ...flattenedFields);
-    } finally {
-      lock.release();
-    }
+    // return await this.redisClient.hset(key, );
+    // fieldValueArr 배열을 평탄화하여 [field, value, field, value, ...] 형태로 변환
+    const flattenedFields = Object.entries(map).flatMap(([field, value]) => [
+      field,
+      value,
+    ]);
+
+    // hset을 통해 한 번에 여러 필드를 설정
+    return await this.redisClient.hset(key, ...flattenedFields);
   }
 
   async delete(key: string) {
-    // 락을 획득할 때까지 기다린다.
-    const lock = await this.redisLock.acquire([`user:${key}`], 1000);
-    try {
-      return await this.redisClient.del(key);
-    } finally {
-      lock.release();
-    }
+    return await this.redisClient.del(key);
   }
 }