vani-meeting-server 1.0.0

package/src/websocket/EachSocketConnectionHandler.ts

@@ -0,0 +1,451 @@
+import WebSocket, { WebSocketServer } from "ws";
+import { RedisHandler } from "../lib/redis/RedisHandler";
+import { Participant } from "../models/Participant";
+import { v4 as uuidv4 } from 'uuid';
+import { EventEmitterHandler } from "../utility/EventEmitterHandler";
+import { VaniEvent } from "../models/Event";
+import { SFUHandler } from "../sfu/SFUHandler";
+import { BaseSFUWebsocket } from "../base/BaseSFUWebsocket";
+
+
+export enum WebSocketBasicEvents {
+    Config = "config",
+    JoinRoom = "joinRoom",
+    IsSetupDone = "setupDone",
+    Ping = "ping",
+    Pong = "pong",
+    AudioVideoPauseResume = "audioVideoPauseResume",
+    OnStartMeetingCalled = "startMeetingCalled",
+    OnAudioVideoPauseResume = "audioVideoPauseResume",
+    OnAudioVideoStatusUpdated = "audioVideoStatusUpdated",
+    OnAudioUnblockRequest = "audioUnblock",
+    OnVideoUnblockRequest = "videoUnblock",
+    OnAudioBlockRequest = "audioBlock",
+    OnVideoBlockRequest = "videoBlock",
+    UpdateParticipant = "updateParticipant",
+    OnParticipantUpdated = "participantUpdated",
+    OnNewJoinee = "newJoinee",
+    OnRejoined = "rejoined",
+    OnUserOnFoundWhileReconnect = "onUserOnFoundWhileReconnect",
+
+    OnUserLeft = "userLeft",
+    GetAllParticipant = "getParticipant",
+    OnServerParticipants = "participants",
+    GetMeetingStartTime = "getMeetingStartTime",
+    OnMeetingStartTime = "meetingStartTime",
+    GetOldMessages = "getOldMessages",
+    OnOldMessages = "oldMessages",
+    Message = "message",
+    OnChat = "chat",
+    SelfLeft = "selfLeft",
+}
+export enum SFUMessageType {
+    SFUMessage = "sfuMessage",
+    GetRouterRtpCapabilities = "routerRtpCapabilities",
+    OnRouterRtpCapabilities = "onRouterRtpCapabilities",
+    OnTransportConnect = "transportConnect",
+    OnCreateTransports = "createTransports",
+    OnTransportConnectDone = "transportConnectDone",
+    OnSendTransport = "onSendTransport",
+    OnConsumeTransport = "onConsumeTransport",
+    OnTransportProduceSyncRequest = "transportProduceSync",
+    OnTransportDataProduceSyncRequest = "dataTransportProduceSync",
+    OnReadyToConsume = "readyToConsume",
+    OnStartRTMP = "startRtmp",
+    OnProducerClosed = "producerClosed",
+    OnPauseProducer = "pauseProducer",
+    OnResumeProducer = "resumeProducer",
+    OnNewProducer = "onNewProducer",
+    ConsumeProductId = "consumeProductId",
+    OnServerConsumer = "onServerConsumer",
+    ResumeConsumer = "resumeConsumer",
+    PauseConsumer = "pauseConsumer",
+    OnProduceSyncDone = "produceSyncDone",
+    OnSpeakerChanged = "onSpeakerChanged",
+    OnRestartIceCandidate = "restartIceCandidate",
+    OnRestartIceCandidateResponse = "onRestartIceCandidate",
+    OnTrackEnded = "onTrackEnded",
+    UpdateSpatialConsumer = "updateSpatialConsumer",
+    OnTransportNotFound = "onTransportNotFound",
+    GetAllProducers = "getAllProducers",
+    OnAllProducers = "onAllProducers",
+    OnStopProducer = "stopProducer",
+
+
+}
+
+export enum LocalMessageType {
+    OnNewUserJoinedRoom = "onNewUserJoinedRoom",
+    OnUserLeft = "OnUserLeft",
+    SocketMessage = "socketMessage"
+
+}
+export type WebSocketEvents = SFUMessageType | WebSocketBasicEvents | LocalMessageType
+
+
+
+
+export interface WebSocketMessageBody {
+    interfaceName: 'WebSocketMessageBody'
+    type: WebSocketEvents;
+    data?: any;
+
+}
+
+export interface ClientMessageBody {
+    interfaceName: 'ClientMessageBody'
+    shouldSendToSelf: boolean;
+    senderParticipant: Participant;
+    broadcastMessage: WebSocketMessageBody
+}
+
+export interface RediSubsciptionDetail {
+    topic: string;
+    listener: (data: string) => void
+}
+export class EachSocketConnectionHandler extends BaseSFUWebsocket {
+
+    private uuid = uuidv4();
+    private socket: WebSocket.WebSocket
+    private selfParticipant?: Participant
+    private appId: string = 'Demo'
+    private isActive = false
+    private roomIds: string[] = []
+    private redisSubscribtionDetails: RediSubsciptionDetail[] = []
+    private isReconnectionFromUrl = false
+    private numberOfPongWaiting = 0;
+    private destoryCallback?: (socketHandler : EachSocketConnectionHandler) => void;
+
+    constructor(socket: WebSocket.WebSocket, isReconnectionFromUrl: boolean) {
+        super()
+        this.socket = socket;
+        this.isReconnectionFromUrl = isReconnectionFromUrl
+        this.init = this.init.bind(this)
+        this.onNewMessage = this.onNewMessage.bind(this)
+        this.onConfig = this.onConfig.bind(this)
+        this.joinRoom = this.joinRoom.bind(this)
+        this.subscribeToRedisMessages = this.subscribeToRedisMessages.bind(this)
+        this.redisSubscribeToTopic = this.redisSubscribeToTopic.bind(this)
+        this.onRedisMessage = this.onRedisMessage.bind(this)
+        this.onNewUserJoinedRoomWithSameUserId = this.onNewUserJoinedRoomWithSameUserId.bind(this)
+        this.cleanUp = this.cleanUp.bind(this)
+        this.onSetupDone = this.onSetupDone.bind(this)
+        this.getAllParticipants = this.getAllParticipants.bind(this)
+        this.startPingPong = this.startPingPong.bind(this)
+        this.getMeetingStartTimeAndInfromIfNotExist = this.getMeetingStartTimeAndInfromIfNotExist.bind(this)
+        this.onSocketClosed = this.onSocketClosed.bind(this)
+        this.onStartMeetingCalled = this.onStartMeetingCalled.bind(this)
+        this.onAudioVideoPauseResume = this.onAudioVideoPauseResume.bind(this)
+    }
+
+    public onDestoryCallback(callBack: (socketHandler : EachSocketConnectionHandler) => void) {
+        this.destoryCallback = callBack
+    }
+    public async init() {
+        this.socket.on("message", this.onNewMessage)
+        this.socket.on("close", this.onSocketClosed)
+        this.subscribeToRedisMessages()
+    }
+
+    private async onSocketClosed(event: WebSocket.CloseEvent) {
+        console.log("Socket close code", event)
+        if (String(event).includes("1005") || String(event).includes("1001") || String(event).includes("1000")) {
+            this.onUserLeft()
+        }
+        else {
+            this.isActive = false
+        }
+    }
+
+    private async onUserLeft() {
+        this.socket.close()
+        if (!this.selfParticipant) {
+            return
+        }
+        const roomSFUHandler = SFUHandler.getInstance().getRoomSFUHandler(this.selfParticipant?.roomId!)
+        if (roomSFUHandler) {
+            roomSFUHandler.onUserLeft(this.selfParticipant)
+        }
+        this.sendVaniEvent(VaniEvent.OnUserLeft, this.selfParticipant)
+        this.redisBroadcastMessageToTopic(this.selfParticipant.roomId!, this.preapreClientMessageBody(false, this.selfParticipant, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnUserLeft, { participant: this.selfParticipant })))
+        RedisHandler.getInstance().removeParticipantForRoom(this.selfParticipant.roomId!, this.selfParticipant)
+        SFUHandler.getInstance().checkIfCanCloseRoom(this.selfParticipant.roomId!)
+        this.cleanUp()
+
+    }
+
+    private async onNewMessage(msgData: string) {
+        const paylod: WebSocketMessageBody = JSON.parse(msgData);
+        if (paylod.type === WebSocketBasicEvents.Config) {
+            this.onConfig(paylod.data)
+        }
+        else if (paylod.type === WebSocketBasicEvents.JoinRoom) {
+            this.joinRoom(paylod.data)
+        }
+        else if (paylod.type === WebSocketBasicEvents.IsSetupDone) {
+            this.onSetupDone(paylod.data)
+        }
+        else if (paylod.type === WebSocketBasicEvents.SelfLeft) {
+            this.onUserLeft()
+        }
+        else if (paylod.type === WebSocketBasicEvents.Pong) {
+            this.numberOfPongWaiting = 0;
+        }
+        else if (paylod.type === WebSocketBasicEvents.GetMeetingStartTime) {
+            const startMeetingTime = await this.getMeetingStartTimeAndInfromIfNotExist()
+            this.redisBroadcastMessageToTopic(this.selfParticipant?.userId!, this.preapreClientMessageBody(true, this.selfParticipant!, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnMeetingStartTime, startMeetingTime)))
+
+        }
+        else if (paylod.type === WebSocketBasicEvents.GetAllParticipant) {
+            this.getAllParticipants()
+        }
+        else if (paylod.type === WebSocketBasicEvents.Message) {
+
+            if (this.selfParticipant) {
+                paylod.data.userId = this.selfParticipant.userId;
+            }
+            if (paylod.data.shouldPresist && paylod.data.shouldPresist === true) {
+                RedisHandler.getInstance().storeMesagesForRoom(this.selfParticipant!.roomId!, paylod.data.message);
+            }
+            this.redisBroadcastMessageToTopic(this.selfParticipant?.roomId!, this.preapreClientMessageBody(false, this.selfParticipant!, this.preapreWebSocketMessageBody(paylod.data.type, paylod.data.message)))
+
+        }
+        else if (paylod.type === WebSocketBasicEvents.GetOldMessages) {
+            const messages = await RedisHandler.getInstance().fetchMessagesForRoom(this.selfParticipant?.roomId!)
+            console.log(messages)
+            this.redisBroadcastMessageToTopic(this.selfParticipant?.userId!, this.preapreClientMessageBody(true, this.selfParticipant!, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnOldMessages, messages)))
+
+        }
+        else if (paylod.type === WebSocketBasicEvents.OnStartMeetingCalled) {
+            this.onStartMeetingCalled(paylod.data)
+        }
+        else if (paylod.type === WebSocketBasicEvents.OnAudioVideoPauseResume) {
+            this.onAudioVideoPauseResume(paylod.data)
+        }
+
+        else if (paylod.type === SFUMessageType.SFUMessage) {
+            const roomSFUHandler = SFUHandler.getInstance().getRoomSFUHandler(this.selfParticipant?.roomId!)
+            if (roomSFUHandler) {
+                roomSFUHandler.onNewMessage(paylod.data, this.selfParticipant!)
+            }
+        }
+
+    }
+    private async onAudioVideoPauseResume(data: any) {
+        if (this.selfParticipant) {
+            if (data.message && data.message.type && data.message.type === "video") {
+                if (data.message.status && data.message.status === "pause") {
+                    this.selfParticipant.isVideoEnable = false
+                }
+                else if (data.message.status && data.message.status === "resume") {
+                    this.selfParticipant.isVideoEnable = true
+                }
+            }
+            else if (data.message && data.message.type && data.message.type === "audio") {
+                if (data.message.status && data.message.status === "pause") {
+                    this.selfParticipant.isAudioEnable = false
+                }
+                else if (data.message.status && data.message.status === "resume") {
+                    this.selfParticipant.isAudioEnable = true
+                }
+            }
+            await RedisHandler.getInstance().addUpdateParticipantForRoom(this.selfParticipant.roomId!, this.selfParticipant)
+            this.redisBroadcastMessageToTopic(this.selfParticipant.roomId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnAudioVideoStatusUpdated, { participant: this.selfParticipant })));
+        }
+    }
+    private async onStartMeetingCalled(data: any) {
+        if (this.selfParticipant) {
+            this.selfParticipant.isStartMeetingCalled = true
+            RedisHandler.getInstance().addUpdateParticipantForRoom(this.selfParticipant.roomId!, this.selfParticipant)
+        }
+    }
+    private async onConfig(data: any) {
+        if (data.participant) {
+            this.selfParticipant = Object.assign(new Participant(), data.participant)
+            if (this.selfParticipant && this.selfParticipant.userId) {
+                this.redisSubscribeToTopic(this.selfParticipant.userId)
+            }
+        }
+        if (data.appId) {
+            this.appId = data.appId
+        }
+    }
+
+    private async joinRoom(data: any) {
+        const roomId = data.roomId
+        const userId = data.id
+        this.isActive = true
+        if (this.roomIds.includes(roomId) === false) {
+            this.roomIds.push(roomId)
+            this.redisSubscribeToTopic(roomId)
+        }
+        //Send Local Event To Close Old Socket for same User id
+        const localEventData = { roomId: roomId, senderUUID: this.uuid, userId: userId }
+        this.redisBroadcastMessageToTopic(userId, this.preapreWebSocketMessageBody(LocalMessageType.OnNewUserJoinedRoom, localEventData))
+    }
+
+    private async onSetupDone(data: any) {
+        if (!this.selfParticipant) {
+            this.cleanUp()
+            return;
+        }
+        await SFUHandler.getInstance().checkAndSetupRoom(this.selfParticipant!.roomId!)
+        // if (shouldUseSfu) {
+        //     sfuRoom = sfuHandler.handleNewUserAdded(
+        //         {
+        //             userId: participant.userId,
+        //             roomId: participant.roomId
+        //         },
+        //         socket
+        //     );
+        // }
+        this.getMeetingStartTimeAndInfromIfNotExist()
+        const checkIfOldUserExist = await RedisHandler.getInstance().getParticipantByUserId(this.selfParticipant.roomId!, this.selfParticipant.userId!)
+        let isReconnection = false
+        if (this.isReconnectionFromUrl && !checkIfOldUserExist) {
+            this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnUserOnFoundWhileReconnect, { participant: this.selfParticipant })))
+            return
+        }
+        if (this.isReconnectionFromUrl || checkIfOldUserExist) {
+            //send message for rejoin
+            this.redisBroadcastMessageToTopic(this.selfParticipant.roomId!, this.preapreClientMessageBody(false, this.selfParticipant, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnRejoined, { participant: this.selfParticipant })))
+            isReconnection = true
+        }
+        else {
+            this.redisBroadcastMessageToTopic(this.selfParticipant.roomId!, this.preapreClientMessageBody(false, this.selfParticipant, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnNewJoinee, { participant: this.selfParticipant })))
+            this.sendVaniEvent(VaniEvent.OnUserJoined, this.selfParticipant)
+            isReconnection = false
+        }
+        await RedisHandler.getInstance().addUpdateParticipantForRoom(this.selfParticipant.roomId!, this.selfParticipant)
+        this.getAllParticipants()
+        this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(WebSocketBasicEvents.IsSetupDone, { isReconnection: isReconnection })));
+        this.startPingPong()
+    }
+
+    private async getMeetingStartTimeAndInfromIfNotExist(): Promise<number> {
+        const meetingStartTime = await RedisHandler.getInstance().fetchMeetingTimeForRoom(this.selfParticipant!.roomId!)
+        if (meetingStartTime === undefined) {
+            const meetingTime = new Date().getTime()
+            RedisHandler.getInstance().storeMeetingTimeForRoom(this.selfParticipant!.roomId!, meetingTime)
+            this.sendVaniEvent(VaniEvent.OnNewMeetingStarted, { roomId: this.selfParticipant!.roomId! })
+            return meetingTime
+        }
+        return meetingStartTime
+
+    }
+
+    private async getAllParticipants() {
+        const allUsers = await RedisHandler.getInstance().getAllParticipants(this.selfParticipant?.roomId!)
+        const userMap: { [key: string]: Participant } = {}
+        allUsers.forEach((participant: Participant) => {
+            userMap[participant.userId!] = participant
+        })
+        this.redisBroadcastMessageToTopic(this.selfParticipant!.userId!, this.preapreClientMessageBody(true, this.selfParticipant!, this.preapreWebSocketMessageBody(WebSocketBasicEvents.OnServerParticipants, userMap)))
+    }
+
+    private startPingPong() {
+        if (this.isActive && this.socket.OPEN && this.selfParticipant) {
+            if (this.numberOfPongWaiting > 10) {
+                console.log("No Pong More Than 10 Times start")
+                console.log(this.selfParticipant)
+                console.log("No Pong More Than 10 Times End")
+                // isUserLeftMsgSent = true;
+                this.onUserLeft();
+                return;
+            }
+            this.redisBroadcastMessageToTopic(this.selfParticipant!.userId!, this.preapreClientMessageBody(true, this.selfParticipant!, this.preapreWebSocketMessageBody(WebSocketBasicEvents.Ping, { userId: this.selfParticipant.userId })))
+            this.numberOfPongWaiting = this.numberOfPongWaiting + 1;
+            setTimeout(this.startPingPong, 5000)
+        }
+
+    }
+
+    private cleanUp() {
+        this.isActive = false;
+        this.socket.close(3006)
+        try {
+            this.socket.removeAllListeners()
+        }
+        catch (err) {
+
+        }
+        if (this.destoryCallback) {
+            this.destoryCallback(this)
+            this.destoryCallback = undefined
+        }
+        this.redisSubscribtionDetails.forEach((eachRedisSubscribtionDetails: RediSubsciptionDetail) => {
+            RedisHandler.getInstance().redisSubscriber.unsubscribe(eachRedisSubscribtionDetails.topic, eachRedisSubscribtionDetails.listener)
+        })
+        this.redisSubscribtionDetails = []
+    }
+
+    //Send EVent Emitter
+
+    private async sendVaniEvent(event: VaniEvent, data: any) {
+        EventEmitterHandler.getInstance().vaniEventEmitter.emit(event, data)
+    }
+
+    //Redis
+
+    private async onNewUserJoinedRoomWithSameUserId(data: any) {
+        console.log("onNewUserJoinedRoomWithSameUserId Start")
+        const roomId = data.roomId
+        const senderUUID = data.senderUUID
+        const userId = data.userId
+        if (userId === this.selfParticipant?.userId && this.uuid !== senderUUID && this.roomIds.includes(roomId)) {
+            this.isActive = false;
+            this.socket.close(3006)
+            this.cleanUp()
+            console.log("onNewUserJoinedRoomWithSameUserId done")
+        }
+    }
+
+
+
+
+    private async sendMessageToClient(data: ClientMessageBody) {
+        if ((data.shouldSendToSelf === true || this.selfParticipant?.userId !== data.senderParticipant.userId) && this.isActive && this.socket.OPEN) {
+            const sendMessageData = { type: data.broadcastMessage.type, data: { message: data.broadcastMessage.data } }
+            this.socket.send(JSON.stringify(sendMessageData))
+        }
+
+    }
+    private async onRedisMessage(data: WebSocketMessageBody | ClientMessageBody) {
+
+        if (data.interfaceName === 'WebSocketMessageBody') {
+            const webSocketMessageBody: WebSocketMessageBody = data
+            if (webSocketMessageBody.type === LocalMessageType.OnNewUserJoinedRoom) {
+                this.onNewUserJoinedRoomWithSameUserId(webSocketMessageBody.data)
+            }
+        }
+        else if (data.interfaceName === 'ClientMessageBody') {
+            const socketMessageBody: ClientMessageBody = data
+            this.sendMessageToClient(socketMessageBody)
+        }
+
+
+
+    }
+
+    private async subscribeToRedisMessages() {
+        RedisHandler.getInstance().redisSubscriber.on('message', (roomId, messageInString) => {
+            const message = JSON.parse(messageInString);
+            console.debug(message)
+        })
+    }
+
+    private async redisSubscribeToTopic(topic: string) {
+        const isListenerAlreadyExist = this.redisSubscribtionDetails.find((eachRedisSubscribtionDetails) => eachRedisSubscribtionDetails.topic === topic)
+        if (!isListenerAlreadyExist) {
+            const listener = (data: string) => {
+                this.onRedisMessage(JSON.parse(data))
+
+            }
+            RedisHandler.getInstance().redisSubscriber.subscribe(topic, listener)
+            this.redisSubscribtionDetails.push({ topic, listener })
+        }
+
+    }
+
+
+}

