udpate

src/controller/basicController.js

@@ -1,10 +1,24 @@
 import { pubClient } from "../connection/redis.js";
-import { EVENT } from "../enum/event.js";
+import { ROLES, CODEMEG, EVENT, FROMTYPE } from "../enum/index.js";
 import { roomController } from "./roomController.js";
 import { syncActionController } from "./syncActionController.js";
+import { logger } from "../core/logger.js";
+import { getSig } from "../core/getSig.js";
 
-export async function basicController(socket) {
-  //   webSyncAction(socket);
-  await roomController(socket);
-  await syncActionController(socket);
+
+export class BasicController {
+  constructor(io,socket,pubClient){
+    this.io = io
+    this.socket = socket
+    this.redisCli = pubClient
+    this.logger = logger
+    this.getSig = getSig
+  }
+
+  isHoster = (role) => {
+    return String(role).toLowerCase() === ROLES.LEADER;
+  };
+  run (){
+
+  }
 }

src/controller/basicsController.js

@@ -0,0 +1,10 @@
+import { pubClient } from "../connection/redis.js";
+import { EVENT } from "../enum/event.js";
+import { roomController } from "./roomController.js";
+import { syncActionController } from "./syncActionController.js";
+
+export async function basicController(socket) {
+  //   webSyncAction(socket);
+  await roomController(socket);
+  await syncActionController(socket);
+}

src/controller/connectController.js

@@ -0,0 +1,25 @@
+import { BasicController } from "./basicController.js";
+
+import { RoomController } from "./room/index.js";
+import { syncActionController } from "./syncActionController.js";
+import { FROMTYPE } from "../enum/index.js";
+
+export class ConnectController extends BasicController {
+  constructor(...args) {
+    super(...args);
+    this.roomController = new RoomController(this.io, this.socket, this.redisCli);
+  }
+  async run() {
+    await this.roomController.run();
+    await syncActionController(this.socket);
+    this.socket.on("disconnect", (reason) => {
+      if (reason === "transport close") {
+        console.log('this.roomController.user.from',this.roomController.user.from)
+        if ([FROMTYPE.MiniAPP].includes(Number(this.roomController.user.from))) {
+          this.roomController.logger.info("主动断开连接");
+          this.roomController.roomAssistant.disconnect();
+        }
+      }
+    });
+  }
+}

src/controller/index.js

@@ -1,18 +1,26 @@
 import { io } from "../core/io.js";
+import { pubClient } from "../connection/redis.js";
+import { ConnectController } from "./connectController.js";
+// import { BasicController } from "./basicController.js";
 
-import { basicController } from "./basicController.js";
-import { errorController } from "./errorController.js";
+// import { errorController } from "./errorController.js";
 
 class mainController {
   constructor(io) {
     this.io = io;
-    this.basicController = basicController.bind(this);
-    this.errorController = errorController.bind(this);
+    // this.basicController = basicController.bind(this);
+    // this.errorController = errorController.bind(this);
   }
   run() {
-    this.io.on("connection", this.basicController);
-    this.io.on("connect_error", this.errorController);
-    this.io.on("error", this.errorController);
+    try {
+      this.io.on("connection", (socket) => new ConnectController(this.io, socket, pubClient).run());
+      // this.io.on("disconnect", (socket) => new DisConnectController(this.io, socket, pubClient).run());
+
+      // this.io.on("connect_error", this.errorController);
+      // this.io.on("error", this.errorController);
+    } catch (error) {
+      console.log("error", error);
+    }
   }
 }
 

src/controller/room/assistant.js

@@ -0,0 +1,209 @@
+// 房间行为助手
+import { EVENT, CODEMEG } from "../../enum/index.js";
+import { updateUser, removeRoomAllUsers, getAllRoomUsers, updateRoomUser } from "../../service/userService.js";
+import { setRoomConfig, getRoomConfig } from "../../service/roomConfigService.js";
+
+export class RoomAssistant {
+  constructor(socket, redis, room) {
+    this.socket = socket;
+    this.redis = redis;
+    this.roomId = null;
+    this.room = room;
+  }
+
+  async prepearRoom(roomSessionId, roomId) {
+    console.log("prepearRoom", roomSessionId, roomId);
+    const uRoomId = await this.redis.get(roomSessionId);
+    const mergeRoomId = uRoomId || roomId;
+    this.roomId = mergeRoomId;
+    await this.redis.set(roomSessionId, mergeRoomId);
+    return Promise.resolve(this.roomId);
+  }
+
+  /**
+   *
+   */
+  kickPersion() {}
+
+  /**
+   * 创建房间  LEADER or assistant 房主或助手
+   * @param {*} roomId
+   * @param {*} userId
+   * @param {*} user
+   */
+
+  async buildRoom(roomId, userId, user) {
+    const hasJoin = await this.redis.HVALS(roomId, userId);
+    if (hasJoin.length === 0) {
+      this.room.logger.info("buildRoom", { roomId });
+      await this.redis.hSet(roomId, userId, JSON.stringify(user));
+    }
+  }
+
+  /**
+   * 关闭房间
+   * @param {*} roomId
+   */
+
+  async removeRoom(roomId) {
+    this.room.logger.info("removeRoom", { roomId });
+    await this.redis.del(roomId);
+  }
+  //   /**
+  //    * 加入房间
+  //    * @param {*} roomId
+  //    * @param {*} userId
+  //    * @param {*} user
+  //    */
+  //   async joinRoom(roomId, userId, user) {
+  //     this.room.logger.info("joinRoom", { roomId });
+  //     try {
+  //       const hasRoom = await this.redis.exists(roomId);
+  //       if (hasRoom) {
+  //         await this.redis.hSet(roomId, userId, JSON.stringify(user));
+  //       } else {
+  //         this.room.logger.info("no room join");
+  //       }
+  //       return Promise.resolve();
+  //     } catch (error) {
+  //       this.room.logger.error(error);
+  //       return Promise.reject(error);
+  //     }
+  //   }
+
+  /**
+   *  加入房间
+   * @param {*} roomId
+   * @param {*} userId
+   * @param {*} user
+   */
+  async joinRoom(roomId, userId, user) {
+    const hasRoom = await this.redis.exists(roomId);
+    const isJoinRoom = await this.redis.hExists(roomId, userId);
+    if (hasRoom) {
+      await this.redis.hSet(roomId, userId, JSON.stringify(user));
+    } else {
+      this.room.logger.error("不存在房间", roomId);
+    }
+    if (!isJoinRoom) {
+      logger.info("加入房间 :", { userId, roomId, user });
+      socket.join(roomId);
+      const AllRoomUsers = await getAllRoomUsers(roomId);
+      const roomConfig = await getRoomConfig(roomId);
+      this.socket.broadcast.emit(EVENT.roomIn, {
+        user,
+        roomsPerson: AllRoomUsers,
+        roomsConfig: roomConfig,
+      });
+    } else {
+      logger.info(`已加入房间 :`, { userId });
+    }
+  }
+
+  /**
+   * 离开房间
+   * @param {*} clientRoom
+   * @param {*} userUniqueId
+   * @param {*} roomUniqueId
+   */
+  async leaveRoom(roomId, userId, user) {
+    this.room.logger.info("离开房间", userId);
+    await this.redis.hDel(roomId, userId);
+    const AllRoomUsers = await getAllRoomUsers(roomId);
+    const roomConfig = await getRoomConfig(roomId);
+    this.socket.broadcast.to(roomId).emit(EVENT.roomOut, {
+      user,
+      roomsPerson: AllRoomUsers,
+      roomsConfig: roomConfig,
+    });
+    this.socket.broadcast.to(roomId).emit(EVENT.someOneLeaveRoom, {
+      user,
+      roomsPerson: AllRoomUsers,
+    });
+    await this.socket.leave(roomId);
+  }
+
+  /**
+   * 房主关闭房间
+   * @param {*} clientRoom
+   * @param {*} userUniqueId
+   * @param {*} roomUniqueId
+   */
+  async closeRoom(roomId, userId, user) {
+    try {
+      this.room.logger.info("房主关闭房间", userId);
+      console.log("isInRoom", this.socket.rooms.has(roomId));
+      this.socket.broadcast.to(roomId).emit(EVENT.roomClose, { code: 3002, msg: CODEMEG[3002] });
+      await removeRoomAllUsers(roomId);
+      this.socket.leave(roomId);
+    } catch (error) {
+      this.room.logger.error("RoomAssistant::closeRoom", error);
+    }
+  }
+
+  /**
+   * 呼叫房间
+   * @param {*} roomId
+   * @param {*} userId
+   * @param {*} user
+   */
+  async startCall(roomId, userId, user) {
+    try {
+      if (!this.room.isHoster(user.role)) {
+        this.room.logger.info("不是房主", JSON.stringify(user));
+        await this.joinRoom(roomId, userId, user, socket);
+      } else {
+        const hasRoom = await this.redis.hVals(roomId);
+        if (hasRoom.length === 0) {
+          this.room.logger.info("房主主动创建房间 :", { roomId, userId });
+          await this.buildRoom(roomId, userId, user);
+        } else {
+          this.room.logger.info("房主已存在房间 :", { roomId, userId });
+        }
+      }
+      user.isInRoom = true;
+      const AllRoomUsers = await getAllRoomUsers(roomId);
+      const roomConfig = await getRoomConfig(roomId);
+      await updateRoomUser(roomId, userId, user);
+      this.room.logger.info("roomId", roomId);
+      this.room.logger.info("AllRoomUsers", AllRoomUsers.length);
+
+      this.socket.emit(EVENT.roomIn, {
+        user,
+        roomsPerson: AllRoomUsers,
+        roomsConfig: roomConfig,
+      });
+      this.socket.broadcast.to(roomId).emit(EVENT.someOneInRoom, {
+        user,
+        roomsPerson: AllRoomUsers,
+      });
+    } catch (error) {
+      this.room.logger.error("assistant::startCall:", error);
+    }
+  }
+
+  /**
+   * 关闭呼叫房间
+   * @param {*} roomId
+   * @param {*} userId
+   * @param {*} user
+   */
+
+  stopCall(roomId, userId, user) {
+    if (!this.room.isHoster(user.role)) {
+      this.leaveRoom(roomId, userId, user);
+    } else {
+      this.closeRoom(roomId, userId, user);
+    }
+  }
+  // 主动断开
+  async disconnect() {
+    const syncId = this.room.syncId;
+    const roomId = this.room.roomId;
+    const userId = this.room.userId;
+    this.socket.leave(syncId);
+    this.socket.leave(roomId);
+    await this.redis.del(syncId);
+    await this.redis.del(userId);
+  }
+}

src/controller/room/index.js

@@ -0,0 +1,128 @@
+import { ROLES, CODEMEG, EVENT, FROMTYPE } from "../../enum/index.js";
+import { updateUser, removeRoomAllUsers, getAllRoomUsers, updateRoomUser } from "../../service/userService.js";
+// import { watchRoomService } from "../../service/watchRoomService.js";
+import { setRoomConfig, getRoomConfig } from "../../service/roomConfigService.js";
+
+import { RoomAssistant } from "./assistant.js";
+import { BasicController } from "../basicController.js";
+
+export class RoomController extends BasicController {
+  constructor(...args) {
+    super(...args);
+    this.roomAssistant = new RoomAssistant(this.socket, this.redisCli, this);
+    this.roomId = null;
+    this.sessionId = null;
+    this.userId = null;
+    this.debugger = true;
+    this.user = {
+      sig: null,
+      roomId: null,
+      userId: null,
+      sceneNum: null,
+      isClient: null,
+      role: null,
+      userLimitNum: null,
+      sceneNumber: null,
+      roomType: null,
+      from: null,
+      enableTalk: null,
+    };
+  }
+
+  async run() {
+    this.logger.info("socket conetcted has start!");
+    try {
+      await this.init();
+      this.initBaseAction();
+    } catch (error) {
+      this.logger.error("roomController::run::error", error);
+    }
+  }
+
+  async init() {
+    let user = this.socket.handshake.query;
+    if (user) {
+      this.user = Object.assign({}, user, {
+        roomType: user.roomType || "",
+      });
+      this.user.sig = this.getSig(this.user.userId);
+      const oneSceneNum = this.user.sceneNumber || this.user.sceneNum;
+      const { userId, roomId } = this.user;
+      await this.initParams(userId, roomId, oneSceneNum);
+      const userObj = { ...this.user, isConnected: true };
+      updateUser(this.userId, userObj);
+
+      // 只有来源于小程序用户信息才记录到redis
+      if (this.isHoster(this.user.role)) {
+        if ([FROMTYPE.MiniAPP].includes(Number(this.user.from))) {
+          await setRoomConfig(this.roomId, {
+            userLimitNum: this.user.userLimitNum,
+            enableTalk: this.user.enableTalk === "true" ? true : false,
+          });
+        }
+      }
+
+      // 加入
+      this.socket.join(this.roomId);
+    } else {
+      this.logger.info("user-query-不存在 :", this.socket.handshake.query);
+      this.socket.disconnect();
+    }
+  }
+
+  async initParams(userId, roomId, oneSceneNum) {
+    this.userId = `user-${userId}`;
+    this.syncId = `sync-${oneSceneNum}-${userId}`;
+    this.sessionId = `${oneSceneNum}-${userId}`;
+    const uRoomId = await this.roomAssistant.prepearRoom(this.sessionId, roomId);
+    this.roomId = `room-${uRoomId}_${oneSceneNum}_web`;
+  }
+
+  initBaseAction() {
+    // 通知 baseView 减少大量通知
+    this.socket.on(EVENT.webSyncAction, (data) => {
+      // socket.broadcast.to(roomUniqueId).emit(EVENT.webSyncAction, data);
+      try {
+        if ([FROMTYPE.base].includes(Number(this.user.from))) {
+            this.socket.broadcast.to(this.roomId).emit(EVENT.webSyncAction, data);
+          }
+      } catch (error) {
+          this.logger.error('roomController::EVENT.webSyncAction',error)
+      }
+    
+    });
+    // 转发action
+    this.socket.on(EVENT.action, (data) => {
+      try {
+        this.logger.debug("room-action", this.roomId, this.socket.rooms.has(this.roomId), JSON.stringify(data));
+        if (this.socket.rooms.has(this.roomId)) {
+          this.socket.broadcast.to(this.roomId).emit(EVENT.action, data);
+        } else {
+          this.logger.error("action 事件不在房间内", this.user);
+        }
+      } catch (error) {
+          this.logger.error('roomController::EVENT.action',error)
+      }
+    });
+
+    this.socket.on(EVENT.startCall, () => {
+      this.roomAssistant.startCall(this.roomId, this.userId, this.user);
+    });
+    this.socket.on(EVENT.stopCall, () => {
+      this.roomAssistant.stopCall(this.roomId, this.userId, this.user);
+    });
+
+    if (this.debugger) {
+      this.socket.onAny((event, data) => {
+        if (event !== "webSyncAction") {
+          console.log(`onAny：get ${event}, data:${JSON.stringify(data)}`);
+        }
+      });
+    }
+  }
+
+  roomMasterAutoRejoin(){
+      
+  }
+  
+}

src/controller/roomAssistantController.js

@@ -5,18 +5,16 @@ import { pubClient } from "../connection/redis.js";
 export class RoomAssistantController{
     constructor(socket){
         this.socket = socket;
-        this.roomId = mergeRoomId
+        this.roomId = null
     }
 
     async prepearRoom(roomSessionId,roomId){
         console.log('prepearRoom',roomSessionId,roomId);
         const uRoomId = await pubClient.get(roomSessionId)
-        console.log('uRoomId',uRoomId)
         const mergeRoomId = uRoomId || roomId
-        console.log('mergeRoomId',mergeRoomId)
         this.roomId = mergeRoomId
         await pubClient.set(roomSessionId,mergeRoomId)
-        return Promise.resolve(roomId)
+        return Promise.resolve(this.roomId)
     }
 
 }

src/controller/roomController.js

@@ -10,122 +10,129 @@ import { isHoster, buildRoom, startCallAction, stopCallAction, joinRoomAction, l
 import { RoomAssistantController } from './roomAssistantController.js'
 
 export async function roomController(socket) {
-  let user = socket.handshake.query;
-  // const roomAssistant = new RoomAssistantController(socket)
-  const { roomId, userId, sceneNum, isClient, role, userLimitNum, sceneNumber, roomType, from, enableTalk } = user;
-  if (user) {
-    const oneSceneNum = sceneNumber || sceneNum;
-    const syncId = `sync-${oneSceneNum}-${userId}`;
-    const roomSessionId  = `${oneSceneNum}-${userId}`;
-    console.log('roomSessionId', roomSessionId);
-    const userUniqueId = `user-${userId}`;
-    const uRoomId = await roomAssistant.prepearRoom(roomSessionId,roomId);
-    const roomUniqueId = `room-${roomId}_${oneSceneNum}_web`;
-    console.log('roomUniqueId',uRoomId)
-
-    // const userLimitNum = userLimitNum || process.env.US
-    if ("roomId" in user && "userId" in user) {
-      user.sig = getSig(userId);
-      const userObj = { ...user, isConnected: true, roomType: roomType || "" };
-
-      updateUser(userUniqueId, userObj);
-      // await pubClient.hSet(userUniqueId, user);
-      // await pubClient.expire(userUniqueId, 60 * 60 * 24);
-      if (isHoster(role)) {
-        if ([FROMTYPE.MiniAPP].includes(Number(from))) {
-          await setRoomConfig(roomUniqueId, {
-            userLimitNum,
-            enableTalk: enableTalk === "true" ? true : false,
-          });
+  try {
+    let user = socket.handshake.query;
+    const roomAssistant = new RoomAssistantController(socket)
+    const { roomId, userId, sceneNum, isClient, role, userLimitNum, sceneNumber, roomType, from, enableTalk } = user;
+    if (user) {
+      const oneSceneNum = sceneNumber || sceneNum;
+      const syncId = `sync-${oneSceneNum}-${userId}`;
+      const roomSessionId  = `${oneSceneNum}-${userId}`;
+      console.log('roomSessionId', roomSessionId);
+      const userUniqueId = `user-${userId}`;
+      const uRoomId = await roomAssistant.prepearRoom(roomSessionId,roomId);
+      const roomUniqueId = `room-${uRoomId}_${oneSceneNum}_web`;
+      console.log('roomUniqueId',roomUniqueId)
+  
+      // const userLimitNum = userLimitNum || process.env.US
+      if ("roomId" in user && "userId" in user) {
+        user.sig = getSig(userId);
+        const userObj = { ...user, isConnected: true, roomType: roomType || "" };
+  
+        updateUser(userUniqueId, userObj);
+        // await pubClient.hSet(userUniqueId, user);
+        // await pubClient.expire(userUniqueId, 60 * 60 * 24);
+        if (isHoster(role)) {
+          if ([FROMTYPE.MiniAPP].includes(Number(from))) {
+            await setRoomConfig(roomUniqueId, {
+              userLimitNum,
+              enableTalk: enableTalk === "true" ? true : false,
+            });
+          }
         }
-      }
-      socket.join(roomUniqueId);
-    } else {
-      logger.info("user-query-不存在 :", socket.handshake.query);
-      // socket.disconnect();
-    }
-
-    socket.on(EVENT.action, (data) => {
-      console.log("room-action", roomUniqueId, socket.rooms.has(roomUniqueId), JSON.stringify(data));
-      if (socket.rooms.has(roomUniqueId)) {
-        socket.broadcast.to(roomUniqueId).emit(EVENT.action, data);
+        socket.join(roomUniqueId);
       } else {
-        logger.error("action 事件不在房间内", user);
-      }
-    });
-
-    // 通知 baseView 减少大量通知
-    socket.on(EVENT.webSyncAction, (data) => {
-      // socket.broadcast.to(roomUniqueId).emit(EVENT.webSyncAction, data);
-      if ([FROMTYPE.base].includes(Number(from))) {
-        socket.broadcast.to(roomUniqueId).emit(EVENT.webSyncAction, data);
+        logger.info("user-query-不存在 :", socket.handshake.query);
+        socket.disconnect();
       }
-    });
-
-    socket.onAny((event, data) => {
-      if (event !== "webSyncAction") {
-        console.log(`onAny：get ${event}, data:${JSON.stringify(data)}`);
-      }
-    });
-
-    // test
-    socket.on(EVENT.changeRoomEnableTalk, async (data) => {
-      // this._roomsConfig[roomId].enableTalk = data;
-      await setRoomConfig(roomUniqueId, data);
-      const roomConfig = await getRoomConfig(roomUniqueId);
-      socket.broadcast.to(roomUniqueId).emit(EVENT.changeRoomEnableTalk, roomConfig);
-    });
-
-    socket.on(EVENT.changeOnlineStatus, async (data) => {
-      user.onlineStatus = data.status;
-      const AllRoomUsers = await getAllRoomUsers(roomUniqueId);
-      await updateRoomUser(roomUniqueId, userUniqueId, user);
-      let actionName = user.onlineStatus ? "inRoom" : "leaveRoom";
-      logger.info("changeOnlineStatus", user);
-      socket.broadcast.to(roomUniqueId).emit(EVENT.roomPersonChange, {
-        roomsPerson: AllRoomUsers,
-        actionName,
-        user,
+  
+      socket.on(EVENT.action, (data) => {
+        console.log("room-action", roomUniqueId, socket.rooms.has(roomUniqueId), JSON.stringify(data));
+        if (socket.rooms.has(roomUniqueId)) {
+          socket.broadcast.to(roomUniqueId).emit(EVENT.action, data);
+        } else {
+          logger.error("action 事件不在房间内", user);
+        }
       });
-    });
-
-    socket.on(EVENT.startCall, () => {
-      startCallAction(roomUniqueId, userUniqueId, user, socket);
-    });
-    socket.on(EVENT.stopCall, () => {
-      stopCallAction(roomUniqueId, userUniqueId, user, socket);
-    });
-
-    socket.on("disconnect", async (reason) => {
-      // leaveRoom({ clientRoom, userUniqueId, roomUniqueId, socket });
-      // watchRoomWithMaster(roomUniqueId, socket);
-      console.log("reason", reason);
-      if (reason === "transport close") {
-        // 主动离开
-        shotGunLeaveAction(
-          {
-            syncId,
-            roomId: roomUniqueId,
-            userId: userUniqueId,
-          },
-          socket,
+  
+      // 通知 baseView 减少大量通知
+      socket.on(EVENT.webSyncAction, (data) => {
+        // socket.broadcast.to(roomUniqueId).emit(EVENT.webSyncAction, data);
+        if ([FROMTYPE.base].includes(Number(from))) {
+          socket.broadcast.to(roomUniqueId).emit(EVENT.webSyncAction, data);
+        }
+      });
+  
+      socket.onAny((event, data) => {
+        if (event !== "webSyncAction") {
+          console.log(`onAny：get ${event}, data:${JSON.stringify(data)}`);
+        }
+      });
+  
+    
+      socket.on(EVENT.changeRoomEnableTalk, async (data) => {
+        // this._roomsConfig[roomId].enableTalk = data;
+        await setRoomConfig(roomUniqueId, data);
+        const roomConfig = await getRoomConfig(roomUniqueId);
+        socket.broadcast.to(roomUniqueId).emit(EVENT.changeRoomEnableTalk, roomConfig);
+      });
+  
+      socket.on(EVENT.changeOnlineStatus, async (data) => {
+        user.onlineStatus = data.status;
+        const AllRoomUsers = await getAllRoomUsers(roomUniqueId);
+        await updateRoomUser(roomUniqueId, userUniqueId, user);
+        let actionName = user.onlineStatus ? "inRoom" : "leaveRoom";
+        logger.info("changeOnlineStatus", user);
+        socket.broadcast.to(roomUniqueId).emit(EVENT.roomPersonChange, {
+          roomsPerson: AllRoomUsers,
+          actionName,
           user,
-        );
-      } else {
-        // 被动离开
-        // disconnectAction(
-        //   {
-        //     syncId,
-        //     roomId: roomUniqueId,
-        //     userId: userUniqueId,
-        //   },
-        //   socket,
-        //   user,
-        // );
-      }
-    });
-    socket.on("reconnect", () => {
-      console.log("reconnect");
-    });
+        });
+      });
+  
+      socket.on(EVENT.startCall, () => {
+        startCallAction(roomUniqueId, userUniqueId, user, socket);
+      });
+      socket.on(EVENT.stopCall, () => {
+        stopCallAction(roomUniqueId, userUniqueId, user, socket);
+      });
+  
+      socket.on("disconnect", async (reason) => {
+        // leaveRoom({ clientRoom, userUniqueId, roomUniqueId, socket });
+        // watchRoomWithMaster(roomUniqueId, socket);
+        console.log("reason", reason);
+        if (reason === "transport close") {
+          // 主动离开
+          shotGunLeaveAction(
+            {
+              syncId,
+              roomId: roomUniqueId,
+              userId: userUniqueId,
+            },
+            socket,
+            user,
+          );
+        } else {
+          // 被动离开
+          // disconnectAction(
+          //   {
+          //     syncId,
+          //     roomId: roomUniqueId,
+          //     userId: userUniqueId,
+          //   },
+          //   socket,
+          //   user,
+          // );
+        }
+      });
+      socket.on("reconnect", () => {
+        console.log("reconnect");
+      });
+    }
+    
+  } catch (error) {
+    console.log('roomController::error',error)
+    
   }
+ 
 }

src/core/cluster.js

@@ -49,10 +49,16 @@ export class CoreCluster {
       logger.debug(`Worker ${process.pid} started`);
       // use the cluster adapter
       io.adapter(createAdapter());
-
-      // setup connection with the primary process
-      controller.run();
+     
+      io.ready().then(()=>{
+        controller.run();
+        // setupWorker(io);
+      })
       setupWorker(io);
+      // controller.run();
+      // setup connection with the primary process
+  
+      
     }
   }
 }

src/core/io.js

@@ -6,6 +6,7 @@ import { createAdapter } from "@socket.io/redis-adapter";
 import { pubClient, subClient } from "../connection/redis.js";
 import { logger } from "./logger.js";
 import customParser from "socket.io-msgpack-parser";
+
 // import { PrometheusSocketIo }  from 'socket.io-prometheus-v3';
 
 console.log("process.env.SOCKET_PATH", process.env.SOCKET_PATH);
@@ -38,14 +39,28 @@ instrument(io, {
 //   collectDefaultMetrics: false // Collect some Node.js-specific metrics.
 // })
 // console.log('prometheus',prometheus)
-
-Promise.all([pubClient.connect(), subClient.connect()])
-  .then(() => {
-    io.adapter(createAdapter(pubClient, subClient));
-    logger.info("redis is conetcted");
+Server.prototype.ready = function(){
+  return new Promise((resolve,reject)=>{
+    Promise.all([pubClient.connect(), subClient.connect()])
+    .then(() => {
+      io.adapter(createAdapter(pubClient, subClient));
+      logger.info("redis is conetcted");
+      resolve(true);
+    })
+    .catch((error) => {
+      reject(error);
+      logger.error("redis is connect fail", error);
+    });
   })
-  .catch((error) => {
-    logger.error("redis is connect fail", error);
-  });
+}
+// Promise.all([pubClient.connect(), subClient.connect()])
+//     .then(() => {
+//       io.adapter(createAdapter(pubClient, subClient));
+//       logger.info("redis is conetcted");
+
+//     })
+//     .catch((error) => {
+//       logger.error("redis is connect fail", error);
+//     });
 
 export { io };