update

ecosystem.config.js

@@ -5,7 +5,7 @@ module.exports = {
     {
       name: 'socket-v4-prod',
       exec_mode: 'cluster',
-      instances: 'max',
+      instances: '4',
       script: './dist/main.js',
       args: '',
       env: {

src/room/actions/actions.service.ts

@@ -12,7 +12,7 @@ export class ActionsService {
     private roomService: RoomService,
     @Inject(forwardRef(() => UsersService))
     private userService: UsersService,
-  ) { }
+  ) {}
 
   async handleAllAction(socket: Socket, data: ActionsParams): Promise<void> {
     const isSocketLeader = () => {

src/room/delay/delay.service.ts

@@ -95,6 +95,7 @@ export class DelayService {
   async handleOnine(socket?: Socket): Promise<void> {
     if (socket?.data) {
       const { RoomId, UserId } = socket.data?.user;
+
       if (RoomId && UserId) {
         await this.redis.del(`kankan:socket:delay:${RoomId}:${UserId}`);
       }
@@ -103,9 +104,10 @@ export class DelayService {
 
   async handleOffline(socket?: Socket): Promise<void> {
     if (socket?.data) {
+      const isBenmark = socket.data?.isBenmark;
       const delayTime = 60 * 5;
       const { RoomId, UserId } = socket.data?.user;
-      if (RoomId && UserId) {
+      if (RoomId && UserId && isBenmark !== 1) {
         this.redis.set(
           `kankan:socket:delay:${RoomId}:${UserId}`,
           '',

src/room/room.service.ts

@@ -17,27 +17,16 @@ export class RoomService {
     private readonly actionsService: ActionsService,
     private readonly delayService: DelayService,
     private readonly tempService: TempService,
-  ) {}
+  ) { }
   public readonly logger = new Logger('user');
   public _sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
   public _userInfo = {} as UserInfoType;
-
-  private get _roomId(): string {
-    return this._userInfo.RoomId;
-  }
-  private get _userId(): string {
-    return this._userInfo.UserId;
-  }
-  public get _isLeader(): boolean {
-    return this._userInfo.Role === 'leader';
-  }
-
   /**
    * 初始化当前用户数据
    * @param userInfo
    */
-  initUserProfile(userInfo: UserInfoParams): void {
-    this._userInfo = {
+  initUserProfile(userInfo: UserInfoParams): UserInfoType {
+    const data = {
       id: userInfo.id,
       RoomId: userInfo.roomId,
       Role: userInfo.role,
@@ -53,6 +42,7 @@ export class RoomService {
       InTime: Date.now(),
       IsOnline: true,
     };
+    return data;
   }
   async handleUserOnline(socket: Socket) {
     if (socket.data.user) {
@@ -70,10 +60,9 @@ export class RoomService {
     await this._sleep(500);
     if (socket.data?.user) {
       this.delayService.handleOffline(socket);
-      const { RoomId, UserId } = socket.data.user;
+      const { RoomId, UserId, Role } = socket.data.user;
       if (RoomId && UserId) {
         //标记主动退出房间
-
         if (socket.data.isRequestExit !== 1 && socket.data.isKick !== 1) {
           const roomUsers = await this.userService.getRoomUsers(RoomId);
           this.socketGateway.server.to(RoomId).emit('action', {
@@ -92,6 +81,10 @@ export class RoomService {
         );
         await this.handleRoomStatusAction(socket);
       }
+      // 压测试直接去除信息
+      if (!!socket.data.isBenmark && Role === 'leader') {
+        this.handleRoomDismiss(RoomId);
+      }
     }
   }
 
@@ -104,20 +97,25 @@ export class RoomService {
     socket: Socket,
     userInfo: UserInfoParams,
   ): Promise<void> {
-    this.initUserProfile(userInfo);
-    socket.data.user = this._userInfo;
+    const user = this.initUserProfile(userInfo);
+    this._userInfo = user;
+    socket.data.user = user;
+    socket.data.user.roomConfig = userInfo.roomConfig;
     await this.handleUserOnline(socket);
     await this.delayService.handleOnine(socket);
     let blockJoin = false;
-    const { RoomId, UserId, Role } = socket.data.user;
-
+    const { RoomId, UserId, Role, roomConfig } = socket.data.user;
+    const _isLeader = Role === 'leader';
     if (RoomId?.length && UserId?.length) {
       //房主设置房间配置
-      if (this._isLeader) {
+      if (_isLeader) {
         const isValid = await this.userService.isRoomMaster(RoomId, UserId);
         //检查房主非法性
         if (isValid) {
-          await this.userService.setRoomConfig(RoomId, userInfo.roomConfig);
+          roomConfig.masterId = UserId;
+          this.logger.log(JSON.stringify(userInfo), 'room-config');
+          userInfo.roomConfig &&
+            (await this.userService.setRoomConfig(RoomId, roomConfig));
         } else {
           blockJoin = true;
           socket.emit('manager-error', {
@@ -128,10 +126,7 @@ export class RoomService {
           socket.disconnect(true);
         }
       }
-      const isExist = await this.userService.isUserInRooms(
-        this._roomId,
-        this._userId,
-      );
+      const isExist = await this.userService.isUserInRooms(RoomId, UserId);
       const isMax = await this.userService.isMaxRoom(RoomId);
       // console.log('isMaxRoom', isMax);
       if (isMax && Role !== 'leader' && !isExist) {
@@ -146,9 +141,9 @@ export class RoomService {
 
       if (!blockJoin) {
         if (!isExist) {
-          await this.userService.insertUser(this._userInfo);
+          await this.userService.insertUser(socket.data.user);
         } else {
-          const updated = await this.userService.updateUsers(this._userInfo);
+          const updated = await this.userService.updateUsers(socket.data.user);
           if (!updated) {
             socket.emit('manager-error', {
               type: 'invalid-match-role',
@@ -163,8 +158,8 @@ export class RoomService {
           }
         }
 
-        await this.tempService.init(socket);
-        const roomUsers = await this.userService.getRoomUsers(this._roomId);
+        this.tempService.init(socket);
+        const roomUsers = await this.userService.getRoomUsers(RoomId);
         socket.emit('join', {
           user: socket.data.user,
           members: roomUsers,
@@ -205,7 +200,10 @@ export class RoomService {
    * @param message
    */
   async handleSyncAction(socket: Socket, message: any) {
-    socket.broadcast.to(this._roomId).emit('sync', message);
+    if (socket.data?.user) {
+      const { RoomId } = socket.data?.user;
+      socket.broadcast.to(RoomId).emit('sync', message);
+    }
   }
 
   /**
@@ -213,7 +211,10 @@ export class RoomService {
    * @param message
    */
   async handlePaintAction(socket: Socket, message: any) {
-    socket.broadcast.to(this._roomId).emit('paint', message);
+    if (socket.data?.user) {
+      const { RoomId } = socket.data?.user;
+      socket.broadcast.to(RoomId).emit('paint', message);
+    }
   }
 
   /**

src/room/users/users.service.ts

@@ -10,7 +10,7 @@ export class UsersService {
     @InjectRedis() private readonly redis: Redis,
     @Inject(forwardRef(() => RoomService))
     private roomService: RoomService,
-  ) {}
+  ) { }
 
   async isUserInRooms(RoomId: string, UserId: string): Promise<boolean> {
     const res = await this.redis.hexists(
@@ -113,6 +113,10 @@ export class UsersService {
   ): Promise<void> {
     const isExist = await this.redis.hget(`kankan:socket:roomConfig`, RoomId);
     // console.log('setRoomConfig', isExist);
+    this.roomService.logger.log(
+      `'room setting: ${RoomId},isExist:${isExist} `,
+      'room-config',
+    );
     if (isExist) {
       const config = JSON.parse(isExist);
       const obj = Object.assign({}, config, RoomConfig);

src/socket/socket.gateway.ts

@@ -28,21 +28,28 @@ console.log('SOCKET_PATH', process.env.SOCKET_PATH);
   // parser: require('socket.io-msgpack-parser'),
 })
 export class SocketGateway
-  implements OnGatewayInit, OnGatewayDisconnect, OnGatewayConnection {
+  implements OnGatewayInit, OnGatewayDisconnect, OnGatewayConnection
+{
   constructor(
     @InjectRedis() private readonly redis: Redis,
     private readonly roomService: RoomService,
     private readonly delayService: DelayService,
-  ) { }
+  ) {}
   public readonly logger = new Logger('socketGateway');
   @WebSocketServer() server: Server;
   // public _loginLimit = new Map<string, string>();
 
-  async handleConnection(@ConnectedSocket() socket: Socket, ...args: any[]) {
+  async handleConnection(@ConnectedSocket() socket: Socket) {
+    const { isBenmark } = socket.handshake.query;
+    if (Number(isBenmark) === 1) {
+      socket.data.isBenmark = 1;
+    }
     // this.delayService
   }
   async handleDisconnect(@ConnectedSocket() socket: Socket) {
     const deviceId = socket.data.deviceId;
+    const isBenmark = socket.data.isBenmark;
+
     if (deviceId) {
       const redisFlag = `kankan:socket:deviceId`;
       // const did = this._loginLimit.get(deviceId);
@@ -51,6 +58,10 @@ export class SocketGateway
         await this.redis.hdel(redisFlag, deviceId);
         // this._loginLimit.delete(deviceId);
       }
+      if (!!isBenmark) {
+        // console.log('isBenmark', isBenmark);
+        await this.redis.hdel(redisFlag, deviceId);
+      }
     }
     await this.roomService.handleUserOffline(socket);
     socket.removeAllListeners();