Add Homer events

server/config.example.js

@@ -1,7 +1,5 @@
 module.exports =
 {
-	// DEBUG env variable For the NPM debug module.
-	debug  : '*INFO* *WARN* *ERROR* *mediasoup-worker*',
 	// Listening hostname for `gulp live|open`.
 	domain : 'localhost',
 	tls    :

server/lib/homer.js

@@ -0,0 +1,359 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const Logger = require('./Logger');
+
+const STATS_INTERVAL = 4000; // TODO
+
+const logger = new Logger('Homer');
+
+function homer(server)
+{
+	if (!process.env.MEDIASOUP_HOMER_OUTPUT)
+		throw new Error('MEDIASOUP_HOMER_OUTPUT env not set');
+
+	server.on('newroom', (room) =>
+	{
+		const fileName = path.join(process.env.MEDIASOUP_HOMER_OUTPUT, String(room.id));
+
+		console.warn(fileName);
+		const stream = fs.createWriteStream(fileName, { flags: 'a' });
+
+		emit(
+			{
+				event           : 'server.newroom',
+				roomId          : room.id,
+				rtpCapabilities : room.rtpCapabilities
+			},
+			stream);
+
+		handleRoom(room, stream);
+	});
+}
+
+function handleRoom(room, stream)
+{
+	const baseEvent =
+	{
+		roomId : room.id
+	};
+
+	room.on('close', () =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event : 'room.close'
+			}),
+			stream);
+
+		stream.end();
+	});
+
+	room.on('newpeer', (peer) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event           : 'room.newpeer',
+				peerName        : peer.name,
+				rtpCapabilities : peer.rtpCapabilities
+			}),
+			stream);
+
+		handlePeer(peer, baseEvent, stream);
+	});
+}
+
+function handlePeer(peer, baseEvent, stream)
+{
+	baseEvent = Object.assign({}, baseEvent,
+		{
+			peerName : peer.name
+		});
+
+	peer.on('close', (originator) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'peer.close',
+				originator : originator
+			}),
+			stream);
+	});
+
+	peer.on('newtransport', (transport) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event              : 'peer.newtransport',
+				transportId        : transport.id,
+				direction          : transport.direction,
+				iceLocalCandidates : transport.iceLocalCandidates
+			}),
+			stream);
+
+		handleTransport(transport, baseEvent, stream);
+	});
+
+	peer.on('newproducer', (producer) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event         : 'peer.newproducer',
+				producerId    : producer.id,
+				kind          : producer.kind,
+				transportId   : producer.transport.id,
+				rtpParameters : producer.rtpParameters
+			}),
+			stream);
+
+		handleProducer(producer, baseEvent, stream);
+	});
+
+	peer.on('newconsumer', (consumer) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event         : 'peer.newconsumer',
+				consumerId    : consumer.id,
+				kind          : consumer.kind,
+				sourceId      : consumer.source.id,
+				rtpParameters : consumer.rtpParameters
+			}),
+			stream);
+
+		handleConsumer(consumer, baseEvent, stream);
+	});
+
+	// Must also handle existing Consumers at the time the Peer was created.
+	for (const consumer of peer.consumers)
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event         : 'peer.newconsumer',
+				consumerId    : consumer.id,
+				kind          : consumer.kind,
+				sourceId      : consumer.source.id,
+				rtpParameters : consumer.rtpParameters
+			}),
+			stream);
+
+		handleConsumer(consumer, baseEvent, stream);
+	}
+}
+
+function handleTransport(transport, baseEvent, stream)
+{
+	baseEvent = Object.assign({}, baseEvent,
+		{
+			transportId : transport.id
+		});
+
+	const statsInterval = setInterval((stats) =>
+	{
+		transport.getStats()
+			.then((stats) =>
+			{
+				emit(Object.assign({}, baseEvent,
+					{
+						event : 'transport.stats',
+						stats : stats
+					}),
+					stream);
+			});
+	}, STATS_INTERVAL);
+
+	transport.on('close', (originator) =>
+	{
+		clearInterval(statsInterval);
+
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'transport.close',
+				originator : originator
+			}),
+			stream);
+	});
+
+	transport.on('iceselectedtuplechange', (iceSelectedTuple) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event            : 'transport.iceselectedtuplechange',
+				iceSelectedTuple : iceSelectedTuple
+			}),
+			stream);
+	});
+
+	transport.on('icestatechange', (iceState) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event    : 'transport.icestatechange',
+				iceState : iceState
+			}),
+			stream);
+	});
+
+	transport.on('dtlsstatechange', (dtlsState) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event     : 'transport.dtlsstatechange',
+				dtlsState : dtlsState
+			}),
+			stream);
+	});
+}
+
+function handleProducer(producer, baseEvent, stream)
+{
+	baseEvent = Object.assign({}, baseEvent,
+		{
+			producerId : producer.id
+		});
+
+	const statsInterval = setInterval((stats) =>
+	{
+		producer.getStats()
+			.then((stats) =>
+			{
+				emit(Object.assign({}, baseEvent,
+					{
+						event : 'producer.stats',
+						stats : stats
+					}),
+					stream);
+			});
+	}, STATS_INTERVAL);
+
+	producer.on('close', (originator) =>
+	{
+		clearInterval(statsInterval);
+
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'producer.close',
+				originator : originator
+			}),
+			stream);
+	});
+
+	producer.on('pause', (originator) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'producer.pause',
+				originator : originator
+			}),
+			stream);
+	});
+
+	producer.on('resume', (originator) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'producer.resume',
+				originator : originator
+			}),
+			stream);
+	});
+}
+
+function handleConsumer(consumer, baseEvent, stream)
+{
+	baseEvent = Object.assign({}, baseEvent,
+		{
+			consumerId : consumer.id
+		});
+
+	const statsInterval = setInterval((stats) =>
+	{
+		consumer.getStats()
+			.then((stats) =>
+			{
+				emit(Object.assign({}, baseEvent,
+					{
+						event : 'consumer.stats',
+						stats : stats
+					}),
+					stream);
+			});
+	}, STATS_INTERVAL);
+
+	consumer.on('close', (originator) =>
+	{
+		clearInterval(statsInterval);
+
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'consumer.close',
+				originator : originator
+			}),
+			stream);
+	});
+
+	consumer.on('handled', () =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event       : 'consumer.handled',
+				transportId : consumer.transport.id
+			}),
+			stream);
+	});
+
+	consumer.on('unhandled', () =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event : 'consumer.handled'
+			}),
+			stream);
+	});
+
+	consumer.on('pause', (originator) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'consumer.pause',
+				originator : originator
+			}),
+			stream);
+	});
+
+	consumer.on('resume', (originator) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event      : 'consumer.resume',
+				originator : originator
+			}),
+			stream);
+	});
+
+	consumer.on('effectiveprofilechange', (profile) =>
+	{
+		emit(Object.assign({}, baseEvent,
+			{
+				event   : 'consumer.effectiveprofilechange',
+				profile : profile
+			}),
+			stream);
+	});
+}
+
+function emit(event, stream)
+{
+	// Add timestamp.
+	event.timestamp = Date.now();
+
+	const line = JSON.stringify(event);
+
+	console.warn(line);
+
+	stream.write(line);
+	stream.write('\n');
+}
+
+module.exports = homer;

