chore: merge dev

Author: jin20fd

BE/.dockerignore

@@ -0,0 +1 @@
+node_modules

BE/src/app.module.ts

@@ -1,4 +1,4 @@
-import { MiddlewareConsumer, Module, ValidationPipe } from '@nestjs/common';
+import { MiddlewareConsumer, Module } from '@nestjs/common';
 import { UserModule } from './user/user.module';
 import { ShellModule } from './shell/shell.module';
 import { QueryModule } from './query/query.module';

BE/src/config/query-database/admin-db-manager.service.ts

@@ -13,7 +13,8 @@ export class AdminDBManager implements OnModuleInit {
   constructor(private readonly configService: ConfigService) {}
 
   async onModuleInit() {
-    this.createAdminConnection();
+    // 서버 테스트를 위한 주석처리
+    //this.createAdminConnection();
   }
 
   private createAdminConnection() {

BE/src/config/redis/redis.service.ts

@@ -5,25 +5,39 @@ import { ConfigService } from '@nestjs/config';
 
 @Injectable()
 export class RedisService {
-  private defaultConnection: Redis;
+  private sessionConnection: Redis;
   private eventConnection: Redis;
+  private activeUserConnection: Redis;
+
+  private readonly SESSION_TTL = 60 * 30;
+  private readonly ACTIVE_USER_TTL = 60 * 5;
 
   constructor(
     private readonly adminDBManager: AdminDBManager,
     private readonly configService: ConfigService,
   ) {
-    this.setDefaultConnection();
+    this.setSessionConnection();
     this.setEventConnection();
+    this.setActiveUserConnection();
   }
 
-  private setDefaultConnection() {
-    this.defaultConnection = new Redis({
+  private setSessionConnection() {
+    this.sessionConnection = new Redis({
       host: this.configService.get<string>('REDIS_HOST'),
       port: this.configService.get<number>('REDIS_PORT'),
+      db: this.configService.get<number>('REDIS_DATABASE_SESSION'),
     });
 
-    this.defaultConnection.on('ready', () => {
-      this.defaultConnection.config('SET', 'notify-keyspace-events', 'Exg');
+    this.sessionConnection.on('ready', () => {
+      this.sessionConnection.config('SET', 'notify-keyspace-events', 'Exg');
+    });
+  }
+
+  private setActiveUserConnection() {
+    this.activeUserConnection = new Redis({
+      host: this.configService.get<string>('REDIS_HOST'),
+      port: this.configService.get<number>('REDIS_PORT'),
+      db: this.configService.get<number>('REDIS_DATABASE_ACTIVE_USER'),
     });
   }
 
@@ -42,28 +56,24 @@ export class RedisService {
     if (!key) {
       return null;
     }
-    return this.defaultConnection.hgetall(key);
+    return this.sessionConnection.hgetall(key);
   }
 
   public async existSession(key: string) {
-    return this.defaultConnection.exists(key);
+    return this.sessionConnection.exists(key);
   }
 
   public async setNewSession(key: string) {
     const session = await this.existSession(key);
     if (!session) {
-      await this.defaultConnection.hset(key, 'rowCount', 0);
+      await this.sessionConnection.hset(key, 'rowCount', 0);
       await this.adminDBManager.initUserDatabase(key);
     }
-    await this.setExpireTime(key, 60 * 60);
+    await this.sessionConnection.expire(key, this.SESSION_TTL);
   }
 
   public async deleteSession(key: string) {
-    await this.defaultConnection.del(key);
-  }
-
-  public async setExpireTime(key: string, ttl: number) {
-    await this.defaultConnection.expire(key, ttl);
+    await this.sessionConnection.del(key);
   }
 
   private subscribeToExpiredEvents() {
@@ -75,10 +85,14 @@ export class RedisService {
   }
 
   public async getRowCount(key: string) {
-    return this.defaultConnection.hget(key, 'rowCount');
+    return this.sessionConnection.hget(key, 'rowCount');
   }
 
   public async setRowCount(key: string, rowCount: number) {
-    await this.defaultConnection.hset(key, 'rowCount', rowCount);
+    await this.sessionConnection.hset(key, 'rowCount', rowCount);
+  }
+
+  public async setActiveUser(key: string) {
+    this.activeUserConnection.expire(key, this.ACTIVE_USER_TTL);
   }
 }

BE/src/query/query.service.ts

@@ -6,16 +6,19 @@ import { ResultSetHeader, RowDataPacket } from 'mysql2/promise';
 import { Shell } from '../shell/shell.entity';
 import { UserDBManager } from '../config/query-database/user-db-manager.service';
 import { UsageService } from 'src/usage/usage.service';
+import { RedisService } from '../config/redis/redis.service';
 
 @Injectable()
 export class QueryService {
   constructor(
     private readonly userDBManager: UserDBManager,
     private shellService: ShellService,
     private readonly usageService: UsageService,
+    private readonly redisService: RedisService,
   ) {}
 
   async execute(req: any, shellId: number, queryDto: QueryDto) {
+    this.redisService.setActiveUser(req.sessionID);
     await this.shellService.findShellOrThrow(shellId);
 
     const baseUpdateData = {