vani-meeting-server 2.0.7 → 2.0.9

package/lib/lib/redis/RedisHandler.d.ts

@@ -22,6 +22,7 @@ export declare class RedisHandler {
         ip: string;
         port: number;
     }[]>;
+    deleteIpForRoomId(roomId: string, ipAddress: string): Promise<void>;
     storeMesagesForRoom(roomId: string, messagePayload: MessagePayload): Promise<void>;
     fetchMessagesForRoom(roomId: string): Promise<MessagePayload[]>;
     storeMeetingTimeForRoom(roomId: string, time?: number): Promise<void>;

package/lib/lib/redis/RedisHandler.js

@@ -62,6 +62,7 @@ class RedisHandler {
         }
         oldIps.push({ ip: ipAddress, port: ServerHandler_1.ServerHandler.getInstance().serverStartRequest.port });
         await this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(oldIps));
+        this.updateRoomCleanupTimeOut(roomId);
     }
     async fetchIpsForRoomId(roomId) {
         const ipAddress = await this.redisClient.hGet(roomId, RedisKeyType.IpAddress);
@@ -74,6 +75,12 @@ class RedisHandler {
             return [];
         }
     }
+    async deleteIpForRoomId(roomId, ipAddress) {
+        const oldIps = await this.fetchIpsForRoomId(roomId);
+        const newIps = oldIps.filter((eachOldIp) => !(eachOldIp.ip === ipAddress && eachOldIp.port === ServerHandler_1.ServerHandler.getInstance().serverStartRequest.port));
+        await this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(newIps));
+        this.updateRoomCleanupTimeOut(roomId);
+    }
     //Messages
     async storeMesagesForRoom(roomId, messagePayload) {
         const messages = await this.fetchMessagesForRoom(roomId);

package/lib/sfu/SFUEachRoomHandler.d.ts

@@ -46,6 +46,7 @@ export declare class SFUEachRoomHandler extends BaseSFUWebsocket implements SFUE
     private audioObserver?;
     private connectionProtocol;
     private eachRoomMutliserverHandler?;
+    private redisSubscribtionDetails;
     constructor(roomId: string, workers: Worker[], sendWorkerIndex: number, connectionProtocol?: ConnectionProtocol);
     onInit: () => Promise<void>;
     getConnectionProtocolType(): ConnectionProtocol;
@@ -68,5 +69,7 @@ export declare class SFUEachRoomHandler extends BaseSFUWebsocket implements SFUE
     resumeAllBroadcastingConsumers(): Promise<void>;
     startBroadcasting(plainTransportPayload: PlainTransportPayload): Promise<void>;
     private consumeProducerForPlainTransport;
+    private redisSubscribeToTopic;
+    private onRedisMessage;
     cleanUp(): Promise<void>;
 }

package/lib/sfu/SFUEachRoomHandler.js

@@ -49,6 +49,7 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
     audioObserver;
     connectionProtocol = ServerHandler_1.ServerHandler.getInstance().serverStartRequest.connectionProtocol;
     eachRoomMutliserverHandler;
+    redisSubscribtionDetails = [];
     constructor(roomId, workers, sendWorkerIndex, connectionProtocol) {
         super();
         this.roomId = roomId;
@@ -63,6 +64,7 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         this.onInit();
     }
     onInit = async () => {
+        await this.redisSubscribeToTopic(Utility_1.Utility.getTopicForRoomIdAndIp(this.roomId, await Constant_1.default.getPublicIp()));
         await this.setUpForRoomId(this.workers, this.sendWorkerIndex);
         if (this.sendRouter) {
             this.eachRoomMutliserverHandler = new SFUEachRoomMutliServerHandler_1.SFUEachRoomMutliServerHandler(this.roomId, this.sendRouter, this);
@@ -372,6 +374,25 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
             }
         }
     }
+    async redisSubscribeToTopic(topic) {
+        const isListenerAlreadyExist = this.redisSubscribtionDetails.find((eachRedisSubscribtionDetails) => eachRedisSubscribtionDetails.topic === topic);
+        if (!isListenerAlreadyExist) {
+            const listener = (data) => {
+                this.onRedisMessage(JSON.parse(data));
+            };
+            await RedisHandler_1.RedisHandler.getInstance().redisSubscriber.subscribe(topic, listener);
+            this.redisSubscribtionDetails.push({ topic, listener });
+        }
+    }
+    onRedisMessage = async (data) => {
+        if (data.interfaceName === 'MultiSystemEventsBody') {
+            console.log("MultiSystemEventsBody recived ", data);
+            const multiSystemEvent = data;
+            if (multiSystemEvent.roomId === this.roomId) {
+                this.onMutiRoomMessage(multiSystemEvent);
+            }
+        }
+    };
     async cleanUp() {
         console.debug("Clean Up Room Id ", this.roomId);
         const allParticipants = await RedisHandler_1.RedisHandler.getInstance().getAllParticipants(this.roomId);
@@ -388,6 +409,11 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
             EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.emit(Event_1.VaniEvent.OnNewMeetingEnded, this.roomId);
         }
         EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.emit(Event_1.VaniEvent.OnAllParticipantLeftOnServer, this.roomId);
