vani-meeting-server 1.0.0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "vani-meeting-server",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.js",
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "preserve": "npm run build",
+    "serve": "cross-env NODE_ENV=development concurrently \"tsc --watch\" \"nodemon -q dist/index.js\"",
+    "prestart": "npm run build",
+    "start": "cross-env NODE_ENV=production node dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "pm2": "tsc && pm2 start pm2.config.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/axios": "^0.14.0",
+    "@types/body-parser": "^1.19.2",
+    "@types/express": "^4.17.13",
+    "@types/node": "^18.7.16",
+    "public-ip": "4.0.3",
+    "@types/redis": "^4.0.11",
+    "@types/ws": "^8.5.3",
+    "axios": "^0.27.2",
+    "body-parser": "^1.20.0",
+    "cross-env": "^7.0.3",
+    "dotenv": "^16.0.2",
+    "express": "^4.18.1",
+    "helmet": "^6.0.0",
+    "mediasoup": "^3.10.6",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.8.3",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/uuid": "^8.3.4",
+    "concurrently": "^7.4.0",
+    "nodemon": "^2.0.19"
+  }
+}

package/pm2.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  apps: [
+      {
+          name: 'Vani server v2',
+          script: './dist/index.js',
+      },
+  ],
+};

package/src/ServerHandler.ts

@@ -0,0 +1,32 @@
+import { RedisHandler } from "./lib/redis/RedisHandler";
+import { WebSocketServerStartRequest } from "./models/WebSocketServerStartRequest";
+import { SFUHandler } from "./sfu/SFUHandler";
+import { WebSocketHandler } from "./websocket/WebSocketHandler";
+
+export class ServerHandler {
+
+    serverStartRequest: WebSocketServerStartRequest = new WebSocketServerStartRequest();
+    rediHandler?: RedisHandler;
+    webSocketHandler?: WebSocketHandler
+    sfuHandler?: SFUHandler
+
+    static instance: ServerHandler = new ServerHandler()
+    static getInstance(): ServerHandler {
+        return ServerHandler.instance;
+    }
+    async initWithServerStartRequest(serverStartRequest: WebSocketServerStartRequest) {
+        this.serverStartRequest = serverStartRequest
+
+        this.rediHandler = RedisHandler.getInstance()
+        await this.rediHandler.connectDB()
+        await this.rediHandler.cleanUp()
+
+        console.info("On Redis Connected")
+
+        this.webSocketHandler = new WebSocketHandler()
+        this.webSocketHandler.connect()
+
+        this.sfuHandler = SFUHandler.getInstance()
+        this.sfuHandler.init()
+    }
+}

package/src/base/BaseSFUWebsocket.ts

@@ -0,0 +1,20 @@
+import { RedisHandler } from "../lib/redis/RedisHandler"
+import { Participant } from "../models/Participant"
+import { ClientMessageBody, WebSocketEvents, WebSocketMessageBody } from "../websocket/EachSocketConnectionHandler"
+
+export class BaseSFUWebsocket{
+    protected async redisBroadcastMessageToTopic(topic: string, data: WebSocketMessageBody | ClientMessageBody) {
+        RedisHandler.getInstance().redisPublisher.publish(topic, JSON.stringify(data))
+    }
+
+
+    //Utilility function
+
+
+    protected preapreClientMessageBody(shouldSendToSelf: boolean, senderParticipant: Participant, broadcastMessage: WebSocketMessageBody): ClientMessageBody {
+        return { shouldSendToSelf, senderParticipant, broadcastMessage, interfaceName: 'ClientMessageBody' }
+    }
+    protected preapreWebSocketMessageBody(type: WebSocketEvents, data: any): WebSocketMessageBody {
+        return { type, data, interfaceName: 'WebSocketMessageBody' }
+    }
+}

package/src/index.ts

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

package/src/lib/redis/RedisHandler.ts

