Nomchy/discord.js
1
0
Fork 0
mirror of https://github.com/discordjs/discord.js.git synced 2026-03-09 16:13:31 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor(Sharding): use options objects (#5510)

Browse Source 
Co-authored-by: Vlad Frangu <kingdgrizzle@gmail.com>
This commit is contained in:
monbrey
2021-05-01 05:46:20 +10:00
committed by GitHub
parent 116ecf246e
commit c9b53539d5
4 changed files with 39 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/sharding/Shard.js
View File

@@ -102,11 +102,11 @@ class Shard extends EventEmitter {
/**
* Forks a child process or creates a worker thread for the shard.
* <warn>You should not need to call this manually.</warn>
* @param {number} [spawnTimeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
* @param {number} [timeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
* before resolving. (-1 or Infinity for no wait)
* @returns {Promise<ChildProcess>}
*/
async spawn(spawnTimeout = 30000) {
async spawn(timeout = 30000) {
if (this.process) throw new Error('SHARDING_PROCESS_EXISTS', this.id);
if (this.worker) throw new Error('SHARDING_WORKER_EXISTS', this.id);
@@ -134,7 +134,7 @@ class Shard extends EventEmitter {
*/
this.emit('spawn', this.process || this.worker);
if (spawnTimeout === -1 || spawnTimeout === Infinity) return this.process || this.worker;
if (timeout === -1 || timeout === Infinity) return this.process || this.worker;
await new Promise((resolve, reject) => {
const cleanup = () => {
clearTimeout(spawnTimeoutTimer);
@@ -163,7 +163,7 @@ class Shard extends EventEmitter {
reject(new Error('SHARDING_READY_TIMEOUT', this.id));
};
const spawnTimeoutTimer = setTimeout(onTimeout, spawnTimeout);
const spawnTimeoutTimer = setTimeout(onTimeout, timeout);
this.once('ready', onReady);
this.once('disconnect', onDisconnect);
this.once('death', onDeath);
@@ -188,15 +188,18 @@ class Shard extends EventEmitter {
/**
* Kills and restarts the shard's process/worker.
* @param {number} [delay=500] How long to wait between killing the process/worker and restarting it (in milliseconds)
* @param {number} [spawnTimeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
* @param {Object} [options] Respawn options for the shard
* @param {number} [options.delay=500] How long to wait between killing the process/worker and
* restarting it (in milliseconds)
* @param {number} [options.timeout=30000] The amount in milliseconds to wait until the {@link Client}
* has become ready
* before resolving. (-1 or Infinity for no wait)
* @returns {Promise<ChildProcess>}
*/
async respawn(delay = 500, spawnTimeout) {
async respawn({ delay = 500, timeout = 30000 } = {}) {
this.kill();
if (delay > 0) await Util.delayFor(delay);
return this.spawn(spawnTimeout);
return this.spawn(timeout);
}
/**
@@ -354,8 +357,8 @@ class Shard extends EventEmitter {
// Shard is requesting a respawn of all shards
if (message._sRespawnAll) {
const { shardDelay, respawnDelay, spawnTimeout } = message._sRespawnAll;
this.manager.respawnAll(shardDelay, respawnDelay, spawnTimeout).catch(() => {
const { shardDelay, respawnDelay, timeout } = message._sRespawnAll;
this.manager.respawnAll({ shardDelay, respawnDelay, timeout }).catch(() => {
// Do nothing
});
return;

13
src/sharding/ShardClientUtil.js
View File

@@ -158,16 +158,17 @@ class ShardClientUtil {
/**
* Requests a respawn of all shards.
* @param {number} [shardDelay=5000] How long to wait between shards (in milliseconds)
* @param {number} [respawnDelay=500] How long to wait between killing a shard's process/worker and restarting it
* (in milliseconds)
* @param {number} [spawnTimeout=30000] The amount in milliseconds to wait for a shard to become ready before
* @param {Object} [options] Options for respawning shards
* @param {number} [options.shardDelay=5000] How long to wait between shards (in milliseconds)
* @param {number} [options.respawnDelay=500] How long to wait between killing a shard's process/worker and
* restarting it (in milliseconds)
* @param {number} [options.timeout=30000] The amount in milliseconds to wait for a shard to become ready before
* continuing to another. (-1 or Infinity for no wait)
* @returns {Promise<void>} Resolves upon the message being sent
* @see {@link ShardingManager#respawnAll}
*/
respawnAll(shardDelay = 5000, respawnDelay = 500, spawnTimeout = 30000) {
return this.send({ _sRespawnAll: { shardDelay, respawnDelay, spawnTimeout } });
respawnAll({ shardDelay = 5000, respawnDelay = 500, timeout = 30000 } = {}) {
return this.send({ _sRespawnAll: { shardDelay, respawnDelay, timeout } });
}
/**

23
src/sharding/ShardingManager.js
View File

@@ -161,13 +161,13 @@ class ShardingManager extends EventEmitter {
/**
* Spawns multiple shards.
* @param {number|string} [amount=this.totalShards] Number of shards to spawn
* @param {number} [delay=5500] How long to wait in between spawning each shard (in milliseconds)
* @param {number} [spawnTimeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
* before resolving. (-1 or Infinity for no wait)
* @param {Object} [options] Options for spawning shards
* @param {number|string} [options.amount=this.totalShards] Number of shards to spawn
* @param {number} [options.delay=5500] How long to wait in between spawning each shard (in milliseconds)
* @param {number} [options.timeout=30000] The amount in milliseconds to wait until the {@link Client} has become
* @returns {Promise<Collection<number, Shard>>}
*/
async spawn(amount = this.totalShards, delay = 5500, spawnTimeout) {
async spawn({ amount = this.totalShards, delay = 5500, timeout = 30000 } = {}) {
// Obtain/verify the number of shards to spawn
if (amount === 'auto') {
amount = await Util.fetchRecommendedShards(this.token);
@@ -202,7 +202,7 @@ class ShardingManager extends EventEmitter {
for (const shardID of this.shardList) {
const promises = [];
const shard = this.createShard(shardID);
promises.push(shard.spawn(spawnTimeout));
promises.push(shard.spawn(timeout));
if (delay > 0 && this.shards.size !== this.shardList.length) promises.push(Util.delayFor(delay));
await Promise.all(promises); // eslint-disable-line no-await-in-loop
}
@@ -270,17 +270,18 @@ class ShardingManager extends EventEmitter {
/**
* Kills all running shards and respawns them.
* @param {number} [shardDelay=5000] How long to wait between shards (in milliseconds)
* @param {number} [respawnDelay=500] How long to wait between killing a shard's process and restarting it
* @param {Object} [options] Options for respawning shards
* @param {number} [options.shardDelay=5000] How long to wait between shards (in milliseconds)
* @param {number} [options.respawnDelay=500] How long to wait between killing a shard's process and restarting it
* (in milliseconds)
* @param {number} [spawnTimeout=30000] The amount in milliseconds to wait for a shard to become ready before
* @param {number} [options.timeout=30000] The amount in milliseconds to wait for a shard to become ready before
* continuing to another. (-1 or Infinity for no wait)
* @returns {Promise<Collection<string, Shard>>}
*/
async respawnAll(shardDelay = 5000, respawnDelay = 500, spawnTimeout) {
async respawnAll({ shardDelay = 5000, respawnDelay = 500, timeout = 30000 } = {}) {
let s = 0;
for (const shard of this.shards.values()) {
const promises = [shard.respawn(respawnDelay, spawnTimeout)];
const promises = [shard.respawn({ respawnDelay, timeout })];
if (++s < this.shards.size && shardDelay > 0) promises.push(Util.delayFor(shardDelay));
await Promise.all(promises); // eslint-disable-line no-await-in-loop
}

14
typings/index.d.ts vendored
View File

@@ -1368,9 +1368,9 @@ declare module 'discord.js' {
public eval<T>(fn: (client: Client) => T): Promise<T[]>;
public fetchClientValue(prop: string): Promise<any>;
public kill(): void;
public respawn(delay?: number, spawnTimeout?: number): Promise<ChildProcess>;
public respawn(options?: { delay?: number, timeout?: number }): Promise<ChildProcess>;
public send(message: any): Promise<Shard>;
public spawn(spawnTimeout?: number): Promise<ChildProcess>;
public spawn(timeout?: number): Promise<ChildProcess>;
public on(event: 'spawn' | 'death', listener: (child: ChildProcess) => void): this;
public on(event: 'disconnect' | 'ready' | 'reconnecting', listener: () => void): this;
@@ -1401,7 +1401,7 @@ declare module 'discord.js' {
public broadcastEval<T>(fn: (client: Client) => T, shard: number): Promise<T>;
public fetchClientValues(prop: string): Promise<any[]>;
public fetchClientValues(prop: string, shard: number): Promise<any>;
public respawnAll(shardDelay?: number, respawnDelay?: number, spawnTimeout?: number): Promise<void>;
public respawnAll(options?: { shardDelay?: number, respawnDelay?: number, timeout?: number }): Promise<void>;
public send(message: any): Promise<void>;
public static singleton(client: Client, mode: ShardingManagerMode): ShardClientUtil;
@@ -1437,12 +1437,12 @@ declare module 'discord.js' {
public createShard(id: number): Shard;
public fetchClientValues(prop: string): Promise<any[]>;
public fetchClientValues(prop: string, shard: number): Promise<any>;
public respawnAll(
public respawnAll(options?: {
shardDelay?: number,
respawnDelay?: number,
spawnTimeout?: number,
): Promise<Collection<number, Shard>>;
public spawn(amount?: number | 'auto', delay?: number, spawnTimeout?: number): Promise<Collection<number, Shard>>;
timeout?: number,
}): Promise<Collection<number, Shard>>;
public spawn(options?: { amount?: number | 'auto', delay?: number, timeout?: number }): Promise<Collection<number, Shard>>;
public on(event: 'shardCreate', listener: (shard: Shard) => void): this;