status-sharding
Version:
Welcome to Status Sharding! This package is designed to provide an efficient and flexible solution for sharding Discord bots, allowing you to scale your bot across multiple processes or workers.
85 lines (84 loc) • 6.04 kB
TypeScript
import { ClusterClientEvents, EvalOptions, Serialized, Awaitable, ValidIfSerializable, SerializableInput, ClusterClientData } from '../types';
import { BaseMessage, DataType } from '../other/message';
import { IPCBrokerClient } from '../handlers/broker';
import { RefClusterManager } from './clusterManager';
import { PromiseHandler } from '../handlers/promise';
import { WorkerClient } from '../classes/worker';
import { ChildClient } from '../classes/child';
import { Serializable } from 'child_process';
import { RefShardingClient } from './client';
import { Guild } from 'discord.js';
import EventEmitter from 'events';
/** Simplified Cluster instance available on the {@link ClusterClient}. */
export declare class ClusterClient<InternalClient extends RefShardingClient = RefShardingClient, InternalManager extends RefClusterManager = RefClusterManager> extends EventEmitter {
client: InternalClient;
/** Ready state of the cluster. */
ready: boolean;
/** Handler that resolves sent messages and requests. */
promise: PromiseHandler;
/** Client that manages broker tunnels. */
readonly broker: IPCBrokerClient;
/** Client that manages the cluster process. */
readonly process: ChildClient | WorkerClient | null;
/** Handler that handles messages from the ClusterManager and the Cluster. */
private messageHandler;
/** Creates an instance of ClusterClient. */
constructor(client: InternalClient);
/** Current cluster id. */
get id(): number;
/** Total number of shards. */
get totalShards(): number;
/** Total number of clusters. */
get totalClusters(): number;
/** Utility function to get some info about the cluster. */
get info(): ClusterClientData;
/** Sends a message to the Cluster as child. (goes to Cluster on _handleMessage). */
send<T extends Serializable>(message: SerializableInput<T>): Promise<void>;
/** Broadcasts a message to all clusters. */
broadcast<T extends Serializable>(message: SerializableInput<T>, sendSelf?: boolean): Promise<void>;
/** Sends a message to the Cluster. */
_sendInstance<D extends DataType, A = Serializable, P extends object = object>(message: BaseMessage<D, A, P>): Promise<void>;
/** Evaluates a script on the master process, in the context of the {@link ClusterManager}. */
evalOnManager<T, P extends object, M = InternalManager>(script: ((manager: M, context: Serialized<P>) => Awaitable<T>), options?: {
context?: P;
timeout?: number;
}): Promise<ValidIfSerializable<T>>;
/** Evaluates a script on all clusters in parallel. */
broadcastEval<T, P extends object, C = InternalClient>(script: string | ((client: C, context: Serialized<P>) => Awaitable<T>), options?: EvalOptions<P>): Promise<ValidIfSerializable<T>[]>;
/** Evaluates a script on specific guild. */
evalOnGuild<T, P extends object, C = InternalClient, E extends boolean = false>(guildId: string, script: (client: C, context: Serialized<P>, guild: E extends true ? Guild : Guild | undefined) => Awaitable<T>, options?: EvalOptions<P>): Promise<ValidIfSerializable<T>>;
/** Evaluates a script on a current client, in the context of the {@link ShardingClient}. */
evalOnClient<T, P extends object, C = InternalClient>(script: string | ((client: C, context: Serialized<P>) => Awaitable<T>), options?: EvalOptions<P>): Promise<ValidIfSerializable<T>>;
/** Sends a request to the Cluster (cluster has to respond with a reply (cluster.on('message', (message) => message.reply('reply')))). */
request<T extends Serializable>(message: SerializableInput<T>, options?: {
timeout?: number;
}): Promise<ValidIfSerializable<T>>;
/** Kills all running clusters and respawns them. */
respawnAll(clusterDelay?: number, respawnDelay?: number, timeout?: number, except?: number[]): Promise<void>;
/** Kills specific clusters and respawns them. */
respawnClusters(clusters: number[], clusterDelay?: number, respawnDelay?: number, timeout?: number): Promise<void>;
/** Handles a message from the ClusterManager. */
private _handleMessage;
/** Sends a message to the master process. */
_respond<D extends DataType, A = Serializable, P extends object = object>(message: BaseMessage<D, A, P>): void;
/** Triggers the ready event, do not use this unless you know what you are doing. */
triggerReady(): boolean;
/** Spawns the next cluster, when queue mode is on 'manual'. */
spawnNextCluster(): Promise<void>;
/** Kills the cluster. */
_debug(message: string): void;
}
export type RefClusterClient = ClusterClient;
/** Modified ClusterClient with bunch of new methods. */
export declare interface ClusterClient {
/** Emit an event. */
emit: (<K extends keyof ClusterClientEvents>(event: K, ...args: ClusterClientEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, ...args: unknown[]) => boolean);
/** Remove an event listener. */
off: (<K extends keyof ClusterClientEvents>(event: K, listener: (...args: ClusterClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, listener: (...args: unknown[]) => void) => this);
/** Listen for an event. */
on: (<K extends keyof ClusterClientEvents>(event: K, listener: (...args: ClusterClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, listener: (...args: unknown[]) => void) => this);
/** Listen for an event once. */
once: (<K extends keyof ClusterClientEvents>(event: K, listener: (...args: ClusterClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, listener: (...args: unknown[]) => void) => this);
/** Remove all listeners for an event. */
removeAllListeners: (<K extends keyof ClusterClientEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof ClusterClientEvents>) => this);
}