server/package.json

@@ -11,11 +11,11 @@
     "debug": "^3.1.0",
     "express": "^4.16.2",
     "mediasoup": "^2.0.7",
-    "protoo-server": "^2.0.5"
+    "protoo-server": "^2.0.7"
   },
   "devDependencies": {
-    "gulp": "git://github.com/gulpjs/gulp.git#4.0",
-    "gulp-eslint": "^4.0.0",
-    "gulp-plumber": "^1.1.0"
+    "gulp": "^4.0.0",
+    "gulp-eslint": "^4.0.2",
+    "gulp-plumber": "^1.2.0"
   }
 }

server/server.js

@@ -6,7 +6,7 @@ process.title = 'mediasoup-demo-server';
 
 const config = require('./config');
 
-process.env.DEBUG = config.debug || '*INFO* *WARN* *ERROR*';
+process.env.DEBUG = process.env.DEBUG || '*INFO* *WARN* *ERROR* *mediasoup-worker*';
 
 /* eslint-disable no-console */
 console.log('- process.env.DEBUG:', process.env.DEBUG);
@@ -24,6 +24,7 @@ const colors = require('colors/safe');
 const repl = require('repl');
 const Logger = require('./lib/Logger');
 const Room = require('./lib/Room');
+const homer = require('./lib/homer');
 
 const logger = new Logger();
 
@@ -44,6 +45,10 @@ const mediaServer = mediasoup.Server(
 		rtcMaxPort       : config.mediasoup.rtcMaxPort
 	});
 
+// Do Homer stuff.
+if (process.env.MEDIASOUP_HOMER_OUTPUT)
+	homer(mediaServer);
+
 global.SERVER = mediaServer;
 
 mediaServer.on('newroom', (room) =>