vani-meeting-server 1.0.1 → 1.0.2

package/lib/ServerHandler.d.ts

@@ -0,0 +1,13 @@
+import { RedisHandler } from "./lib/redis/RedisHandler";
+import { WebSocketServerStartRequest } from "./models/WebSocketServerStartRequest";
+import { SFUHandler } from "./sfu/SFUHandler";
+import { WebSocketHandler } from "./websocket/WebSocketHandler";
+export declare class ServerHandler {
+    serverStartRequest: WebSocketServerStartRequest;
+    rediHandler?: RedisHandler;
+    webSocketHandler?: WebSocketHandler;
+    sfuHandler?: SFUHandler;
+    static instance: ServerHandler;
+    static getInstance(): ServerHandler;
+    initWithServerStartRequest(serverStartRequest: WebSocketServerStartRequest): Promise<void>;
+}

package/lib/ServerHandler.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { RedisHandler } from "./lib/redis/RedisHandler";
+import { WebSocketServerStartRequest } from "./models/WebSocketServerStartRequest";
+import { SFUHandler } from "./sfu/SFUHandler";
+import { WebSocketHandler } from "./websocket/WebSocketHandler";
+export class ServerHandler {
+    constructor() {
+        this.serverStartRequest = new WebSocketServerStartRequest();
+    }
+    static getInstance() {
+        return ServerHandler.instance;
+    }
+    initWithServerStartRequest(serverStartRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.serverStartRequest = serverStartRequest;
+            this.rediHandler = RedisHandler.getInstance();
+            yield this.rediHandler.connectDB();
+            yield this.rediHandler.cleanUp();
+            console.info("On Redis Connected");
+            this.webSocketHandler = new WebSocketHandler();
+            this.webSocketHandler.connect();
+            this.sfuHandler = SFUHandler.getInstance();
+            this.sfuHandler.init();
+        });
+    }
+}
+ServerHandler.instance = new ServerHandler();

package/lib/base/BaseSFUWebsocket.d.ts

@@ -0,0 +1,7 @@
+import { Participant } from "../models/Participant";
+import { ClientMessageBody, WebSocketEvents, WebSocketMessageBody } from "../websocket/EachSocketConnectionHandler";
+export declare class BaseSFUWebsocket {
+    protected redisBroadcastMessageToTopic(topic: string, data: WebSocketMessageBody | ClientMessageBody): Promise<void>;
+    protected preapreClientMessageBody(shouldSendToSelf: boolean, senderParticipant: Participant, broadcastMessage: WebSocketMessageBody): ClientMessageBody;
+    protected preapreWebSocketMessageBody(type: WebSocketEvents, data: any): WebSocketMessageBody;
+}

package/lib/base/BaseSFUWebsocket.js