@@ -0,0 +1,150 @@
+import { log } from "console";
+import { createClient, RedisClientType } from "redis";
+import { MessagePayload } from "../../models/MessagePayload";
+import { Participant } from "../../models/Participant";
+import { ServerHandler } from "../../ServerHandler";
+
+export enum RedisKeyType {
+    Messages = "messages",
+    MeetingTime = "meetingTime",
+    Participants = "participants",
+}
+export class RedisHandler {
+
+    private static redisHandler: RedisHandler = new RedisHandler();
+    private redisClient: RedisClientType;
+    // private redisRoomModelHash = new Map<string, RedisRoomModel>;
+    public redisPublisher: RedisClientType;
+    public redisSubscriber: RedisClientType;
+    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 })
+    }
+
+
+    public static getInstance() {
+        return this.redisHandler
+    }
+
+    public async connectDB() {
+        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);
+        });
+        await this.redisClient.connect()
+        await this.redisSubscriber.connect()
+        await this.redisPublisher.connect()
+        // await this.redisClient.hSet("rooms","123","HSETObject")
+        // console.log(await this.redisClient.hGet("rooms","123"))
+    }
+
+    public async cleanUp() {
+        return await this.redisClient.flushDb()
+    }
+
+
+    //Clean Room Id
+
+    public async cleanUpRoomId(roomId: string) {
+        await this.redisClient.del(roomId)
+    }
+
+
+    //Messages
+    public async storeMesagesForRoom(roomId: string, messagePayload: MessagePayload) {
+        const messages = await this.fetchMessagesForRoom(roomId)
+        messages.push(messagePayload)
+        await this.redisClient.hSet(roomId, RedisKeyType.Messages, JSON.stringify(messages))
+        this.updateRoomCleanupTimeOut(roomId)
+    }
+
+    public async fetchMessagesForRoom(roomId: string): Promise<MessagePayload[]> {
+        const messages = await this.redisClient.hGet(roomId, RedisKeyType.Messages)
+        if (messages) {
+            return JSON.parse(messages)
+        }
+        else {
+            return []
+        }
+    }
+
+    //Meeting Time
+
+    public async storeMeetingTimeForRoom(roomId: string, time?: number) {
+
+        await this.redisClient.hSet(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime())
+        this.updateRoomCleanupTimeOut(roomId)
+    }
+
+    public async fetchMeetingTimeForRoom(roomId: string): Promise<number | undefined> {
+        const meetingTime = await this.redisClient.hGet(roomId, RedisKeyType.MeetingTime)
+        if (meetingTime) {
+            return +meetingTime;
+        }
+        else {
+            return undefined
+        }
+    }
+
+
+    //Users
+    public async removeParticipantForRoom(roomId: string, participant: Participant) {
+        const participantKey = RedisKeyType.Participants + ":" + participant.userId
+        await this.redisClient.hDel(roomId, participantKey)
+        this.updateRoomCleanupTimeOut(roomId)
+    }
+    public async addUpdateParticipantForRoom(roomId: string, participant: Participant) {
+        const participantKey = RedisKeyType.Participants + ":" + participant.userId
+        await this.redisClient.hSet(roomId, participantKey, JSON.stringify(participant))
+        this.updateRoomCleanupTimeOut(roomId)
+    }
+
+    public async getParticipantByUserId(roomId: string, userId: string): Promise<Participant | undefined> {
+        const participantKey = RedisKeyType.Participants + ":" + userId
+        const particpantString = await this.redisClient.hGet(roomId, participantKey)
+        if (particpantString) {
+            return JSON.parse(particpantString)
+        }
+        return undefined
+    }
+
+    public async getAllParticipants(roomId: string): Promise<Participant[]> {
+        const particpantsInStringify = await this.redisClient.hGetAll(roomId)
+        const participants: Participant[] = []
+        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
+    //     }
+    // }
+
+    private updateRoomCleanupTimeOut(roomId: string) {
+        this.redisClient.expire(roomId, ServerHandler.getInstance().serverStartRequest.redisRoomDestoryTimeOutInSec)
+    }
+
+
+}

package/src/models/Event.ts

@@ -0,0 +1,36 @@
+import { Participant } from "./Participant";
+
+
+export 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.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
+}

package/src/models/MessagePayload.ts