package/src/websocket/WebSocketHandler.ts

@@ -0,0 +1,30 @@
+import WebSocket from "ws";
+import { VaniEvent } from "../models/Event";
+import { ServerHandler } from "../ServerHandler";
+import { EventEmitterHandler } from "../utility/EventEmitterHandler";
+import { EachSocketConnectionHandler } from "./EachSocketConnectionHandler";
+
+export class WebSocketHandler {
+
+    private wss: WebSocket.Server;
+    private socketConnections: EachSocketConnectionHandler[] = []
+    constructor() {
+        this.wss = new WebSocket.Server({ port: ServerHandler.getInstance().serverStartRequest.port })
+    }
+    connect() {
+        this.wss.on("connection", (socket, req) => {
+            console.log("On New Connection")
+            const eachSocketConnection = new EachSocketConnectionHandler(socket, req.url ? req.url.includes('reconnect') : false)
+            eachSocketConnection.init();
+            eachSocketConnection.onDestoryCallback((socketConnection: EachSocketConnectionHandler) => {
+                const index = this.socketConnections.indexOf(socketConnection)
+                if (index > -1) {
+                    this.socketConnections.splice(index, 1)
+                }
+            })
+            this.socketConnections.push(eachSocketConnection)
+        })
+        EventEmitterHandler.getInstance().vaniEventEmitter.emit(VaniEvent.OnServerStarted, {})
+
+    }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": ["ESNext"],
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}