@@ -0,0 +1,24 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { RedisHandler } from "../lib/redis/RedisHandler";
+export class BaseSFUWebsocket {
+    redisBroadcastMessageToTopic(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            RedisHandler.getInstance().redisPublisher.publish(topic, JSON.stringify(data));
+        });
+    }
+    //Utilility function
+    preapreClientMessageBody(shouldSendToSelf, senderParticipant, broadcastMessage) {
+        return { shouldSendToSelf, senderParticipant, broadcastMessage, interfaceName: 'ClientMessageBody' };
+    }
+    preapreWebSocketMessageBody(type, data) {
+        return { type, data, interfaceName: 'WebSocketMessageBody' };
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './models/Event';
+export * from './models/WebSocketServerStartRequest';
+export * from './ServerHandler';

package/lib/index.js

@@ -0,0 +1,3 @@
+export * from './models/Event';
+export * from './models/WebSocketServerStartRequest';
+export * from './ServerHandler';

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

@@ -0,0 +1,28 @@
+import { RedisClientType } from "redis";
+import { MessagePayload } from "../../models/MessagePayload";
+import { Participant } from "../../models/Participant";
+export declare enum RedisKeyType {
+    Messages = "messages",
+    MeetingTime = "meetingTime",
+    Participants = "participants"
+}
+export declare class RedisHandler {
+    private static redisHandler;
+    private redisClient;
+    redisPublisher: RedisClientType;
+    redisSubscriber: RedisClientType;
+    constructor();
+    static getInstance(): RedisHandler;
+    connectDB(): Promise<void>;
+    cleanUp(): Promise<string>;
+    cleanUpRoomId(roomId: string): Promise<void>;
+    storeMesagesForRoom(roomId: string, messagePayload: MessagePayload): Promise<void>;
+    fetchMessagesForRoom(roomId: string): Promise<MessagePayload[]>;
+    storeMeetingTimeForRoom(roomId: string, time?: number): Promise<void>;
+    fetchMeetingTimeForRoom(roomId: string): Promise<number | undefined>;
+    removeParticipantForRoom(roomId: string, participant: Participant): Promise<void>;
+    addUpdateParticipantForRoom(roomId: string, participant: Participant): Promise<void>;
+    getParticipantByUserId(roomId: string, userId: string): Promise<Participant | undefined>;
+    getAllParticipants(roomId: string): Promise<Participant[]>;
+    private updateRoomCleanupTimeOut;
+}

package/lib/lib/redis/RedisHandler.js

@@ -0,0 +1,148 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createClient } from "redis";
+import { Participant } from "../../models/Participant";
+import { ServerHandler } from "../../ServerHandler";
+export var RedisKeyType;
+(function (RedisKeyType) {
+    RedisKeyType["Messages"] = "messages";
+    RedisKeyType["MeetingTime"] = "meetingTime";
+    RedisKeyType["Participants"] = "participants";
+})(RedisKeyType || (RedisKeyType = {}));
+export class RedisHandler {
+    constructor() {
+        this.redisClient = createClient({ url: ServerHandler.getInstance().serverStartRequest.redisUrl, database: ServerHandler.getInstance().serverStartRequest.redisDBIndex });
+        this.redisSubscriber = createClient({ url: ServerHandler.getInstance().serverStartRequest.redisUrl });
+        this.redisPublisher = createClient({ url: ServerHandler.getInstance().serverStartRequest.redisUrl });
+    }
+    static getInstance() {
+        return this.redisHandler;
+    }
+    connectDB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.redisClient.on("connect", (data) => {
+                console.info('Redis has been connected successfully.', data);
+            });
+            this.redisClient.on('end', (err) => {
+                console.error('Redis connection has been closed.', err);
+            });
+            this.redisClient.on('error', (err) => {
+                console.error('Unknown exception occurred at Redis', err);
+            });
+            yield this.redisClient.connect();
+            yield this.redisSubscriber.connect();
+            yield this.redisPublisher.connect();
+            // await this.redisClient.hSet("rooms","123","HSETObject")
+            // console.log(await this.redisClient.hGet("rooms","123"))
+        });
+    }
+    cleanUp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.redisClient.flushDb();
+        });
+    }
+    //Clean Room Id
+    cleanUpRoomId(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redisClient.del(roomId);
+        });
+    }
+    //Messages
+    storeMesagesForRoom(roomId, messagePayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const messages = yield this.fetchMessagesForRoom(roomId);
+            messages.push(messagePayload);
+            yield this.redisClient.hSet(roomId, RedisKeyType.Messages, JSON.stringify(messages));
+            this.updateRoomCleanupTimeOut(roomId);
+        });
+    }
+    fetchMessagesForRoom(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const messages = yield this.redisClient.hGet(roomId, RedisKeyType.Messages);
+            if (messages) {
+                return JSON.parse(messages);
+            }
+            else {
+                return [];
+            }
+        });
+    }
+    //Meeting Time
+    storeMeetingTimeForRoom(roomId, time) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redisClient.hSet(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
+            this.updateRoomCleanupTimeOut(roomId);
+        });
+    }
+    fetchMeetingTimeForRoom(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const meetingTime = yield this.redisClient.hGet(roomId, RedisKeyType.MeetingTime);
+            if (meetingTime) {
+                return +meetingTime;
+            }
+            else {
+                return undefined;
+            }
+        });
+    }
+    //Users
+    removeParticipantForRoom(roomId, participant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const participantKey = RedisKeyType.Participants + ":" + participant.userId;
+            yield this.redisClient.hDel(roomId, participantKey);
+            this.updateRoomCleanupTimeOut(roomId);
+        });
+    }
+    addUpdateParticipantForRoom(roomId, participant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const participantKey = RedisKeyType.Participants + ":" + participant.userId;
+            yield this.redisClient.hSet(roomId, participantKey, JSON.stringify(participant));
+            this.updateRoomCleanupTimeOut(roomId);
+        });
+    }
+    getParticipantByUserId(roomId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const participantKey = RedisKeyType.Participants + ":" + userId;
+            const particpantString = yield this.redisClient.hGet(roomId, participantKey);
+            if (particpantString) {
+                return JSON.parse(particpantString);
+            }
+            return undefined;
+        });
+    }
+    getAllParticipants(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const particpantsInStringify = yield this.redisClient.hGetAll(roomId);
+            const participants = [];
+            if (particpantsInStringify) {
+                Object.entries(particpantsInStringify).forEach(([key, value]) => {
+                    if (key.includes(RedisKeyType.Participants)) {
+                        participants.push(Object.assign(new Participant(), JSON.parse(value)));
+                    }
+                });
+            }
+            return participants;
+        });
+    }
+    // private getRediRoomModelForRoomId(roomId: string): RedisRoomModel {
+    //     if (this.redisRoomModelHash.has(roomId)) {
+    //         return this.redisRoomModelHash.get(roomId)!
+    //     }
+    //     else {
+    //         const redisRoomModel = new RedisRoomModel(roomId)
+    //         this.redisRoomModelHash.set(roomId, redisRoomModel)
+    //         return redisRoomModel
+    //     }
+    // }
+    updateRoomCleanupTimeOut(roomId) {
+        this.redisClient.expire(roomId, ServerHandler.getInstance().serverStartRequest.redisRoomDestoryTimeOutInSec);
+    }
+}
+RedisHandler.redisHandler = new RedisHandler();