+        RedisHandler_1.RedisHandler.getInstance().deleteIpForRoomId(this.roomId, await Constant_1.default.getPublicIp());
+        this.redisSubscribtionDetails.forEach((eachRedisSubscribtionDetails) => {
+            RedisHandler_1.RedisHandler.getInstance().redisSubscriber.unsubscribe(eachRedisSubscribtionDetails.topic, eachRedisSubscribtionDetails.listener);
+        });
+        this.redisSubscribtionDetails = [];
         this.eachRoomMutliserverHandler?.cleanUp();
         this.eachRoomMutliserverHandler = undefined;
         this.roomPaticipants.forEach((sfuEachRoomUser) => {

package/lib/sfu/SFUEachRoomMutliServerHandler.js

@@ -49,18 +49,22 @@ class SFUEachRoomMutliServerHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket
         if (message.type === EachSocketConnectionHandler_1.MultiSystemEvents.OnNewServerJoinedForRoom) {
             const pipeTransportAndPort = await this.createPipeTransport(message.data.ip);
             if (pipeTransportAndPort) {
-                await pipeTransportAndPort.transport?.connect({ ip: message.data.ip, port: message.data.port });
-                this.redisBroadcastMessageToTopic(Utility_1.Utility.getTopicForRoomIdAndIp(message.roomId, message.data.ip), this.prepareMutilSystemEvents(EachSocketConnectionHandler_1.MultiSystemEvents.OnConnectPipe, message.roomId, { ip: await Constant_1.default.getPublicIp(), port: pipeTransportAndPort.port }));
+                if (!pipeTransportAndPort.transport.tuple.remoteIp) {
+                    await pipeTransportAndPort.transport?.connect({ ip: message.data.ip, port: message.data.port });
+                    this.redisBroadcastMessageToTopic(Utility_1.Utility.getTopicForRoomIdAndIp(message.roomId, message.data.ip), this.prepareMutilSystemEvents(EachSocketConnectionHandler_1.MultiSystemEvents.OnConnectPipe, message.roomId, { ip: await Constant_1.default.getPublicIp(), port: pipeTransportAndPort.port }));
+                }
             }
         }
         else if (message.type === EachSocketConnectionHandler_1.MultiSystemEvents.OnConnectPipe) {
             const ip = message.data.ip;
             if (this.pipeTransports[ip]) {
-                await this.pipeTransports[ip].transport.connect({ ip: ip, port: message.data.port });
-                this.redisBroadcastMessageToTopic(Utility_1.Utility.getTopicForRoomIdAndIp(message.roomId, message.data.ip), this.prepareMutilSystemEvents(EachSocketConnectionHandler_1.MultiSystemEvents.OnPipeConnected, message.roomId, { ip: await Constant_1.default.getPublicIp() }));
-                this.roomHandlerDataSource.getAllProducerForRoom().forEach(async (eachRoomProducer) => {
-                    await this.consumeProductAndInfrom(this.pipeTransports[ip].transport, ip, eachRoomProducer);
-                });
+                if (!this.pipeTransports[ip].transport.tuple.remoteIp) {
+                    await this.pipeTransports[ip].transport.connect({ ip: ip, port: message.data.port });
+                    this.redisBroadcastMessageToTopic(Utility_1.Utility.getTopicForRoomIdAndIp(message.roomId, message.data.ip), this.prepareMutilSystemEvents(EachSocketConnectionHandler_1.MultiSystemEvents.OnPipeConnected, message.roomId, { ip: await Constant_1.default.getPublicIp() }));
+                    this.roomHandlerDataSource.getAllProducerForRoom().forEach(async (eachRoomProducer) => {
+                        await this.consumeProductAndInfrom(this.pipeTransports[ip].transport, ip, eachRoomProducer);
+                    });
+                }
             }
         }
         else if (message.type === EachSocketConnectionHandler_1.MultiSystemEvents.OnPipeConnected) {
@@ -86,6 +90,7 @@ class SFUEachRoomMutliServerHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket
             }
         }
         else if (message.type === EachSocketConnectionHandler_1.MultiSystemEvents.OnPipeClosed) {
+            console.log("on remote");
             if (message.data.ip) {
                 if (this.pipeTransports[message.data.ip]) {
                     this.pipeTransports[message.data.ip].transport.close();

package/lib/websocket/EachSocketConnectionHandler.js

@@ -274,7 +274,6 @@ class EachSocketConnectionHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         if (this.roomIds.includes(roomId) === false) {
             this.roomIds.push(roomId);
             this.redisSubscribeToTopic(roomId);
-            this.redisSubscribeToTopic(Utility_1.Utility.getTopicForRoomIdAndIp(roomId, await Constant_1.default.getPublicIp()));
         }
         //Send Local Event To Close Old Socket for same User id
         const localEventData = { roomId: roomId, senderUUID: this.uuid, userId: userId };
@@ -407,14 +406,14 @@ class EachSocketConnectionHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
             const socketMessageBody = data;
             this.sendMessageToClient(socketMessageBody);
         }
-        else if (data.interfaceName === 'MultiSystemEventsBody') {
-            console.log("MultiSystemEventsBody recived ", data);
-            const multiSystemEvent = data;
-            const roomSFUHandler = SFUHandler_1.SFUHandler.getInstance().getRoomSFUHandler(multiSystemEvent.roomId);
-            if (roomSFUHandler) {
-                roomSFUHandler.onMutiRoomMessage(multiSystemEvent);
-            }
-        }
+        // else if (data.interfaceName === 'MultiSystemEventsBody') {
+        //     console.log("MultiSystemEventsBody recived ", data)
+        //     const multiSystemEvent: MultiSystemEventsBody = data
+        //     const roomSFUHandler = SFUHandler.getInstance().getRoomSFUHandler(multiSystemEvent.roomId)
+        //     if (roomSFUHandler) {
+        //         roomSFUHandler.onMutiRoomMessage(multiSystemEvent)
+        //     }
+        // }
     }
     async subscribeToRedisMessages() {
         RedisHandler_1.RedisHandler.getInstance().redisSubscriber.on('message', (roomId, messageInString) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vani-meeting-server",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "Vani Meeting Server SDK",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",