Initial commit

mediasoup-server/server.js

@@ -0,0 +1,703 @@
+/**
+ * MyTelegram Mediasoup SFU Server
+ * Production-ready WebRTC SFU for group calls
+ */
+
+const mediasoup = require('mediasoup');
+const express = require('express');
+const http = require('http');
+const socketIO = require('socket.io');
+const cors = require('cors');
+const winston = require('winston');
+require('dotenv').config();
+
+// ==================== Configuration ====================
+
+const config = {
+  listenIp: process.env.MEDIASOUP_LISTEN_IP || '0.0.0.0',
+  announcedIp: process.env.MEDIASOUP_ANNOUNCED_IP || '127.0.0.1',
+  httpPort: parseInt(process.env.PORT) || 3200,
+  rtcMinPort: parseInt(process.env.RTC_MIN_PORT) || 10000,
+  rtcMaxPort: parseInt(process.env.RTC_MAX_PORT) || 10100,
+  logLevel: process.env.LOG_LEVEL || 'debug',
+};
+
+// ==================== Logger Setup ====================
+
+const logger = winston.createLogger({
+  level: config.logLevel,
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.printf(({ timestamp, level, message, ...meta }) => {
+      return `[${timestamp}] [${level.toUpperCase()}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ''}`;
+    })
+  ),
+  transports: [
+    new winston.transports.Console(),
+    new winston.transports.File({ filename: 'mediasoup-error.log', level: 'error' }),
+    new winston.transports.File({ filename: 'mediasoup-combined.log' })
+  ]
+});
+
+// ==================== Express App Setup ====================
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+const server = http.createServer(app);
+const io = socketIO(server, {
+  cors: {
+    origin: '*',
+    methods: ['GET', 'POST']
+  }
+});
+
+// ==================== Global State ====================
+
+let worker;
+let router;
+const rooms = new Map(); // roomId -> Room
+const peers = new Map(); // socketId -> Peer
+
+class Room {
+  constructor(roomId) {
+    this.id = roomId;
+    this.peers = new Map(); // peerId -> Peer
+    this.router = null;
+    logger.info(`Room created: ${roomId}`);
+  }
+
+  addPeer(peer) {
+    this.peers.set(peer.id, peer);
+    logger.info(`Peer ${peer.id} added to room ${this.id}`);
+  }
+
+  removePeer(peerId) {
+    const peer = this.peers.get(peerId);
+    if (peer) {
+      peer.close();
+      this.peers.delete(peerId);
+      logger.info(`Peer ${peerId} removed from room ${this.id}`);
+    }
+    
+    if (this.peers.size === 0) {
+      logger.info(`Room ${this.id} is empty, closing...`);
+      return true; // Room can be deleted
+    }
+    return false;
+  }
+
+  getPeer(peerId) {
+    return this.peers.get(peerId);
+  }
+
+  getAllPeers() {
+    return Array.from(this.peers.values());
+  }
+
+  close() {
+    for (const peer of this.peers.values()) {
+      peer.close();
+    }
+    this.peers.clear();
+    logger.info(`Room ${this.id} closed`);
+  }
+}
+
+class Peer {
+  constructor(id, socket, roomId) {
+    this.id = id;
+    this.socket = socket;
+    this.roomId = roomId;
+    this.transports = new Map(); // transportId -> Transport
+    this.producers = new Map(); // producerId -> Producer
+    this.consumers = new Map(); // consumerId -> Consumer
+    this.rtpCapabilities = null;
+    logger.info(`Peer created: ${id} in room ${roomId}`);
+  }
+
+  addTransport(transport) {
+    this.transports.set(transport.id, transport);
+    logger.debug(`Transport ${transport.id} added to peer ${this.id}`);
+  }
+
+  addProducer(producer) {
+    this.producers.set(producer.id, producer);
+    logger.info(`Producer ${producer.id} (${producer.kind}) added to peer ${this.id}`);
+  }
+
+  addConsumer(consumer) {
+    this.consumers.set(consumer.id, consumer);
+    logger.info(`Consumer ${consumer.id} (${consumer.kind}) added to peer ${this.id}`);
+  }
+
+  close() {
+    logger.info(`Closing peer ${this.id}`);
+    
+    // Close all consumers
+    for (const consumer of this.consumers.values()) {
+      consumer.close();
+    }
+    this.consumers.clear();
+
+    // Close all producers
+    for (const producer of this.producers.values()) {
+      producer.close();
+    }
+    this.producers.clear();
+
+    // Close all transports
+    for (const transport of this.transports.values()) {
+      transport.close();
+    }
+    this.transports.clear();
+  }
+}
+
+// ==================== Mediasoup Worker & Router ====================
+
+async function createWorker() {
+  logger.info('Creating Mediasoup worker...');
+  
+  worker = await mediasoup.createWorker({
+    logLevel: 'warn',
+    rtcMinPort: config.rtcMinPort,
+    rtcMaxPort: config.rtcMaxPort,
+  });
+
+  worker.on('died', () => {
+    logger.error('Mediasoup worker died, exiting in 2 seconds...');
+    setTimeout(() => process.exit(1), 2000);
+  });
+
+  logger.info(`Mediasoup worker created [PID: ${worker.pid}]`);
+  return worker;
+}
+
+async function createRouter() {
+  logger.info('Creating Mediasoup router...');
+  
+  const mediaCodecs = [
+    {
+      kind: 'audio',
+      mimeType: 'audio/opus',
+      clockRate: 48000,
+      channels: 2
+    },
+    {
+      kind: 'video',
+      mimeType: 'video/VP8',
+      clockRate: 90000,
+      parameters: {
+        'x-google-start-bitrate': 1000
+      }
+    },
+    {
+      kind: 'video',
+      mimeType: 'video/H264',
+      clockRate: 90000,
+      parameters: {
+        'packetization-mode': 1,
+        'profile-level-id': '42e01f',
+        'level-asymmetry-allowed': 1
+      }
+    }
+  ];
+
+  router = await worker.createRouter({ mediaCodecs });
+  logger.info(`Mediasoup router created [ID: ${router.id}]`);
+  return router;
+}
+
+// ==================== HTTP API Endpoints ====================
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    worker: {
+      pid: worker?.pid,
+      dead: worker?.closed
+    },
+    router: {
+      id: router?.id,
+      closed: router?.closed
+    },
+    rooms: rooms.size,
+    peers: peers.size
+  });
+});
+
+// Get DTLS fingerprint (for MyTelegram backend)
+app.get('/api/dtls-fingerprint', (req, res) => {
+  if (!router) {
+    return res.status(503).json({ error: 'Router not initialized' });
+  }
+
+  const fingerprint = router.rtpCapabilities.headerExtensions.length > 0 
+    ? router.rtpCapabilities 
+    : null;
+
+  // Get DTLS parameters from a temporary transport
+  router.createWebRtcTransport({
+    listenIps: [{ ip: config.listenIp, announcedIp: config.announcedIp }],
+    enableUdp: true,
+    enableTcp: false,
+    preferUdp: true
+  }).then(transport => {
+    const dtls = transport.dtlsParameters;
+    res.json({
+      algorithm: dtls.fingerprints[0].algorithm,
+      value: dtls.fingerprints[0].value
+    });
+    transport.close();
+  }).catch(err => {
+    logger.error('Failed to get DTLS fingerprint:', err);
+    res.status(500).json({ error: err.message });
+  });
+});
+
+// Get router RTP capabilities
+app.get('/api/rtp-capabilities', (req, res) => {
+  if (!router) {
+    return res.status(503).json({ error: 'Router not initialized' });
+  }
+  res.json(router.rtpCapabilities);
+});
+
+// Get room info
+app.get('/api/rooms/:roomId', (req, res) => {
+  const room = rooms.get(req.params.roomId);
+  if (!room) {
+    return res.status(404).json({ error: 'Room not found' });
+  }
+
+  res.json({
+    id: room.id,
+    peers: room.getAllPeers().map(p => ({
+      id: p.id,
+      producers: p.producers.size,
+      consumers: p.consumers.size
+    }))
+  });
+});
+
+// Create WebRTC transport for Telegram MTProto integration
+app.post('/api/transports/create', async (req, res) => {
+  try {
+    const { roomId, peerId, direction } = req.body;
+    
+    logger.info(`Creating ${direction} transport for peer ${peerId} in room ${roomId}`);
+    
+    const transport = await router.createWebRtcTransport({
+      listenIps: [
+        {
+          ip: config.listenIp,
+          announcedIp: config.announcedIp
+        }
+      ],
+      enableUdp: true,
+      enableTcp: false,
+      preferUdp: true,
+      initialAvailableOutgoingBitrate: 1000000,
+      minimumAvailableOutgoingBitrate: 600000,
+      maxSctpMessageSize: 262144,
+      maxIncomingBitrate: 1500000
+    });
+
+    // Store transport info
+    const key = `${roomId}:${peerId}:${direction}`;
+    if (!global.transports) global.transports = new Map();
+    global.transports.set(key, transport);
+    global.transports.set(transport.id, transport);
+
+    logger.info(`Transport ${transport.id} created on port ${transport.tuple?.localPort || 'dynamic'}`);
+
+    res.json({
+      id: transport.id,
+      iceParameters: transport.iceParameters,
+      iceCandidates: transport.iceCandidates,
+      dtlsParameters: transport.dtlsParameters
+    });
+
+  } catch (error) {
+    logger.error('Error creating transport:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Connect transport with DTLS parameters from client
+app.post('/api/transports/connect', async (req, res) => {
+  try {
+    const { transportId, dtlsParameters } = req.body;
+    
+    logger.info(`Connecting transport ${transportId}`);
+    
+    const transport = global.transports?.get(transportId);
+    if (!transport) {
+      return res.status(404).json({ error: 'Transport not found' });
+    }
+
+    await transport.connect({ dtlsParameters });
+    
+    logger.info(`Transport ${transportId} connected`);
+    res.json({ success: true });
+
+  } catch (error) {
+    logger.error('Error connecting transport:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Create producer (for sending media)
+app.post('/api/produce', async (req, res) => {
+  try {
+    const { transportId, kind, rtpParameters } = req.body;
+    
+    logger.info(`Creating producer on transport ${transportId}, kind: ${kind}`);
+    
+    const transport = global.transports?.get(transportId);
+    if (!transport) {
+      return res.status(404).json({ error: 'Transport not found' });
+    }
+
+    const producer = await transport.produce({
+      kind,
+      rtpParameters
+    });
+
+    logger.info(`Producer ${producer.id} created`);
+    res.json({ producerId: producer.id });
+
+  } catch (error) {
+    logger.error('Error creating producer:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Create consumer (for receiving media)
+app.post('/api/consume', async (req, res) => {
+  try {
+    const { transportId, producerId, rtpCapabilities } = req.body;
+    
+    logger.info(`Creating consumer on transport ${transportId} for producer ${producerId}`);
+    
+    const transport = global.transports?.get(transportId);
+    if (!transport) {
+      return res.status(404).json({ error: 'Transport not found' });
+    }
+
+    // Check if can consume
+    if (!router.canConsume({ producerId, rtpCapabilities })) {
+      return res.status(400).json({ error: 'Cannot consume' });
+    }
+
+    const consumer = await transport.consume({
+      producerId,
+      rtpCapabilities,
+      paused: false
+    });
+
+    logger.info(`Consumer ${consumer.id} created`);
+    
+    res.json({
+      id: consumer.id,
+      producerId: producerId,
+      kind: consumer.kind,
+      rtpParameters: consumer.rtpParameters
+    });
+
+  } catch (error) {
+    logger.error('Error creating consumer:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// ==================== Socket.IO Signaling ====================
+
+io.on('connection', (socket) => {
+  logger.info(`Socket connected: ${socket.id}`);
+
+  socket.on('join-room', async ({ roomId, peerId }, callback) => {
+    try {
+      logger.info(`Peer ${peerId} joining room ${roomId}`);
+
+      // Get or create room
+      let room = rooms.get(roomId);
+      if (!room) {
+        room = new Room(roomId);
+        room.router = router;
+        rooms.set(roomId, room);
+      }
+
+      // Create peer
+      const peer = new Peer(peerId, socket, roomId);
+      room.addPeer(peer);
+      peers.set(socket.id, peer);
+
+      socket.join(roomId);
+
+      callback({
+        success: true,
+        rtpCapabilities: router.rtpCapabilities
+      });
+
+    } catch (error) {
+      logger.error('Error joining room:', error);
+      callback({ success: false, error: error.message });
+    }
+  });
+
+  socket.on('create-transport', async ({ roomId, direction }, callback) => {
+    try {
+      const peer = peers.get(socket.id);
+      if (!peer) {
+        throw new Error('Peer not found');
+      }
+
+      const transport = await router.createWebRtcTransport({
+        listenIps: [
+          {
+            ip: config.listenIp,
+            announcedIp: config.announcedIp
+          }
+        ],
+        enableUdp: true,
+        enableTcp: false,
+        preferUdp: true,
+        initialAvailableOutgoingBitrate: 1000000,
+        minimumAvailableOutgoingBitrate: 600000,
+        maxSctpMessageSize: 262144,
+        maxIncomingBitrate: 1500000
+      });
+
+      peer.addTransport(transport);
+
+      transport.on('dtlsstatechange', (dtlsState) => {
+        logger.debug(`Transport ${transport.id} DTLS state: ${dtlsState}`);
+        if (dtlsState === 'closed') {
+          transport.close();
+        }
+      });
+
+      transport.on('close', () => {
+        logger.info(`Transport ${transport.id} closed`);
+      });
+
+      callback({
+        success: true,
+        transport: {
+          id: transport.id,
+          iceParameters: transport.iceParameters,
+          iceCandidates: transport.iceCandidates,
+          dtlsParameters: transport.dtlsParameters
+        }
+      });
+
+    } catch (error) {
+      logger.error('Error creating transport:', error);
+      callback({ success: false, error: error.message });
+    }
+  });
+
+  socket.on('connect-transport', async ({ transportId, dtlsParameters }, callback) => {
+    try {
+      const peer = peers.get(socket.id);
+      if (!peer) {
+        throw new Error('Peer not found');
+      }
+
+      const transport = peer.transports.get(transportId);
+      if (!transport) {
+        throw new Error('Transport not found');
+      }
+
+      await transport.connect({ dtlsParameters });
+      logger.info(`Transport ${transportId} connected for peer ${peer.id}`);
+
+      callback({ success: true });
+
+    } catch (error) {
+      logger.error('Error connecting transport:', error);
+      callback({ success: false, error: error.message });
+    }
+  });
+
+  socket.on('produce', async ({ transportId, kind, rtpParameters }, callback) => {
+    try {
+      const peer = peers.get(socket.id);
+      if (!peer) {
+        throw new Error('Peer not found');
+      }
+
+      const transport = peer.transports.get(transportId);
+      if (!transport) {
+        throw new Error('Transport not found');
+      }
+
+      const producer = await transport.produce({
+        kind,
+        rtpParameters
+      });
+
+      peer.addProducer(producer);
+
+      producer.on('transportclose', () => {
+        logger.info(`Producer ${producer.id} transport closed`);
+        producer.close();
+        peer.producers.delete(producer.id);
+      });
+
+      // Notify other peers in room about new producer
+      const room = rooms.get(peer.roomId);
+      if (room) {
+        socket.to(peer.roomId).emit('new-producer', {
+          peerId: peer.id,
+          producerId: producer.id,
+          kind: producer.kind
+        });
+      }
+
+      callback({
+        success: true,
+        producerId: producer.id
+      });
+
+    } catch (error) {
+      logger.error('Error producing:', error);
+      callback({ success: false, error: error.message });
+    }
+  });
+
+  socket.on('consume', async ({ transportId, producerId, rtpCapabilities }, callback) => {
+    try {
+      const peer = peers.get(socket.id);
+      if (!peer) {
+        throw new Error('Peer not found');
+      }
+
+      const transport = peer.transports.get(transportId);
+      if (!transport) {
+        throw new Error('Transport not found');
+      }
+
+      // Find the producer peer
+      const room = rooms.get(peer.roomId);
+      let producer = null;
+      for (const otherPeer of room.getAllPeers()) {
+        producer = otherPeer.producers.get(producerId);
+        if (producer) break;
+      }
+
+      if (!producer) {
+        throw new Error('Producer not found');
+      }
+
+      // Check if router can consume
+      if (!router.canConsume({ producerId, rtpCapabilities })) {
+        throw new Error('Cannot consume');
+      }
+
+      const consumer = await transport.consume({
+        producerId,
+        rtpCapabilities,
+        paused: false
+      });
+
+      peer.addConsumer(consumer);
+
+      consumer.on('transportclose', () => {
+        logger.info(`Consumer ${consumer.id} transport closed`);
+        consumer.close();
+        peer.consumers.delete(consumer.id);
+      });
+
+      consumer.on('producerclose', () => {
+        logger.info(`Consumer ${consumer.id} producer closed`);
+        socket.emit('consumer-closed', { consumerId: consumer.id });
+        consumer.close();
+        peer.consumers.delete(consumer.id);
+      });
+
+      callback({
+        success: true,
+        consumer: {
+          id: consumer.id,
+          producerId: producerId,
+          kind: consumer.kind,
+          rtpParameters: consumer.rtpParameters
+        }
+      });
+
+    } catch (error) {
+      logger.error('Error consuming:', error);
+      callback({ success: false, error: error.message });
+    }
+  });
+
+  socket.on('disconnect', () => {
+    logger.info(`Socket disconnected: ${socket.id}`);
+    
+    const peer = peers.get(socket.id);
+    if (peer) {
+      const room = rooms.get(peer.roomId);
+      if (room) {
+        const isEmpty = room.removePeer(peer.id);
+        if (isEmpty) {
+          rooms.delete(room.id);
+        }
+        
+        // Notify other peers
+        socket.to(peer.roomId).emit('peer-left', { peerId: peer.id });
+      }
+      peers.delete(socket.id);
+    }
+  });
+});
+
+// ==================== Server Startup ====================
+
+async function startServer() {
+  try {
+    await createWorker();
+    await createRouter();
+
+    server.listen(config.httpPort, () => {
+      logger.info(`==============================================`);
+      logger.info(`MyTelegram Mediasoup SFU Server Started`);
+      logger.info(`==============================================`);
+      logger.info(`HTTP API: http://localhost:${config.httpPort}`);
+      logger.info(`WebRTC RTC Ports: ${config.rtcMinPort}-${config.rtcMaxPort}`);
+      logger.info(`Announced IP: ${config.announcedIp}`);
+      logger.info(`==============================================`);
+    });
+
+  } catch (error) {
+    logger.error('Failed to start server:', error);
+    process.exit(1);
+  }
+}
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  logger.info('Shutting down gracefully...');
+  
+  // Close all rooms
+  for (const room of rooms.values()) {
+    room.close();
+  }
+  rooms.clear();
+  peers.clear();
+
+  if (worker) {
+    worker.close();
+  }
+
+  server.close(() => {
+    logger.info('Server closed');
+    process.exit(0);
+  });
+});
+
+startServer();