feat: add RouterService

src/apis/master.ts

@@ -1,4 +1,4 @@
-import { PeerService, RoomService } from '../services/index.js';
+import { PeerService, RoomService, RouterService } from '../services/index.js';
 import { RouteConfig, getDataSource } from '../utils/index.js';
 
 export default [
@@ -16,6 +16,13 @@ export default [
       return new RoomService(getDataSource()).getCapabilities(data);
     },
   },
+  {
+    method: 'POST',
+    url: '/rooms/:roomId/join',
+    handler: (data) => {
+      return new RouterService(getDataSource()).getOrCreate(data);
+    },
+  },
   {
     method: 'POST',
     url: '/rooms/:roomId/producer_peers',

src/entities/media.router.ts

@@ -5,11 +5,13 @@ import {
   Column,
   ManyToOne,
   PrimaryColumn,
+  Index,
 } from 'typeorm';
 import { MediaSlave } from './media.slave.js';
 import { MediaRoom } from './media.room.js';
 
 @Entity()
+@Index(['slaveId', 'roomId'], { unique: true })
 export class MediaRouter extends BaseEntity {
   @PrimaryColumn('uuid')
   id!: string;

src/services/index.ts

@@ -1,4 +1,5 @@
 export * from './slave.js';
 export * from './room.js';
 export * from './peer.js';
+export * from './router.js';
 export * from './mediasoup/index.js';

src/services/room.ts

@@ -1,12 +1,14 @@
+import { constants } from '../constants.js';
 import { MediaRoom } from '../entities/index.js';
 import { fetchApi } from '../utils/index.js';
 import { ServiceError, BaseService } from './base.js';
 import { SlaveService } from './slave.js';
 
 export class RoomService extends BaseService {
-  // for master server
   async create(data: { metadata?: any }) {
-    const slave = await this.createService(SlaveService).getForNewRoom();
+    const slave = await this.createService(SlaveService).getFor(
+      constants.PRODUCER
+    );
     if (slave) {
       const result = await fetchApi({
         host: slave.internalHost,

src/services/router.ts

@@ -0,0 +1,56 @@
+import { constants } from '../constants.js';
+import { MediaRouter } from '../entities/index.js';
+import { fetchApi } from '../utils/api.js';
+import { BaseService, ServiceError } from './base.js';
+import { SlaveService } from './slave.js';
+
+export class RouterService extends BaseService {
+  async create(data: { roomId: string }) {
+    const slave = await this.createService(SlaveService).getFor(
+      constants.CONSUMER
+    );
+    if (slave) {
+      const result = await fetchApi({
+        host: slave.internalHost,
+        port: slave.apiPort,
+        path: '/routers',
+        method: 'POST',
+      });
+      const mediaRouter = new MediaRouter();
+      mediaRouter.id = result.id;
+      mediaRouter.slaveId = slave.id;
+      Object.assign(mediaRouter, data);
+      await this.dataSource.getRepository(MediaRouter).save(mediaRouter);
+      return { result };
+    }
+    throw new ServiceError(404, 'Slave not found');
+  }
+
+  async get(data: { roomId: string }) {
+    const router = await this.dataSource
+      .createQueryBuilder(MediaRouter, 'router')
+      .leftJoinAndSelect('router.slave', 'slave')
+      .where('router.roomId = :roomId', { roomId: data.roomId })
+      .andWhere('slave.peerCount < slave.maxPeer')
+      .getOne();
+    if (router) {
+      const result = await fetchApi({
+        host: router.slave.internalHost,
+        port: router.slave.apiPort,
+        path: '/routers/:routerId',
+        method: 'GET',
+        data: { routerId: router.id },
+      });
+      return { ...result, id: data.roomId };
+    }
+    return null;
+  }
+
+  async getOrCreate(data: { roomId: string }) {
+    const result = await this.get(data);
+    if (result) {
+      return result;
+    }
+    return this.create(data);
+  }
+}

src/services/slave.ts

@@ -55,12 +55,12 @@ export class SlaveService extends BaseService {
     });
   }
 
-  getForNewRoom() {
+  getFor(type: string) {
     return this.dataSource
       .createQueryBuilder()
       .select('slave')
       .from(MediaSlave, 'slave')
-      .where('slave.for = :for', { for: constants.PRODUCER })
+      .where('slave.for = :for', { for: type })
       .andWhere('slave.peerCount < slave.maxPeer')
       .getOne();
   }