package/{src/models/Event.ts → lib/models/Event.d.ts}

@@ -1,36 +1,25 @@
 import { Participant } from "./Participant";
-
-
-export enum VaniEvent {
-
+export declare enum VaniEvent {
     OnNewMeetingStarted = "onNewMeetingStarted",
     OnNewMeetingEnded = "onNewMeetingEnded",
     OnUserJoined = "onUserJoined",
     OnUserLeft = "onUserLeft",
     OnServerStarted = "onServerStarted"
-
-    
 }
-
 interface VaniConnectionEvents {
-    [VaniEvent.OnNewMeetingStarted]: (roomId : string) => any;
-    [VaniEvent.OnNewMeetingEnded]: (roomId : string) => any;
-    [VaniEvent.OnUserJoined]: (participant : Participant) => any;
-    [VaniEvent.OnUserLeft]: (participant : Participant) => any;
+    [VaniEvent.OnNewMeetingStarted]: (roomId: string) => any;
+    [VaniEvent.OnNewMeetingEnded]: (roomId: string) => any;
+    [VaniEvent.OnUserJoined]: (participant: Participant) => any;
+    [VaniEvent.OnUserLeft]: (participant: Participant) => any;
     [VaniEvent.OnServerStarted]: () => any;
-
-    // [VaniEvent.OnSocketError]: (error: any) => any; 
 }
-
 export declare interface VaniEventListener {
     on<U extends keyof VaniConnectionEvents>(event: U, listener: VaniConnectionEvents[U]): this;
     off<U extends keyof VaniConnectionEvents>(event: U, listener: VaniConnectionEvents[U]): this;
     emit<U extends keyof VaniConnectionEvents>(event: U, ...args: Parameters<VaniConnectionEvents[U]>): boolean;
 }
-
-
-
 export interface Device {
-    id: string,
-    label: string
-}
+    id: string;
+    label: string;
+}
+export {};

