Setup

package.json

@@ -49,6 +49,7 @@
     "express": "^5.1.0",
     "helmet": "^8.1.0",
     "mediasoup": "^3.18.0",
+    "public-ip": "^7.0.1",
     "redis": "^5.8.0",
     "zod": "^4.0.17"
   }

proto-gen.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-npx proto-loader-gen-types --grpcLib=@grpc/grpc-js --outDir=src/protos/ src/protos/*.proto
+npx proto-loader-gen-types --grpcLib=@grpc/grpc-js --outDir=src/protos/gen/ src/protos/*.proto

src/app.ts

@@ -1,4 +1,3 @@
-import fs from 'fs';
 import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';
@@ -8,19 +7,19 @@ import config from './config';
 import { Routes } from './routes';
 import { redisServer } from './servers/redis-server';
 import { grpcServer } from './servers/grpc-server';
-
-const serverOption = {
-  key: fs.readFileSync(config.tls.key, 'utf8'),
-  cert: fs.readFileSync(config.tls.cert, 'utf8'),
-};
+import { MediaNodeData } from './types';
+import { getRedisKey, registerMediaNode } from './lib/utils';
+import { mediaSoupServer } from './servers/mediasoup-server';
 
 const app = express();
 app.use(cors(config.cors));
 app.use(helmet());
 app.use(express.json());
 app.use('/', Routes);
 
-const httpsServer = createServer(serverOption, app);
+const httpsServer = createServer(config.httpsServerOptions, app);
+
+let medianodeData: MediaNodeData;
 
 (async (): Promise<void> => {
   try {
@@ -29,6 +28,11 @@ const httpsServer = createServer(serverOption, app);
       console.log(`Server running on port ${config.port}`);
     });
     await grpcServer.start();
+
+    await mediaSoupServer.start();
+
+    medianodeData = await registerMediaNode();
+    console.log('Register medianode');
   } catch (error) {
     console.error('Initialization error:', error);
     process.exit(1);
@@ -37,6 +41,12 @@ const httpsServer = createServer(serverOption, app);
 
 const shutdown = async (): Promise<void> => {
   try {
+    await redisServer.sRem(
+      getRedisKey['medianodesRunning'](),
+      JSON.stringify(medianodeData)
+    );
+    console.log('Delete medianode');
+
     await redisServer.disconnect();
     httpsServer.close();
     console.log('Application shut down gracefully');

src/config/index.ts

@@ -1,26 +1,138 @@
+import fs from 'fs';
+import os from 'os';
 import path from 'path';
+
 import * as dotenv from 'dotenv';
+import { types as mediasoupTypes } from 'mediasoup';
 
 dotenv.config();
 
-const certPath = path.join(__dirname, '..', 'certs', 'fullchain.pem');
-const keyPath = path.join(__dirname, '..', 'certs', 'privkey.pem');
+const certFile =
+  process.env.HTTPS_CERT ||
+  path.join(__dirname, '..', 'certs', 'fullchain.pem');
+const keyFile =
+  process.env.HTTPS_KEY || path.join(__dirname, '..', 'certs', 'privkey.pem');
+
+const LISTEN_IP = process.env.LISTEN_IP || '0.0.0.0';
+const ANNOUNCED_ADDRESS = process.env.ANNOUNCED_ADDRESS || '127.0.0.1';
 
 const config = {
+  nodeId: `mnode-1`,
   env: process.env.NODE_ENV,
   cors: {
     origin: process.env.NODE_ENV === 'production' ? ['https://mitsi.app'] : '*',
     methods: ['GET', 'POST'],
   },
-  tls: {
-    cert: process.env.HTTPS_CERT || certPath,
-    key: process.env.HTTPS_KEY || keyPath,
+  httpsServerOptions: {
+    key: fs.readFileSync(keyFile, 'utf8'),
+    cert: fs.readFileSync(certFile, 'utf8'),
   },
   port: process.env.PORT || 4000,
+  grpcPort: process.env.GRPC_PORT || 50052,
+  cpus: Object.keys(os.cpus()).length,
+
   apiServerUrl: process.env.API_SERVER_URL,
   apiServerApiKey: process.env.API_SERVER_API_KEY,
   recordingServerUrl: process.env.RECORDING_SERVER_URL,
   redisServerUrl: process.env.REDIS_SERVER_URL || 'redis://localhost:6379',
+
+  mediasoup: {
+    maxWorkerLoad: parseInt(process.env.MAX_WORKER_LOAD || '100'),
+    workerSettings: {
+      dtlsCertificateFile: certFile,
+      dtlsPrivateKeyFile: keyFile,
+      rtcMinPort: parseInt(process.env.RTC_MIN_PORT || '2000'),
+      rtcMaxPort: parseInt(process.env.RTC_MAX_PORT || '2300'),
+      logLevel: 'warn' as mediasoupTypes.WorkerLogLevel,
+      logTags: [
+        'info',
+        'ice',
+        'dtls',
+        'rtp',
+        'srtp',
+        'rtcp',
+        'rtx',
+        'bwe',
+        'score',
+        'simulcast',
+        'svc',
+        'sctp',
+      ] as Array<mediasoupTypes.WorkerLogTag>,
+    },
+    webRtcServer: {
+      listenInfos: [
+        {
+          protocol: 'udp',
+          ip: LISTEN_IP,
+          announcedAddress: ANNOUNCED_ADDRESS,
+        },
+        {
+          protocol: 'tcp',
+          ip: LISTEN_IP,
+          announcedAddress: ANNOUNCED_ADDRESS,
+        },
+      ] as Array<mediasoupTypes.TransportListenInfo>,
+    },
+    routerMediaCodecs: [
+      {
+        kind: 'audio',
+        mimeType: 'audio/opus',
+        clockRate: 48000,
+        channels: 2,
+        // parameters: {
+        //     'stereo': 1,
+        //     'sprop-stereo': 1,
+        //     'maxplaybackrate': 48000,
+        //     'useinbandfec': 1
+        // }
+      },
+      {
+        kind: 'video',
+        mimeType: 'video/VP8',
+        clockRate: 90000,
+        parameters: {
+          'x-google-start-bitrate': 1000,
+        },
+      },
+      // {
+      //     kind: 'video',
+      //     mimeType: 'video/VP9',
+      //     clockRate: 90000,
+      //     parameters: {
+      //         'profile-id': 2,
+      //         'x-google-start-bitrate': 1000
+      //     }
+      // },
+      // {
+      //     kind: 'video',
+      //     mimeType: 'video/h264',
+      //     clockRate: 90000,
+      //     parameters: {
+      //         'packetization-mode': 1,
+      //         'profile-level-id': '4d0032',
+      //         'level-asymmetry-allowed': 1,
+      //         'x-google-start-bitrate': 1000
+      //     }
+      // },
+      // {
+      //     kind: 'video',
+      //     mimeType: 'video/h264',
+      //     clockRate: 90000,
+      //     parameters: {
+      //         'packetization-mode': 1,
+      //         'profile-level-id': '42e01f',
+      //         'level-asymmetry-allowed': 1,
+      //         'x-google-start-bitrate': 1000
+      //     }
+      // }
+    ] as Array<mediasoupTypes.RtpCodecCapability>,
+
+    transportListenInfo: {
+      protocol: 'udp',
+      ip: LISTEN_IP,
+      announcedAddress: ANNOUNCED_ADDRESS,
+    } as mediasoupTypes.TransportListenInfo,
+  },
 };
 
 export default config;

src/lib/utils.ts

@@ -0,0 +1,37 @@
+import config from '../config';
+import { redisServer } from '../servers/redis-server';
+import { MediaNodeData } from '../types';
+
+export const getRedisKey = {
+  room: (roomId: string): string => `room-${roomId}`,
+  lobby: (roomId: string): string => `lobby-${roomId}`,
+  roomPeers: (roomId: string): string => `room-${roomId}-peers`,
+  roomPeerIds: (roomId: string): string => `room-${roomId}-peerids`,
+  roomActiveSpeakerPeerId: (roomId: string): string =>
+    `room-${roomId}-activespeakerpeerid`,
+  roomsOngoing: (): string => `rooms-ongoing`,
+  medianodesRunning: (): string => `medianodes-running`,
+  signalnodesRunning: (): string => `signalnodes-running`,
+  roomMedianodes: (roomId: string): string => `room-${roomId}-medianodes`,
+  roomSignalnodes: (roomId: string): string => `room-${roomId}-signalnodes`,
+};
+
+export const registerMediaNode = async (): Promise<MediaNodeData> => {
+  try {
+    // const { publicIpv4 } = await import('public-ip');
+    // const ip = await publicIpv4();
+    const medianodeData: MediaNodeData = {
+      id: config.nodeId,
+      ip: '0.0.0.0',
+      address: `${config.port}`,
+      grpcPort: `${config.grpcPort}`,
+    };
+    await redisServer.sAdd(
+      getRedisKey['medianodesRunning'](),
+      JSON.stringify(medianodeData)
+    );
+    return medianodeData;
+  } catch (error) {
+    throw error;
+  }
+};

src/protos/gen/media-signaling.ts

@@ -0,0 +1,19 @@
+import type * as grpc from '@grpc/grpc-js';
+import type { MessageTypeDefinition } from '@grpc/proto-loader';
+
+import type { MediaSignalingClient as _mediaSignalingPackage_MediaSignalingClient, MediaSignalingDefinition as _mediaSignalingPackage_MediaSignalingDefinition } from './mediaSignalingPackage/MediaSignaling';
+import type { MessageRequest as _mediaSignalingPackage_MessageRequest, MessageRequest__Output as _mediaSignalingPackage_MessageRequest__Output } from './mediaSignalingPackage/MessageRequest';
+import type { MessageResponse as _mediaSignalingPackage_MessageResponse, MessageResponse__Output as _mediaSignalingPackage_MessageResponse__Output } from './mediaSignalingPackage/MessageResponse';
+
+type SubtypeConstructor<Constructor extends new (...args: any) => any, Subtype> = {
+  new(...args: ConstructorParameters<Constructor>): Subtype;
+};
+
+export interface ProtoGrpcType {
+  mediaSignalingPackage: {
+    MediaSignaling: SubtypeConstructor<typeof grpc.Client, _mediaSignalingPackage_MediaSignalingClient> & { service: _mediaSignalingPackage_MediaSignalingDefinition }
+    MessageRequest: MessageTypeDefinition<_mediaSignalingPackage_MessageRequest, _mediaSignalingPackage_MessageRequest__Output>
+    MessageResponse: MessageTypeDefinition<_mediaSignalingPackage_MessageResponse, _mediaSignalingPackage_MessageResponse__Output>
+  }
+}
+

src/protos/gen/mediaSignalingPackage/MediaSignaling.ts

@@ -0,0 +1,23 @@
+// Original file: src/protos/media-signaling.proto
+
+import type * as grpc from '@grpc/grpc-js'
+import type { MethodDefinition } from '@grpc/proto-loader'
+import type { MessageRequest as _mediaSignalingPackage_MessageRequest, MessageRequest__Output as _mediaSignalingPackage_MessageRequest__Output } from '../mediaSignalingPackage/MessageRequest';
+import type { MessageResponse as _mediaSignalingPackage_MessageResponse, MessageResponse__Output as _mediaSignalingPackage_MessageResponse__Output } from '../mediaSignalingPackage/MessageResponse';
+
+export interface MediaSignalingClient extends grpc.Client {
+  Message(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_mediaSignalingPackage_MessageRequest, _mediaSignalingPackage_MessageResponse__Output>;
+  Message(options?: grpc.CallOptions): grpc.ClientDuplexStream<_mediaSignalingPackage_MessageRequest, _mediaSignalingPackage_MessageResponse__Output>;
+  message(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_mediaSignalingPackage_MessageRequest, _mediaSignalingPackage_MessageResponse__Output>;
+  message(options?: grpc.CallOptions): grpc.ClientDuplexStream<_mediaSignalingPackage_MessageRequest, _mediaSignalingPackage_MessageResponse__Output>;
+
+}
+
+export interface MediaSignalingHandlers extends grpc.UntypedServiceImplementation {
+  Message: grpc.handleBidiStreamingCall<_mediaSignalingPackage_MessageRequest__Output, _mediaSignalingPackage_MessageResponse>;
+
+}
+
+export interface MediaSignalingDefinition extends grpc.ServiceDefinition {
+  Message: MethodDefinition<_mediaSignalingPackage_MessageRequest, _mediaSignalingPackage_MessageResponse, _mediaSignalingPackage_MessageRequest__Output, _mediaSignalingPackage_MessageResponse__Output>
+}

src/protos/gen/mediaSignalingPackage/MessageRequest.ts

@@ -0,0 +1,14 @@
+// Original file: src/protos/media-signaling.proto
+
+
+export interface MessageRequest {
+  'action'?: (string);
+  'args'?: (string);
+  'requestId'?: (string);
+}
+
+export interface MessageRequest__Output {
+  'action'?: (string);
+  'args'?: (string);
+  'requestId'?: (string);
+}

src/protos/gen/mediaSignalingPackage/MessageResponse.ts

@@ -0,0 +1,14 @@
+// Original file: src/protos/media-signaling.proto
+
+
+export interface MessageResponse {
+  'action'?: (string);
+  'args'?: (string);
+  'requestId'?: (string);
+}
+
+export interface MessageResponse__Output {
+  'action'?: (string);
+  'args'?: (string);
+  'requestId'?: (string);
+}

src/protos/media-signaling.proto

@@ -1,16 +1,19 @@
 syntax = "proto3";
-package media_signaling_package;
+
+package mediaSignalingPackage;
 
 service MediaSignaling {
- rpc SendMessage(stream SendMessageRequest) returns (stream SendMessageResponse) {};
-}
-message SendMessageRequest {
-  string type = 1;
-  map<string, string> args = 2;
+ rpc Message(stream MessageRequest) returns (stream MessageResponse) {};
 }
 
-message SendMessageResponse {
-  string type = 1;
-  map<string, string> args = 2;
+message MessageRequest {
+  string action = 1;
+  string args = 2;
+  string requestId = 3;
 }
 
+message MessageResponse {
+  string action = 1;
+  string args = 2;
+  string requestId = 3;
+}