'use strict'; // These are the https socket.io server parameters. var config = require('./config'); // This port is needed because Apache serves HTTPS on port 443. var PORT = 8443; // The peerName of the publisher in a given room. var PUBLISHER_PEER = 'publisher'; // Whether to print verbose MediaSoup debugging logs. var DEBUG = false; // The log* properties only work if process.env.DEBUG is set appropriately. var SERVER_OPTIONS = { //logLevel: 'warn', //logTags: ['info', 'ice', 'rtp', 'rtcp', 'srtp'], }; if (DEBUG) { process.env.DEBUG = 'mediasoup:*'; SERVER_OPTIONS.logLevel = 'debug'; SERVER_OPTIONS.logTags = ['info', 'ice', 'dtls', 'rtp', 'srtp', 'rtcp', 'rbe', 'rtx']; } // Use h264, which is the only video codec shared between Safari 11 and Edge. // Firefox and Chrome have no issues with any codec. // Maybe someday we can use VP8, once Edge is gone and Safari supports it. var MEDIA_CODECS = [ { kind : "audio", name : "opus", clockRate : 48000, channels : 2, parameters : { useinbandfec : 1 } }, { kind : "video", name : "vp8", clockRate : 90000, parameters : { "packetization-mode" : 1, "profile-level-id" : "42e01f", "level-asymmetry-allowed" : 1 } }, ]; // The modules we need. var https = require('https'); var fs = require('fs'); var mediasoup = require('mediasoup'); // Create a MediaSoup server (and all its workers). var ms = mediasoup.Server(SERVER_OPTIONS); console.log(config); //process.exit(); // Create an HTTPS server with the letsencrypt certificates. var server = https.createServer({ key: fs.readFileSync(config.key2), cert: fs.readFileSync(config.cert2 ), }, function onRequest(req, res) { res.writeHead(404); res.end('not found'); }); console.log('MediaSoupServer start...'); // Have HTTPS listen on the specified port. server.listen(PORT, function onListen() { //console.log('listening on', PORT); }); // Mapping of streamids to MediaSoup rooms. // Note that we have only one publisher per room. We put them in // separate rooms to take advantage of distributing the load // among mediasoup-workers (each room needs to run entirely on one // worker). // // This is the only global collection. The rest are scoped to // the individual socket.io connection. var rooms = {}; // We listen for socket.io only. var io = require('socket.io').listen(server); io.sockets.on('connection', function newConn(socket) { // New connection from a web browser running client/index.html. var id = socket.id; // Generate a unique address for logging this connection's details. var addr = id + ':' + '*' + ':'; // A "session" is an identifier that is scoped to the current connections // which the cilent can use to publish/subscribe to different streamids // without requiring separate socket.io connections. // Map of sessions to the streamid they are publishing/subscribing to. var streams = {}; // Map of sessions to `true` if they are a publisher. var canPublish = {}; // Map of sessions to the MediaSoup peer they correspond to. var peers = {}; // Let them know we got a connection. //console.log(addr, 'connected'); // Helper function to send an object to the client. function send(addr, obj) { //console.log(addr, 'send', obj); socket.emit('ms', obj); } // Helper function to release all resources used by a given session. function closeSession(addr, session) { // Remove any existing publisher f lag. delete canPublish[session]; if (peers[session]) { // If they have a peer, close it. peers[session].close(); } delete peers[session]; // Remove the stream mapping for the session. var streamid = streams[session]; delete streams[session] // If there is a room, clean up if it is no longer used. var room = rooms[streamid]; if (room && room.peers.length === 0) { //console.log(addr, 'close empty streamid', streamid); room.close(); delete rooms[streamid]; } } // Clean up all of this connection's sessions on disconnect. socket.on('disconnect', function disco(reason) { //console.log(addr, 'disconnected:', reason); for (var session in streams) { closeSession(addr, session); } }); // Handle MediaSoup-related messages from the client. socket.on('ms', function recv(obj) { // Check which session this message is for. var session = obj.meta.session; // Shadow the addr variable with the current session's information. var addr = id + ':' + session + ':'; //console.log(addr, 'recv', obj); // Dispatch on the object's type. switch (obj.type) { case 'MS_STOP': { // Terminate a session. //console.log(addr, 'stopping session: streamid', streams[session]); closeSession(addr, session); break; } case 'MS_START': { // Initiate a new session. // FIXME: Should not allow overwriting an existing sesssion. var streamid = streams[session] = obj.payload.streamid; //console.log(addr, 'starting session: streamid', streamid); // FIXME: Authenticate here. if (obj.payload.kind === 'publish') { // They're a publisher. canPublish[session] = true; } // Create a new room for the streamid if there isn't one. if (!rooms[streamid]) { //console.log(addr, 'new streamid', streamid); rooms[streamid] = ms.Room(MEDIA_CODECS); } // Tell them we're ready for MediaSoup messages. send(addr, {type: 'MS_RESPONSE', payload: obj.payload, meta: obj.meta}); break; } case 'MS_SEND': { // This is a message sent directly by the MediaSoup client. var target; // Look up the particular details of this session. var isPublisher = canPublish[session]; var streamid = streams[session]; var room = rooms[streamid]; var peer = peers[session]; // Check to see the target: either the current room, or this peer. switch (obj.payload.target) { case 'room': target = room; break; case 'peer': target = peer; break; } if (obj.meta.notification) { // It was a notification. if (!target) { //console.log(addr, 'unknown notification target', obj.payload.target); // FIXME: Maybe send a special MS_ERROR to the client side, where it can // be handled and logged, too. // For now we just drop it on the floor. break; } target.receiveNotification(obj.payload); break; } if (!target) { // Send an error response (mirroring the object meta) to say that it // was not a valid target. //console.log(addr, 'unknown request target', obj.payload.target); send(addr, {type: 'MS_ERROR', payload: 'unknown request target', meta: obj.meta}); break; } if (obj.payload.method === 'join') { // Special meaning of the 'join' method: restrict publshing to just // one session globally. if (isPublisher) { // Publisher has a reserved name. obj.payload.peerName = PUBLISHER_PEER; } else if (obj.payload.peerName === PUBLISHER_PEER) { // A subscriber attempted to be the publisher. // Just prefix their peerName so it doesn't replace // the real publisher. obj.payload.peerName = 'pseudo' + PUBLISHER_PEER; } // Kick out the old peer. This is the only really sane thing // we can do, or else we would have competing pubsub for // the same name. var oldPeer = room.getPeerByName(obj.payload.peerName); if (oldPeer) { // Let MediaSoup generate the right messages. oldPeer.close(); } } // Tell the request to the room/peer target. target.receiveRequest(obj.payload) .then(function onResponse(response) { // If the target was successful, process the response. if (obj.payload.method === 'join') { // Detected a join request, so get the new peer object. var peerName = obj.payload.peerName; peer = peers[session] = room.getPeerByName(peerName); // Install our notification handler. peer.on('notify', function onNotify(notification) { if (notification.method === 'newPeer' || notification.method === 'peerClosed') { if (!isPublisher && notification.name !== PUBLISHER_PEER) { // Skip the notification to hide all peers but the publisher // from non-publishers. return; } } // Send the notification to the client. send(addr, {type: 'MS_NOTIFY', payload: notification, meta: session}); }); // Log that we joined. //console.log(addr, 'new peer', JSON.stringify(peerName), 'joined streamid', streamid); if (!isPublisher) { // Filter out all peers but the publisher to hide them // from non-publishers. response = Object.assign({}, response, {peers: response.peers.filter(function(peer) { // Reveal the publisher, if any. return peer.name === PUBLISHER_PEER; })}); } } // Send the response to the client with the same metadata (message id and session). send(addr, {type: 'MS_RESPONSE', payload: response, meta: obj.meta}); }) .catch(function onError(err) { // Error processing the request, so send an error to the client's error callback. send(addr, {type: 'MS_ERROR', payload: err, meta: obj.meta}); }); break; } default: // Didn't find valid MS_* protocol type. throw Error('Unrecognized object type ' + obj.type); } }); });