@@ -0,0 +1,35 @@
+
+export enum ChatMessageType{
+  Chat = "chat",
+  File = "file",
+  Info = "info",
+}
+export enum ChatSendVia{
+  WebSocket = "WebSocket",
+  DataChannel = "DataChannel",
+}
+
+export class MessagePayload { 
+  public message?: string;
+  public to : string = "all";
+  public extraData : any = {}
+  public type? :  ChatMessageType | string ;
+  public senderUserId? : string;
+  // public sender? :Participant;
+  public shouldPresist : boolean = false
+  public time : number = new Date().getTime();
+  public chatSendVia : 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/src/models/Participant.ts

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

package/src/models/WebSocketServerStartRequest.ts

@@ -0,0 +1,14 @@
+
+
+export class WebSocketServerStartRequest {
+
+  port: number = 4010
+  redisUrl: string = "redis://127.0.0.1:6378";
+  redisDBIndex: number = 5
+  redisRoomDestoryTimeOutInSec = 1800
+  rtcMinPort = 40000
+  rtcMaxPort = 59999
+  isTCPConnection: boolean = false
+
+
+}

package/src/sfu/SFUEachRoomHandler.ts

@@ -0,0 +1,265 @@
+import { log } from "console";
+import { ActiveSpeakerObserver } from "mediasoup/node/lib/ActiveSpeakerObserver";
+import { AudioLevelObserver } from "mediasoup/node/lib/AudioLevelObserver";
+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 { RedisHandler } from "../lib/redis/RedisHandler";
+import { VaniEvent } from "../models/Event";
+import { Participant } from "../models/Participant";
+import { mediaCodecs } from "../utility/Constant";
+import { EventEmitterHandler } from "../utility/EventEmitterHandler";
+import { ClientMessageBody, SFUMessageType, WebSocketBasicEvents, WebSocketMessageBody } 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 class SFUEachRoomHandler extends BaseSFUWebsocket implements SFUEachRoomHandlerInterface {
+
+    private recvRouter: Router[] = []
+    private sendRouter?: Router;
+    private roomId: string;
+    public roomPaticipants = new Map<string, SFUEachRoomUserHandler>()
+
+    private workers?: Worker[]
+    private sendWorkerIndex: number = -1
+    private audioObserver?: ActiveSpeakerObserver;
+    constructor(roomId: string, workers: Worker[], sendWorkerIndex: number) {
+        super()
+        this.roomId = roomId;
+        this.workers = workers
+        this.sendWorkerIndex = sendWorkerIndex
+        this.cleanUp = this.cleanUp.bind(this)
+    }
+
+
+
+
+
+    public onNewMessage(payload: SFUMessageBody, participant: Participant) {
+        // console.log(payload)
+        if (payload.type === SFUMessageType.GetRouterRtpCapabilities) {
+            this.onGetRTPCapabilities(participant)
+        }
+        else {
+            const sfuEachRoomUser = this.getEachRoomUserFromParticipant(participant)
+            if (sfuEachRoomUser) {
+                this.getEachRoomUserFromParticipant(participant)?.onNewMessage(payload)
+            }
+
+        }
+    }
+
+
+
+
+    private getEachRoomUserFromParticipant(participant: Participant): SFUEachRoomUserHandler | undefined {
+
+        if (this.sendRouter && this.recvRouter.length > 0) {
+            if (this.roomPaticipants.has(participant.userId!)) {
+                return this.roomPaticipants.get(participant.userId!)
+            }
+            else {
+                const indexForRecRouter = (this.roomPaticipants.size % this.recvRouter.length)
+                const roomUser = new SFUEachRoomUserHandler(participant, this.sendRouter!, this.recvRouter[indexForRecRouter], this)
+                this.roomPaticipants.set(participant.userId!, roomUser)
+                return roomUser;
+            }
+        }
+
+    }
+
+    private async onGetRTPCapabilities(participant: Participant) {
+        if (this.workers) {
+            await this.setUpForRoomId(this.workers, this.sendWorkerIndex)
+        }
+
+        if (this.sendRouter) {
+            const rtpCapablities = this.sendRouter.rtpCapabilities;
+            if (rtpCapablities) {
+                this.redisBroadcastMessageToTopic(participant.userId!, this.preapreClientMessageBody(true, participant, this.preapreWebSocketMessageBody(SFUMessageType.OnRouterRtpCapabilities, { rtpCapabilities: rtpCapablities })));
+            }
+        }
+        else {
+            console.error("onGetRTPCapabilities no sende router found")
+        }
+    }
+
+
+
+    private async setUpForRoomId(workers: Worker[], sendWorkerIndex: number) {
+        let currentWorkerIndexForRouter = sendWorkerIndex
+        let sendWorkerPID = undefined
+        if (!this.sendRouter) {
+            const worker = workers[currentWorkerIndexForRouter]
+            if (worker) {
+                this.sendRouter = await worker.createRouter({ mediaCodecs })
+                sendWorkerPID = worker.pid
+                currentWorkerIndexForRouter = this.getWorkerIndexForCreatingRouter(currentWorkerIndexForRouter, workers.length)
+                this.addAudioObserver()
+            }
+        }
+
+        while (this.recvRouter.length < (workers.length - 1)) { // Dont create on send worker
+            const worker = workers[currentWorkerIndexForRouter]
+            currentWorkerIndexForRouter = this.getWorkerIndexForCreatingRouter(currentWorkerIndexForRouter, workers.length)
+            if (worker.pid === sendWorkerPID) {
+                continue;
+            }
+            this.recvRouter.push(await worker.createRouter({ mediaCodecs }))
+        }
+        this.workers = undefined
+        this.sendWorkerIndex = -1
+    }
+
+    private async addAudioObserver() {
+
+        if (this.sendRouter && !this.audioObserver) {
+            this.audioObserver = await this.sendRouter.createActiveSpeakerObserver({
+                interval: 100
+            })
+            this.audioObserver.on("dominantspeaker", (speakerProducer) => {
+
+                const speakerUserId: string = speakerProducer.producer.appData.userId as string;
+                if (this.roomPaticipants.size < 2) {
+                    return;
+                }
+                else {
+                    const participant = RedisHandler.getInstance().getParticipantByUserId(this.roomId, speakerUserId);
+                    if (participant !== undefined) {
+                        this.redisBroadcastMessageToTopic(this.roomId, this.preapreClientMessageBody(true, participant as unknown as Participant, this.preapreWebSocketMessageBody(SFUMessageType.OnSpeakerChanged, { speakerUserId: speakerUserId })));
+                        console.log( "dominantspeaker" ,  speakerUserId)
+                    }
+                }
+
+
+            })
+
+
+        }
+    }
+
+    private getWorkerIndexForCreatingRouter(currentIndexOfWorker: number, totalNumberOfWorker: number) {
+        if (currentIndexOfWorker < (totalNumberOfWorker - 1)) {
+            return (currentIndexOfWorker + 1);
+        }
+        return 0
+    }
+
+
+
+    //Interface methods
+    getProducerById(producerId: string): SFUEachRoomProducer | undefined {
+
+        const allProducers: SFUEachRoomProducer[] = this.getAllProducerForRoom()
+        const producer = allProducers.find((eachProducer) => eachProducer.producer.id === producerId)
+        return producer;
+    }
+
+    getAllProducerForRoom(): SFUEachRoomProducer[] {
+        const allProducers: SFUEachRoomProducer[] = []
+        this.roomPaticipants.forEach((roomPaticipant, userId) => {
+            roomPaticipant.producers.forEach(producer => {
+                if (producer.closed === false) {
+                    allProducers.push({ participant: roomPaticipant.selfParticipant, producer })
+                }
+                else {
+                    console.log("Producer is Closed ", producer.id, roomPaticipant.selfParticipant.userData.name)
+                }
+            });
+        })
+        return allProducers
+    }
+    getAllConsumerForRoom(): SFUEachRoomConsumer[] {
+        return []
+    }
+    getAllRecvRouterForRoom(): Router[] {
+        return this.recvRouter;
+    }
+    getSendRouterForRoom(): Router {
+        return this.sendRouter!;
+    }
+    async pipeToRoute(producer: Producer) {
+        if (!this.sendRouter) {
+            console.error("pipeToRoute - no send router found")
+        }
+
+
+        for (const eachRecvRouter of this.recvRouter) {
+            try {
+                await this.sendRouter?.pipeToRouter({ producerId: producer.id, router: eachRecvRouter })
+            } catch (err) {
+                console.error("pipeToRouter Error")
+                console.error(err)
+            }
+
+
+        }
+
+    }
+
+    async addAudioObserverForProducer(audioProducer: Producer) {
+        if (this.audioObserver) {
+            console.log("addAudioObserverForProducer" , audioProducer.appData.userId)
+            this.audioObserver?.addProducer({ producerId: audioProducer.id })
+        }
+    }
+
+    public onUserLeft(participant: Participant) {
+        if (this.roomPaticipants.has(participant.userId!)) {
+            this.roomPaticipants.get(participant.userId!)?.cleanUp()
+            this.roomPaticipants.delete(participant.userId!)
+        }
+    }
+
+    public cleanUp() {
+        console.debug("Clean Up Room Id ", this.roomId)
+        RedisHandler.getInstance().cleanUpRoomId(this.roomId)
+        EventEmitterHandler.getInstance().vaniEventEmitter.emit(VaniEvent.OnNewMeetingEnded, this.roomId)
+        this.roomPaticipants.forEach((sfuEachRoomUser: SFUEachRoomUserHandler) => {
+            this.onUserLeft(sfuEachRoomUser.selfParticipant)
+        })
+        this.recvRouter.forEach((eachRouter) => {
+            eachRouter.close()
+        })
+        if (this.audioObserver) {
+            this.audioObserver.close()
+            this.audioObserver = undefined
+        }
+        this.recvRouter = []
+        if (this.sendRouter) {
+            this.sendRouter.close()
+        }
+        this.sendRouter = undefined;
+        this.workers = []
+    }
+
+
+}