[IMP] recording

TODO

Author: ThanhDodeurOdoo

src/config.ts

@@ -64,6 +64,11 @@ export const HTTP_INTERFACE: string = process.env.HTTP_INTERFACE || "0.0.0.0";
  */
 export const PORT: number = Number(process.env.PORT) || 8070;
 
+/**
+ * Whether the recording feature is enabled, true by default.
+ */
+export const RECORDING: boolean = !FALSY_INPUT.has(process.env.LOG_TIMESTAMP!);
+
 /**
  * The number of workers to spawn (up to core limits) to manage RTC servers.
  * 0 < NUM_WORKERS <= os.availableParallelism()
@@ -197,6 +202,25 @@ export const timeouts: TimeoutConfig = Object.freeze({
     busBatch: process.env.JEST_WORKER_ID ? 10 : 300
 });
 
+export const recording = Object.freeze({
+    directory: os.tmpdir() + "/recordings",
+    enabled: RECORDING,
+    maxDuration: 1000 * 60 * 60, // 1 hour, could be a env-var.
+    fileTTL: 1000 * 60 * 60 * 24, // 24 hours
+    fileType: "mp4",
+    videoCodec: "libx264",
+    audioCodec: "aac",
+    audioLimit: 20,
+    cameraLimit: 4, // how many camera can be merged into one recording
+    screenLimit: 1,
+});
+
+export const dynamicPorts = Object.freeze({
+    min: 50000,
+    max: 59999,
+});
+
+
 // how many errors can occur before the session is closed, recovery attempts will be made until this limit is reached
 export const maxSessionErrors: number = 6;
 

src/models/channel.ts

@@ -11,6 +11,7 @@ import {
     SESSION_CLOSE_CODE,
     type SessionId,
 } from "#src/models/session.ts";
+import { Recorder } from "#src/models/recorder.ts";
 import { getWorker, type RtcWorker } from "#src/services/rtc.ts";
 
 const logger = new Logger("CHANNEL");
@@ -52,6 +53,7 @@ interface ChannelCreateOptions {
     key?: string;
     /** Whether to enable WebRTC functionality */
     useWebRtc?: boolean;
+    useRecording?: boolean;
 }
 interface JoinResult {
     /** The channel instance */
@@ -86,6 +88,8 @@ export class Channel extends EventEmitter {
     public readonly sessions = new Map<SessionId, Session>();
     /** mediasoup Worker handling this channel */
     private readonly _worker?: RtcWorker;
+    /** Manages the recording of this channel, undefined if the feature is disabled */
+    private recorder?: Recorder;
     /** Timeout for auto-closing empty channels */
     private _closeTimeout?: NodeJS.Timeout;
 
@@ -101,7 +105,7 @@ export class Channel extends EventEmitter {
         issuer: string,
         options: ChannelCreateOptions = {}
     ): Promise<Channel> {
-        const { key, useWebRtc = true } = options;
+        const { key, useWebRtc = true, useRecording = true } = options;
         const safeIssuer = `${remoteAddress}::${issuer}`;
         const oldChannel = Channel.recordsByIssuer.get(safeIssuer);
         if (oldChannel) {
@@ -111,7 +115,7 @@ export class Channel extends EventEmitter {
         const channelOptions: ChannelCreateOptions & {
             worker?: Worker;
             router?: Router;
-        } = { key };
+        } = { key, useRecording: useWebRtc && useRecording };
         if (useWebRtc) {
             channelOptions.worker = await getWorker();
             channelOptions.router = await channelOptions.worker.createRouter({
@@ -182,6 +186,8 @@ export class Channel extends EventEmitter {
         const now = new Date();
         this.createDate = now.toISOString();
         this.remoteAddress = remoteAddress;
+        this.recorder = config.recording.enabled && options.useRecording ? new Recorder(this) : undefined;
+        this.recorder?.todo();
         this.key = key ? Buffer.from(key, "base64") : undefined;
         this.uuid = crypto.randomUUID();
         this.name = `${remoteAddress}*${this.uuid.slice(-5)}`;

src/models/recorder.ts

@@ -0,0 +1,18 @@
+import {EventEmitter} from "node:events";
+import type { Channel } from "./channel";
+import {Logger} from "#src/utils/utils.ts";
+
+const logger = new Logger("RECORDER");
+
+export class Recorder extends EventEmitter {
+    channel: Channel;
+
+    constructor(channel: Channel) {
+        super();
+        this.channel = channel;
+    }
+
+    todo() {
+        logger.warn("TODO: Everything");
+    }
+}

src/models/session.ts

@@ -56,6 +56,9 @@ export enum SESSION_CLOSE_CODE {
     KICKED = "kicked",
     ERROR = "error"
 }
+export interface SessionPermissions {
+    recording?: boolean;
+}
 export interface TransportConfig {
     /** Transport identifier */
     id: string;
@@ -135,6 +138,9 @@ export class Session extends EventEmitter {
         camera: null,
         screen: null
     };
+    public permissions: SessionPermissions = {
+        recording: false
+    };
     /** Parent channel containing this session */
     private readonly _channel: Channel;
     /** Recovery timeouts for failed consumers */

src/services/auth.ts

@@ -3,7 +3,7 @@ import crypto from "node:crypto";
 import * as config from "#src/config.ts";
 import { Logger } from "#src/utils/utils.ts";
 import { AuthenticationError } from "#src/utils/errors.ts";
-import type { SessionId } from "#src/models/session.ts";
+import type { SessionId, SessionPermissions } from "#src/models/session.ts";
 import type { StringLike } from "#src/shared/types.ts";
 
 /**
@@ -43,6 +43,7 @@ interface PrivateJWTClaims {
     sfu_channel_uuid?: string;
     session_id?: SessionId;
     ice_servers?: object[];
+    permissions: SessionPermissions,
     sessionIdsByChannel?: Record<string, SessionId[]>;
     /** If provided when requesting a channel, this key will be used instead of the global key to verify JWTs related to this channel */
     key?: string;

src/services/http.ts

@@ -98,7 +98,8 @@ function setupRoutes(routeListener: RouteListener): void {
                 }
                 const channel = await Channel.create(remoteAddress, claims.iss, {
                     key: claims.key,
-                    useWebRtc: searchParams.get("webRTC") !== "false"
+                    useWebRtc: searchParams.get("webRTC") !== "false",
+                    useRecording: searchParams.get("recording") !== "false"
                 });
                 res.setHeader("Content-Type", "application/json");
                 res.statusCode = 200;

src/services/ws.ts

@@ -112,7 +112,7 @@ function connect(webSocket: WebSocket, credentials: Credentials): Session {
     const { channelUUID, jwt } = credentials;
     let channel = channelUUID ? Channel.records.get(channelUUID) : undefined;
     const authResult = verify(jwt, channel?.key);
-    const { sfu_channel_uuid, session_id } = authResult;
+    const { sfu_channel_uuid, session_id, permissions } = authResult;
     if (!channelUUID && sfu_channel_uuid) {
         // Cases where the channelUUID is not provided in the credentials for backwards compatibility with version 1.1 and earlier.
         channel = Channel.records.get(sfu_channel_uuid);
@@ -131,6 +131,7 @@ function connect(webSocket: WebSocket, credentials: Credentials): Session {
     webSocket.send(""); // client can start using ws after this message.
     const bus = new Bus(webSocket, { batchDelay: config.timeouts.busBatch });
     const { session } = Channel.join(channel.uuid, session_id);
+    session.permissions = permissions;
     session.once("close", ({ code }: { code: string }) => {
         let wsCloseCode = WS_CLOSE_CODE.CLEAN;
         switch (code) {