package/lib/models/Event.js

@@ -0,0 +1,8 @@
+export var VaniEvent;
+(function (VaniEvent) {
+    VaniEvent["OnNewMeetingStarted"] = "onNewMeetingStarted";
+    VaniEvent["OnNewMeetingEnded"] = "onNewMeetingEnded";
+    VaniEvent["OnUserJoined"] = "onUserJoined";
+    VaniEvent["OnUserLeft"] = "onUserLeft";
+    VaniEvent["OnServerStarted"] = "onServerStarted";
+})(VaniEvent || (VaniEvent = {}));

package/lib/models/MessagePayload.d.ts

@@ -0,0 +1,19 @@
+export declare enum ChatMessageType {
+    Chat = "chat",
+    File = "file",
+    Info = "info"
+}
+export declare enum ChatSendVia {
+    WebSocket = "WebSocket",
+    DataChannel = "DataChannel"
+}
+export declare class MessagePayload {
+    message?: string;
+    to: string;
+    extraData: any;
+    type?: ChatMessageType | string;
+    senderUserId?: string;
+    shouldPresist: boolean;
+    time: number;
+    chatSendVia: ChatSendVia;
+}

package/lib/models/MessagePayload.js

@@ -0,0 +1,29 @@
+export var ChatMessageType;
+(function (ChatMessageType) {
+    ChatMessageType["Chat"] = "chat";
+    ChatMessageType["File"] = "file";
+    ChatMessageType["Info"] = "info";
+})(ChatMessageType || (ChatMessageType = {}));
+export var ChatSendVia;
+(function (ChatSendVia) {
+    ChatSendVia["WebSocket"] = "WebSocket";
+    ChatSendVia["DataChannel"] = "DataChannel";
+})(ChatSendVia || (ChatSendVia = {}));
+export class MessagePayload {
+    constructor() {
+        this.to = "all";
+        this.extraData = {};
+        // public sender? :Participant;
+        this.shouldPresist = false;
+        this.time = new Date().getTime();
+        this.chatSendVia = ChatSendVia.WebSocket;
+        // constructor( _message : string)
+        // constructor( _message : string ,  _to: string )
+        // constructor(_message : string , _to: string = "all"  , _sender ? : Participant , _type : ChatMessageType | string = ChatMessageType.Chat) { 
+        //   this.message = _message;
+        //   this.to = _to;
+        //   this.sender = _sender;
+        //   this.type = _type;
+        // }   
+    }
+}

package/lib/models/Participant.d.ts

@@ -0,0 +1,15 @@
+export declare class Participant {
+    userId?: string;
+    userData: any;
+    isAdmin: boolean;
+    isAudioBlockedByAdmin: boolean;
+    isVideoBlockedByAdmin: boolean;
+    isMessageBlockedByAdmin: boolean;
+    isWhiteboardBlockedByAdmin: boolean;
+    isScreenshareBlockedByAdmin: boolean;
+    roomId?: string;
+    isVideoEnable: boolean;
+    isAudioEnable: boolean;
+    isStartMeetingCalled: boolean;
+    isRecordingUser: boolean;
+}

package/lib/models/Participant.js

@@ -0,0 +1,20 @@
+export class Participant {
+    constructor() {
+        this.isAdmin = false;
+        this.isAudioBlockedByAdmin = false;
+        this.isVideoBlockedByAdmin = false;
+        this.isMessageBlockedByAdmin = false;
+        this.isWhiteboardBlockedByAdmin = true;
+        this.isScreenshareBlockedByAdmin = false;
+        this.isVideoEnable = false;
+        this.isAudioEnable = false;
+        this.isStartMeetingCalled = false;
+        this.isRecordingUser = false;
+        // constructor(_userId: string, _roomId: string, _userData: any = {}, _isAdmin: boolean = false) {
+        //     this.userId = _userId;
+        //     this.roomId = _roomId;
+        //     this.userData = _userData;
+        //     this.isAdmin = _isAdmin;
+        // }
+    }
+}

