[mirotalksfu] - refactoring

app/src/Peer.js

@@ -109,7 +109,11 @@ module.exports = class Peer {
                 rtpParameters: producer_rtpParameters,
             });
 
-            const { id, appData, type, rtpParameters } = producer;
+            if (!producer) {
+                throw new Error(`Producer type: ${producer_type} kind: ${producer_kind} not found`);
+            }
+
+            const { id, appData, type, kind, rtpParameters } = producer;
 
             appData.mediaType = producer_type;
 
@@ -119,13 +123,13 @@ module.exports = class Peer {
                 const { scalabilityMode } = rtpParameters.encodings[0];
                 const spatialLayer = parseInt(scalabilityMode.substring(1, 2)); // 1/2/3
                 const temporalLayer = parseInt(scalabilityMode.substring(3, 4)); // 1/2/3
-                log.debug(`Producer [${type}] created with ID ${id}`, {
+                log.debug(`Producer [${type}-${kind}] ----->`, {
                     scalabilityMode,
                     spatialLayer,
                     temporalLayer,
                 });
             } else {
-                log.debug(`Producer of type ${type} created with ID ${id}`);
+                log.debug('Producer ----->', { type: type, kind: kind });
             }
 
             producer.on('transportclose', () => {
@@ -172,6 +176,10 @@ module.exports = class Peer {
                 paused: false,
             });
 
+            if (!consumer) {
+                throw new Error(`Consumer for producer ID ${producer_id} not found`);
+            }
+
             const { id, type, kind, rtpParameters, producerPaused } = consumer;
 
             if (['simulcast', 'svc'].includes(type)) {
@@ -182,13 +190,13 @@ module.exports = class Peer {
                     spatialLayer: spatialLayer,
                     temporalLayer: temporalLayer,
                 });
-                log.debug(`Consumer [${type}] ----->`, {
+                log.debug(`Consumer [${type}-${kind}] ----->`, {
                     scalabilityMode,
                     spatialLayer,
                     temporalLayer,
                 });
             } else {
-                log.debug('Consumer ----->', { type: type });
+                log.debug('Consumer ----->', { type: type, kind: kind });
             }
 
             consumer.on('transportclose', () => {

app/src/Room.js

@@ -256,6 +256,10 @@ module.exports = class Room {
                 initialAvailableOutgoingBitrate,
             });
 
+            if (!transport) {
+                throw new Error('Failed to create WebRTC transport');
+            }
+
             const { id, iceParameters, iceCandidates, dtlsParameters } = transport;
 
             if (maxIncomingBitrate) {

app/src/Server.js

@@ -1344,11 +1344,19 @@ function startServer() {
 
             const room = roomList.get(socket.room_id);
 
-            log.debug('Connect transport', getPeerName(room));
+            const peer_name = getPeerName(room, false);
 
-            await room.connectPeerTransport(socket.id, transport_id, dtlsParameters);
+            log.debug('Connect transport', { peer_name: peer_name, transport_id: transport_id });
 
-            callback('success');
+            try {
+                await room.connectPeerTransport(socket.id, transport_id, dtlsParameters);
+                callback('success');
+            } catch (err) {
+                log.error('Connect transport error', err.message);
+                callback({
+                    error: err.message,
+                });
+            }
         });
 
         socket.on('produce', async ({ producerTransportId, kind, appData, rtpParameters }, callback) => {
@@ -1371,30 +1379,36 @@ function startServer() {
 
             await room.getPeers().get(socket.id).updatePeerInfo(data);
 
-            const producer_id = await room.produce(
+            try {
-                socket.id,
+                const producer_id = await room.produce(
-                producerTransportId,
+                    socket.id,
-                rtpParameters,
+                    producerTransportId,
-                kind,
+                    rtpParameters,
-                appData.mediaType,
+                    kind,
-            );
+                    appData.mediaType,
+                );
 
-            log.debug('Produce', {
+                log.debug('Produce', {
-                kind: kind,
+                    kind: kind,
-                type: appData.mediaType,
+                    type: appData.mediaType,
-                peer_name: peer_name,
+                    peer_name: peer_name,
-                peer_id: socket.id,
+                    peer_id: socket.id,
-                producer_id: producer_id,
+                    producer_id: producer_id,
-            });
+                });
 
-            // add & monitor producer audio level
+                // add & monitor producer audio level
-            if (kind === 'audio') {
+                if (kind === 'audio') {
-                room.addProducerToAudioLevelObserver({ producerId: producer_id });
+                    room.addProducerToAudioLevelObserver({ producerId: producer_id });
+                }
+                callback({
+                    producer_id,
+                });
+            } catch (err) {
+                log.error('Producer transport error', err.message);
+                callback({
+                    error: err.message,
+                });
             }
-
-            callback({
-                producer_id,
-            });
         });
 
         socket.on('consume', async ({ consumerTransportId, producerId, rtpCapabilities }, callback) => {
@@ -1404,15 +1418,24 @@ function startServer() {
 
             const room = roomList.get(socket.room_id);
 
-            const params = await room.consume(socket.id, consumerTransportId, producerId, rtpCapabilities);
+            const peer_name = getPeerName(room, false);
 
-            log.debug('Consuming', {
+            try {
-                peer_name: getPeerName(room, false),
+                const params = await room.consume(socket.id, consumerTransportId, producerId, rtpCapabilities);
-                producer_id: producerId,
-                consumer_id: params ? params.id : undefined,
-            });
 
-            callback(params);
+                log.debug('Consuming', {
+                    peer_name: peer_name,
+                    producer_id: producerId,
+                    consumer_id: params ? params.id : undefined,
+                });
+
+                callback(params);
+            } catch (err) {
+                log.error('Consumer transport error', err.message);
+                callback({
+                    error: err.message,
+                });
+            }
         });
 
         socket.on('producerClosed', (data) => {