40 | /**
41 | * Created by Julian & NoobLance on 25.05.2017.
42 | * DISCLAIMER: We reuse some eris code
43 | */
44 |
45 | const { Collection } = require('eris');
46 | const Lavalink = require('./Lavalink');
47 | const Player = require('./Player');
48 |
49 | /**
50 | * Player Manager
51 | * @extends Map
52 | * @prop {Player} baseObject The player class used to create new players
53 | * @prop {object} client The eris client
54 | * @prop {object} defaultRegions The default region config
55 | * @prop {object} regions The region config being used
56 | */
57 | class PlayerManager extends Collection {
58 | /**
59 | * PlayerManager constructor
60 | * @param {Client} client Eris client
61 | * @param {Object[]} nodes The Lavalink nodes to connect to
62 | * @param {Object} [options] Setup options
63 | * @param {string} [options.defaultRegion] The default region
64 | * @param {number} [options.failoverRate=250] Failover rate in ms
65 | * @param {number} [options.failoverLimit=1] Number of connections to failover per rate limit
66 | * @param {Object} [options.player] Optional Player class to replace the default Player
67 | * @param {number} [options.reconnectThreshold=2000] The amount of time to skip ahead in a song when reconnecting in ms
68 | * @param {Object} [options.regions] Region mapping object
69 | */
70 | constructor(client, nodes, options) {
71 | super(options.player || Player);
72 |
73 | this.client = client;
74 | this.nodes = new Collection();
75 | this.pendingGuilds = {};
76 | this.options = options || {};
77 | this.failoverQueue = [];
78 | this.failoverRate = options.failoverRate || 250;
79 | this.failoverLimit = options.failoverLimit || 1;
80 |
81 | this.defaultRegions = {
82 | asia: ['hongkong', 'singapore', 'sydney'],
83 | eu: ['eu', 'amsterdam', 'frankfurt', 'russia'],
84 | us: ['us', 'brazil'],
85 | };
86 |
87 | this.regions = options.regions || this.defaultRegions;
88 |
89 | for (let node of nodes) {
90 | this.createNode(Object.assign({}, node, options));
91 | }
92 |
93 | this.shardReadyListener = this.shardReady.bind(this);
94 | this.client.on('shardReady', this.shardReadyListener);
95 | }
96 |
97 | /**
98 | * Create a Lavalink node
99 | * @param {Object} options Lavalink node options
100 | * @param {string} options.host The hostname to connect to
101 | * @param {string} options.port The port to connect with
102 | * @param {string} options.region The region of the node
103 | * @param {number} options.numShards The number of shards the bot is running
104 | * @param {string} options.userId The user id of the bot
105 | * @param {string} options.password The password for the Lavalink node
106 | * @returns {void}
107 | */
108 | createNode(options) {
109 | let node = new Lavalink({
110 | host: options.host,
111 | port: options.port,
112 | region: options.region,
113 | numShards: options.numShards,
114 | userId: options.userId,
115 | password: options.password,
116 | });
117 |
118 | node.on('error', this.onError.bind(this, node));
119 | node.on('disconnect', this.onDisconnect.bind(this, node));
120 | node.on('message', this.onMessage.bind(this, node));
121 |
122 | this.nodes.set(options.host, node);
123 | }
124 |
125 | /**
126 | * Remove a Lavalink node
127 | * @param {string} host The hostname of the node
128 | * @returns {void}
129 | */
130 | removeNode(host) {
131 | let node = this.nodes.get(host);
132 | if (!host) return;
133 | node.destroy();
134 | this.nodes.delete(host);
135 | this.onDisconnect(node);
136 | }
137 |
138 | /**
139 | * Check the failover queue
140 | * @private
141 | */
142 | checkFailoverQueue() {
143 | if (this.failoverQueue.length > 0) {
144 | let fns = this.failoverQueue.splice(0, this.failoverLimit);
145 | for (let fn of fns) {
146 | this.processQueue(fn);
147 | }
148 | }
149 | }
150 |
151 | /**
152 | * Queue a failover
153 | * @param {Function} fn The failover function to queue
154 | * @private
155 | */
156 | queueFailover(fn) {
157 | if (this.failoverQueue.length > 0) {
158 | this.failoverQueue.push(fn);
159 | } else {
160 | return this.processQueue(fn);
161 | }
162 | }
163 |
164 | /**
165 | * Process the failover queue
166 | * @param {Function} fn The failover function to call
167 | * @private
168 | */
169 | processQueue(fn) {
170 | fn();
171 | setTimeout(() => this.checkFailoverQueue(), this.failoverRate);
172 | }
173 |
174 | /**
175 | * Called when an error is received from a Lavalink node
176 | * @param {Lavalink} node The Lavalink node
177 | * @param {string|Error} err The error received
178 | * @private
179 | */
180 | onError(node, err) {
181 | this.client.emit(err);
182 | }
183 |
184 | /**
185 | * Called when a node disconnects
186 | * @param {Lavalink} node The Lavalink node
187 | * @param {*} msg The disconnect message if sent
188 | * @private
189 | */
190 | onDisconnect(node, msg) {
191 | let players = this.filter(player => player.node.host === node.host);
192 | for (let player of players) {
193 | this.queueFailover(this.switchNode.bind(this, player, true));
194 | }
195 | }
196 |
197 | /**
198 | * Called when a shard readies
199 | * @param {number} id Shard ID
200 | * @private
201 | */
202 | shardReady(id) {
203 | let players = this.filter(player => player.shard && player.shard.id === id);
204 | for (let player of players) {
205 | this.queueFailover(this.switchNode.bind(this, player));
206 | }
207 | }
208 |
209 | /**
210 | * Switch the voice node of a player
211 | * @param {Player} player The Player instance
212 | * @param {boolean} leave Whether to leave the channel or not on our side
213 | * @returns {void}
214 | */
215 | switchNode(player, leave) {
216 | let { guildId, channelId, track } = player,
217 | position = (player.state.position || 0) + (this.options.reconnectThreshold || 2000);
218 |
219 | let listeners = player.listeners('end'),
220 | endListeners = [];
221 |
222 | if (listeners && listeners.length) {
223 | for (let listener of listeners) {
224 | endListeners.push(listener);
225 | player.removeListener('end', listener);
226 | }
227 | }
228 |
229 | player.once('end', () => {
230 | for (let listener of endListeners) {
231 | player.on('end', listener);
232 | }
233 | });
234 |
235 | this.delete(guildId);
236 |
237 | player.playing = false;
238 |
239 | if (leave) {
240 | player.updateVoiceState(null);
241 | } else {
242 | player.node.send({ op: 'disconnect', guildId: guildId });
243 | }
244 |
245 | process.nextTick(() => {
246 | this.join(guildId, channelId, null, player).then(player => {
247 | player.play(track, { startTime: position });
248 | player.emit('reconnect');
249 | this.set(guildId, player);
250 | })
251 | .catch(err => {
252 | player.emit('disconnect', err);
253 | player.disconnect();
254 | });
255 | });
256 | }
257 |
258 | /**
259 | * Called when a message is received from the voice node
260 | * @param {Lavalink} node The Lavalink node
261 | * @param {*} message The message received
262 | * @private
263 | */
264 | onMessage(node, message) {
265 | if (!message.op) return;
266 |
267 | switch (message.op) {
268 | case 'validationReq': {
269 | let payload = {
270 | op: 'validationRes',
271 | guildId: message.guildId,
272 | };
273 |
274 | let guildValid = false;
275 | let channelValid = false;
276 |
277 | if (message.guildId && message.guildId.length) {
278 | guildValid = this.client.guilds.has(message.guildId);
279 | } else {
280 | guildValid = true;
281 | }
282 |
283 | if (message.channelId && message.channelId.length) {
284 | let voiceChannel = this.client.getChannel(message.channelId);
285 | if (voiceChannel) {
286 | payload.channelId = voiceChannel.id;
287 | channelValid = true;
288 | }
289 | } else {
290 | channelValid = true;
291 | }
292 |
293 | payload.valid = guildValid && channelValid;
294 |
295 | return node.send(payload);
296 | }
297 | case 'isConnectedReq': {
298 | let payload = {
299 | op: 'isConnectedRes',
300 | shardId: parseInt(message.shardId),
301 | connected: false,
302 | };
303 |
304 | let shard = this.client.shards.get(message.shardId);
305 | if (shard && (shard.status === 'connected' || shard.status === 'ready')) {
306 | payload.connected = true;
307 | }
308 |
309 | return node.send(payload);
310 | }
311 | case 'sendWS': {
312 | let shard = this.client.shards.get(message.shardId);
313 | if (shard === undefined) return;
314 |
315 | const payload = JSON.parse(message.message);
316 |
317 | shard.sendWS(payload.op, payload.d);
318 |
319 | if (payload.op === 4 && payload.d.channel_id === null) {
320 | this.delete(payload.d.guild_id);
321 | }
322 | }
323 | case 'playerUpdate': {
324 | let player = this.get(message.guildId);
325 | if (!player) return;
326 |
327 | return player.stateUpdate(message.state);
328 | }
329 | case 'event': {
330 | let player = this.get(message.guildId);
331 | if (!player) return;
332 |
333 | switch (message.type) {
334 | case 'TrackEndEvent':
335 | return player.onTrackEnd(message);
336 | case 'TrackExceptionEvent':
337 | return player.onTrackException(message);
338 | case 'TrackStuckEvent':
339 | return player.onTrackStuck(message);
340 | default:
341 | return player.emit('warn', `Unexpected event type: ${message.type}`);
342 | }
343 | }
344 | }
345 | }
346 |
347 | /**
348 | * Join a voice channel
349 | * @param {string} guildId The guild ID
350 | * @param {string} channelId The channel ID
351 | * @param {Object} options Join options
352 | * @param {Player} [player] Optionally pass an existing player
353 | * @returns {Promise<Player>}
354 | */
355 | async join(guildId, channelId, options, player) {
356 | options = options || {};
357 |
358 | player = player || this.get(guildId);
359 | if (player && player.channelId !== channelId) {
360 | player.switchChannel(channelId);
361 | return Promise.resolve(player);
362 | }
363 |
364 | let region = this.getRegionFromData(options.region || 'us');
365 | let node = await this.findIdealNode(region);
366 |
367 | if (!node) {
368 | return Promise.reject('No available voice nodes.');
369 | }
370 |
371 | return new Promise((res, rej) => {
372 | this.pendingGuilds[guildId] = {
373 | channelId: channelId,
374 | options: options || {},
375 | player: player || null,
376 | node: node,
377 | res: res,
378 | rej: rej,
379 | timeout: setTimeout(() => {
380 | node.send({ op: 'disconnect', guildId: guildId });
381 | delete this.pendingGuilds[guildId];
382 | rej(new Error('Voice connection timeout'));
383 | }, 10000),
384 | };
385 |
386 | node.send({
387 | op: 'connect',
388 | guildId: guildId,
389 | channelId: channelId,
390 | });
391 | });
392 | }
393 |
394 | /**
395 | * Leave a voice channel
396 | * @param {string} guildId The guild ID
397 | * @returns {void}
398 | */
399 | async leave(guildId) {
400 | let player = this.get(guildId);
401 | if (!player) {
402 | return;
403 | }
404 | player.disconnect();
405 | this.delete(player);
406 | }
407 |
408 | /**
409 | * Find the ideal voice node based on load and region
410 | * @param {string} region Guild region
411 | * @private
412 | */
413 | async findIdealNode(region) {
414 | let nodes = [...this.nodes.values()].filter(node => !node.draining && node.ws && node.connected);
415 |
416 | if (region) {
417 | let regionalNodes = nodes.filter(node => node.region === region);
418 | if (regionalNodes && regionalNodes.length) {
419 | nodes = regionalNodes;
420 | }
421 | }
422 |
423 | nodes = nodes.sort((a, b) => {
424 | let aload = a.stats.cpu ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100 : 0,
425 | bload = b.stats.cpu ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100 : 0;
426 | return aload - bload;
427 | });
428 | return nodes[0];
429 | }
430 |
431 | /**
432 | * Called by eris when a voice server update is received
433 | * @param {*} data The voice server update from eris
434 | * @private
435 | */
436 | async voiceServerUpdate(data) {
437 | if (this.pendingGuilds[data.guild_id] && this.pendingGuilds[data.guild_id].timeout) {
438 | clearTimeout(this.pendingGuilds[data.guild_id].timeout);
439 | this.pendingGuilds[data.guild_id].timeout = null;
440 | }
441 |
442 | let player = this.get(data.guild_id);
443 | if (!player) {
444 | if (!this.pendingGuilds[data.guild_id]) {
445 | return;
446 | }
447 |
448 | player = this.pendingGuilds[data.guild_id].player;
449 |
450 | if (player) {
451 | player.sessionId = data.sessionId;
452 | player.hostname = this.pendingGuilds[data.guild_id].hostname;
453 | player.node = this.pendingGuilds[data.guild_id].node;
454 | player.event = data;
455 | this.set(data.guild_id, player);
456 | }
457 |
458 | player = player || this.add(new this.baseObject(data.guild_id, {
459 | shard: data.shard,
460 | guildId: data.guild_id,
461 | sessionId: data.session_id,
462 | channelId: this.pendingGuilds[data.guild_id].channelId,
463 | hostname: this.pendingGuilds[data.guild_id].hostname,
464 | node: this.pendingGuilds[data.guild_id].node,
465 | options: this.pendingGuilds[data.guild_id].options,
466 | event: data,
467 | manager: this,
468 | }));
469 |
470 | player.connect({
471 | sessionId: data.session_id,
472 | guildId: data.guild_id,
473 | channelId: this.pendingGuilds[data.guild_id].channelId,
474 | event: {
475 | endpoint: data.endpoint,
476 | guild_id: data.guild_id,
477 | token: data.token,
478 | },
479 | });
480 | }
481 |
482 | let disconnectHandler = () => {
483 | player = this.get(data.guild_id);
484 | if (!this.pendingGuilds[data.guild_id]) {
485 | if (player) {
486 | player.removeListener('ready', readyHandler);
487 | }
488 | return;
489 | }
490 | player.removeListener('ready', readyHandler);
491 | this.pendingGuilds[data.guild_id].rej(new Error('Disconnected'));
492 | delete this.pendingGuilds[data.guild_id];
493 | };
494 |
495 | let readyHandler = () => {
496 | player = this.get(data.guild_id);
497 | if (!this.pendingGuilds[data.guild_id]) {
498 | if (player) {
499 | player.removeListener('disconnect', disconnectHandler);
500 | }
501 | return;
502 | }
503 | player.removeListener('disconnect', disconnectHandler);
504 | this.pendingGuilds[data.guild_id].res(player);
505 | delete this.pendingGuilds[data.guild_id];
506 | };
507 |
508 | player.once('ready', readyHandler).once('disconnect', disconnectHandler);
509 | }
510 |
511 | /**
512 | * Get ideal region from data
513 | * @param {string} endpoint Endpoint or region
514 | * @private
515 | */
516 | getRegionFromData(endpoint) {
517 | if (!endpoint) return this.options.defaultRegion || 'us';
518 |
519 | endpoint = endpoint.replace('vip-', '');
520 |
521 | for (let key in this.regions) {
522 | let nodes = this.nodes.filter(n => n.region === key);
523 | if (!nodes || !nodes.length) continue;
524 | if (!nodes.find(n => n.connected && !n.draining)) continue;
525 | for (let region of this.regions[key]) {
526 | if (endpoint.startsWith(region)) {
527 | return key;
528 | }
529 | }
530 | }
531 |
532 | return this.options.defaultRegion || 'us';
533 | }
534 | }
535 |
536 | module.exports = PlayerManager;
537 |
538 |
539 |