vani-meeting-server 2.9.1 → 2.9.2

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

@@ -1,6 +1,7 @@
 import { RedisClientType } from "redis";
 import { MessagePayload } from "../../models/MessagePayload";
 import { Participant } from "../../models/Participant";
+import { SyncLocalEvent } from "../../websocket/EachSocketConnectionHandler";
 export declare enum RedisKeyType {
     Messages = "messages",
     MeetingTime = "meetingTime",
@@ -13,6 +14,7 @@ export declare class RedisHandler {
     private localCacheDataStorage;
     redisPublisher: RedisClientType;
     redisSubscriber: RedisClientType;
+    private localEventUpdateRedisSubsciption?;
     static getInstance(): RedisHandler;
     init(): void;
     isRedisConnected: () => Promise<boolean>;
@@ -22,6 +24,8 @@ export declare class RedisHandler {
     private deleteKeyValueForLocalCache;
     private getKeyValueForLocalCache;
     private storeKeyValueForLocalCache;
+    storeKeyValueForLocalCacheFromOtherServer: (data: SyncLocalEvent) => Promise<void>;
+    protected redisBroadcastMessageToTopic: (topic: string, data: SyncLocalEvent) => Promise<void>;
     setIpForRoomId(roomId: string, ipAddress: string): Promise<void>;
     fetchIpsForRoomId(roomId: string): Promise<{
         ip: string;

package/lib/lib/redis/RedisHandler.js

@@ -9,6 +9,7 @@ const Participant_1 = require("../../models/Participant");
 const ServerHandler_1 = require("../../ServerHandler");
 const Constant_1 = __importDefault(require("../../utility/Constant"));
 const WebSocketServerStartRequest_1 = require("../../models/WebSocketServerStartRequest");
+const EachSocketConnectionHandler_1 = require("../../websocket/EachSocketConnectionHandler");
 var RedisKeyType;
 (function (RedisKeyType) {
     RedisKeyType["Messages"] = "messages";
@@ -22,6 +23,7 @@ class RedisHandler {
     localCacheDataStorage = new Map;
     redisPublisher;
     redisSubscriber;
+    localEventUpdateRedisSubsciption;
     static getInstance() {
         if (!this.redisHandler) {
             this.redisHandler = new RedisHandler();
@@ -65,13 +67,44 @@ class RedisHandler {
                 console.log('Unknown exception occurred at Redis', err);
             });
             this.redisClient.on('ready', () => console.log('client is ready'));
-            this.redisSubscriber.on("connect", (data) => {
+            this.redisSubscriber.on("connect", async (data) => {
                 console.info(' redisSubscriber Redis has been connected successfully.', data);
+                try {
+                    if (this.localEventUpdateRedisSubsciption) {
+                        RedisHandler.getInstance().redisSubscriber.unsubscribe(this.localEventUpdateRedisSubsciption.topic, this.localEventUpdateRedisSubsciption.listener);
+                        this.localEventUpdateRedisSubsciption = undefined;
+                    }
+                    const listener = (data) => {
+                        // this.onRedisMessage(JSON.parse(data))
+                        const parsedData = JSON.parse(data);
+                        this.storeKeyValueForLocalCacheFromOtherServer(parsedData);
+                    };
+                    await RedisHandler.getInstance().redisSubscriber.subscribe(EachSocketConnectionHandler_1.MultiSystemEvents.SyncLocalEvent, listener);
+                    this.localEventUpdateRedisSubsciption = { listener: listener, topic: EachSocketConnectionHandler_1.MultiSystemEvents.SyncLocalEvent };
+                }
+                catch (err) {
+                }
             });
             this.redisSubscriber.on('end', (err) => {
+                try {
+                    if (this.localEventUpdateRedisSubsciption) {
+                        RedisHandler.getInstance().redisSubscriber.unsubscribe(this.localEventUpdateRedisSubsciption.topic, this.localEventUpdateRedisSubsciption.listener);
+                        this.localEventUpdateRedisSubsciption = undefined;
+                    }
+                }
+                catch (err) {
+                }
                 console.log('redisSubscriber Redis connection has been closed.', err);
             });
             this.redisSubscriber.on('error', (err) => {
+                try {
+                    if (this.localEventUpdateRedisSubsciption) {
+                        RedisHandler.getInstance().redisSubscriber.unsubscribe(this.localEventUpdateRedisSubsciption.topic, this.localEventUpdateRedisSubsciption.listener);
+                        this.localEventUpdateRedisSubsciption = undefined;
+                    }
+                }
+                catch (err) {
+                }
                 console.log('redisSubscriber Unknown exception occurred at Redis', err);
             });
             this.redisSubscriber.on('ready', () => console.log('redisSubscriber client is ready'));
@@ -137,14 +170,44 @@ class RedisHandler {
         }
         return undefined;
     };
-    storeKeyValueForLocalCache = (key, fieldOne, fieldTwo) => {
+    storeKeyValueForLocalCache = async (key, fieldOne, fieldTwo) => {
         let keyData = this.localCacheDataStorage.get(key);
         if (!keyData) {
             keyData = new Map();
             this.localCacheDataStorage.set(key, keyData);
         }
+        try {
+            await this.redisBroadcastMessageToTopic(EachSocketConnectionHandler_1.MultiSystemEvents.SyncLocalEvent, { senderIp: (await Constant_1.default.getPublicIp()).toString(), data: { key: key, fieldOne: fieldOne, fieldTwo: fieldTwo }, interfaceName: 'SyncLocalEvent', type: EachSocketConnectionHandler_1.MultiSystemEvents.SyncLocalEvent });
+        }
+        catch (err) {
+        }
         keyData.set(fieldOne, fieldTwo);
     };
+    storeKeyValueForLocalCacheFromOtherServer = async (data) => {
+        try {
+            ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None
+                && console.log("storeKeyValueForLocalCacheFromOtherServer recived ", data);
+            if (data.senderIp !== await Constant_1.default.getPublicIp()) {
+                const key = data.data?.key;
+                const fieldOne = data.data?.fieldOne;
+                const fieldTwo = data.data?.fieldTwo;
+                if (key) {
+                    let keyData = this.localCacheDataStorage.get(key);
+                    if (keyData && fieldOne && fieldTwo) {
+                        keyData.set(fieldOne, fieldTwo);
+                        ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None
+                            && console.log("storeKeyValueForLocalCacheFromOtherServer set ", keyData);
+                    }
+                }
+            }
+        }
+        catch (err) {
+        }
+    };
+    redisBroadcastMessageToTopic = async (topic, data) => {
+        const stringifyData = JSON.stringify(data);
+        RedisHandler.getInstance().redisPublisher.publish(topic, stringifyData);
+    };
     async setIpForRoomId(roomId, ipAddress) {
         try {
             const oldIps = await this.fetchIpsForRoomId(roomId);
@@ -154,7 +217,7 @@ class RedisHandler {
                 return;
             }
             oldIps.push({ ip: ipAddress, port: ServerHandler_1.ServerHandler.getInstance().serverStartRequest.port });
-            this.storeKeyValueForLocalCache(roomId, RedisKeyType.IpAddress, JSON.stringify(oldIps));
+            await this.storeKeyValueForLocalCache(roomId, RedisKeyType.IpAddress, JSON.stringify(oldIps));
             /*await*/ this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(oldIps));
             this.updateRoomCleanupTimeOut(roomId);
             // await this.fetchIpsForRoomId(roomId)
@@ -188,7 +251,7 @@ class RedisHandler {
         try {
             const oldIps = await this.fetchIpsForRoomId(roomId);
             const newIps = oldIps.filter((eachOldIp) => !(eachOldIp.ip === ipAddress && eachOldIp.port === ServerHandler_1.ServerHandler.getInstance().serverStartRequest.port));
-            this.storeKeyValueForLocalCache(roomId, RedisKeyType.IpAddress, JSON.stringify(newIps));
+            await this.storeKeyValueForLocalCache(roomId, RedisKeyType.IpAddress, JSON.stringify(newIps));
             /*await*/ this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(newIps));
             this.updateRoomCleanupTimeOut(roomId);
         }
@@ -228,7 +291,7 @@ class RedisHandler {
     //Meeting Time
     async storeMeetingTimeForRoom(roomId, time) {
         try {
-            this.storeKeyValueForLocalCache(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
+            await this.storeKeyValueForLocalCache(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
             /*await*/ this.redisClient.hSet(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
             this.updateRoomCleanupTimeOut(roomId);
         }
@@ -277,7 +340,7 @@ class RedisHandler {
             if (!participant.serverIpAddress) {
                 participant.serverIpAddress = await Constant_1.default.getPublicIp();
             }
-            this.storeKeyValueForLocalCache(roomId, participantKey, JSON.stringify(participant));
+            await this.storeKeyValueForLocalCache(roomId, participantKey, JSON.stringify(participant));
             /*await*/ this.redisClient.hSet(roomId, participantKey, JSON.stringify(participant));
             // console.log("addUpdateParticipantForRoom =====" , participantKey)
             // console.log(await this.getAllParticipants(roomId))

package/lib/sfu/SFUEachRoomMutliServerHandler.js

@@ -48,6 +48,9 @@ class SFUEachRoomMutliServerHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket
     onMutiRoomMessage = async (message) => {
         ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("onMutiRoomMessage", message);
         if (message.type === EachSocketConnectionHandler_1.MultiSystemEvents.OnNewServerJoinedForRoom) {
+            if (await Constant_1.default.getPublicIp() === message.data.ip) {
+                return;
+            }
             const pipeTransportAndPort = await this.createPipeTransport(message.data.ip);
             if (pipeTransportAndPort && await Constant_1.default.getPublicIp() !== message.data.ip) {
                 if (!pipeTransportAndPort.transport.tuple.remoteIp) {

package/lib/websocket/EachSocketConnectionHandler.d.ts

@@ -78,7 +78,8 @@ export declare enum MultiSystemEvents {
     OnRemoteConsumerClosed = "OnRemoteConsumerClosed",
     OnConnectPipe = "OnConnectPipe",
     OnPipeConnected = "OnPipeConnected",
-    OnPipeClosed = "OnPipeClosed"
+    OnPipeClosed = "OnPipeClosed",
+    SyncLocalEvent = "SyncLocalEvent"
 }
 export declare enum LocalMessageType {
     OnNewUserJoinedRoom = "onNewUserJoinedRoom",
@@ -86,7 +87,17 @@ export declare enum LocalMessageType {
     SocketMessage = "socketMessage",
     SelfLeftForceFully = "SelfLeftForceFully"
 }
-export type WebSocketEvents = SFUMessageType | WebSocketBasicEvents | LocalMessageType | MultiSystemEvents;
+export type WebSocketEvents = SFUMessageType | WebSocketBasicEvents | LocalMessageType | MultiSystemEvents | SyncLocalEvent;
+export interface SyncLocalEvent {
+    interfaceName: 'SyncLocalEvent';
+    type: MultiSystemEvents;
+    data?: {
+        key: string;
+        fieldOne: any;
+        fieldTwo: any;
+    };
+    senderIp?: string;
+}
 export interface WebSocketMessageBody {
     interfaceName: 'WebSocketMessageBody';
     type: WebSocketEvents;

package/lib/websocket/EachSocketConnectionHandler.js

@@ -101,6 +101,7 @@ var MultiSystemEvents;
     MultiSystemEvents["OnConnectPipe"] = "OnConnectPipe";
     MultiSystemEvents["OnPipeConnected"] = "OnPipeConnected";
     MultiSystemEvents["OnPipeClosed"] = "OnPipeClosed";
+    MultiSystemEvents["SyncLocalEvent"] = "SyncLocalEvent";
 })(MultiSystemEvents || (exports.MultiSystemEvents = MultiSystemEvents = {}));
 var LocalMessageType;
 (function (LocalMessageType) {

package/package.json

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