package/lib/models/WebSocketServerStartRequest.d.ts

@@ -0,0 +1,9 @@
+export declare class WebSocketServerStartRequest {
+    port: number;
+    redisUrl: string;
+    redisDBIndex: number;
+    redisRoomDestoryTimeOutInSec: number;
+    rtcMinPort: number;
+    rtcMaxPort: number;
+    isTCPConnection: boolean;
+}

package/lib/models/WebSocketServerStartRequest.js

@@ -0,0 +1,11 @@
+export class WebSocketServerStartRequest {
+    constructor() {
+        this.port = 4010;
+        this.redisUrl = "redis://127.0.0.1:6378";
+        this.redisDBIndex = 5;
+        this.redisRoomDestoryTimeOutInSec = 1800;
+        this.rtcMinPort = 40000;
+        this.rtcMaxPort = 59999;
+        this.isTCPConnection = false;
+    }
+}

package/lib/sfu/SFUEachRoomHandler.d.ts

@@ -0,0 +1,56 @@
+import { Consumer } from "mediasoup/node/lib/Consumer";
+import { Producer } from "mediasoup/node/lib/Producer";
+import { Router } from "mediasoup/node/lib/Router";
+import { Worker } from "mediasoup/node/lib/Worker";
+import { BaseSFUWebsocket } from "../base/BaseSFUWebsocket";
+import { Participant } from "../models/Participant";
+import { SFUMessageType } from "../websocket/EachSocketConnectionHandler";
+import { SFUEachRoomUserHandler } from "./SFUEachRoomUserHandler";
+export interface SFUEachRoomParticipantInterface {
+    participant: Participant;
+}
+export interface SFUEachRoomProducer extends SFUEachRoomParticipantInterface {
+    producer: Producer;
+}
+export interface SFUEachRoomConsumer extends SFUEachRoomParticipantInterface {
+    consumer: Consumer;
+}
+export interface SFUMessageBody {
+    to: string;
+    type: SFUMessageType;
+    message: any;
+}
+export interface SFUEachRoomHandlerInterface {
+    getAllProducerForRoom(): SFUEachRoomProducer[];
+    getProducerById(producerId: string): SFUEachRoomProducer | undefined;
+    getAllConsumerForRoom(): SFUEachRoomConsumer[];
+    getAllRecvRouterForRoom(): Router[];
+    getSendRouterForRoom(): Router;
+    addAudioObserverForProducer(audioProducer: Producer): void;
+    pipeToRoute(producer: Producer): Promise<void>;
+}
+export declare class SFUEachRoomHandler extends BaseSFUWebsocket implements SFUEachRoomHandlerInterface {
+    private recvRouter;
+    private sendRouter?;
+    private roomId;
+    roomPaticipants: Map<string, SFUEachRoomUserHandler>;
+    private workers?;
+    private sendWorkerIndex;
+    private audioObserver?;
+    constructor(roomId: string, workers: Worker[], sendWorkerIndex: number);
+    onNewMessage(payload: SFUMessageBody, participant: Participant): void;
+    private getEachRoomUserFromParticipant;
+    private onGetRTPCapabilities;
+    private setUpForRoomId;
+    private addAudioObserver;
+    private getWorkerIndexForCreatingRouter;
+    getProducerById(producerId: string): SFUEachRoomProducer | undefined;
+    getAllProducerForRoom(): SFUEachRoomProducer[];
+    getAllConsumerForRoom(): SFUEachRoomConsumer[];
+    getAllRecvRouterForRoom(): Router[];
+    getSendRouterForRoom(): Router;
+    pipeToRoute(producer: Producer): Promise<void>;
+    addAudioObserverForProducer(audioProducer: Producer): Promise<void>;
+    onUserLeft(participant: Participant): void;
+    cleanUp(): void;
+}