Class WorkerManager

constructor

• new WorkerManager(
      options: Omit<
          PickPartial<
              WorkerManagerOptions,
              "token"
              | "info"
              | "handlePayload"
              | "intents"
              | "handleWorkerMessage",
          >,
          "resharding",
      > & {
          resharding?: PickPartial<
              {
                  interval: number;
                  percentage: number;
                  getInfo(): Promise<APIGatewayBotInfo>;
              },
              "getInfo",
          >;
      },
  ): WorkerManager

  Parameters

  • options: Omit<
        PickPartial<
            WorkerManagerOptions,
            "token"
            | "info"
            | "handlePayload"
            | "intents"
            | "handleWorkerMessage",
        >,
        "resharding",
    > & {
        resharding?: PickPartial<
            {
                interval: number;
                percentage: number;
                getInfo(): Promise<APIGatewayBotInfo>;
            },
            "getInfo",
        >;
    }

  Returns WorkerManager

cacheAdapter

connectQueue

Optionaldebugger

heartbeater

options

promises

reshardingWorkerQueue

rest

workerQueue

concurrency

• get concurrency(): number

  Returns number

remaining

• get remaining(): number

  Returns number

shardEnd

• get shardEnd(): number

  Returns number

shardsPerWorker

• get shardsPerWorker(): number

  Returns number

shardStart

• get shardStart(): number

  Returns number

totalShards

• get totalShards(): number

  Returns number

totalWorkers

• get totalWorkers(): number

  Returns number

calculateShardId

• calculateShardId(guildId: string): number

  Parameters

  • guildId: string

  Returns number

calculateWorkerId

• calculateWorkerId(shardId: number): number

  Parameters

  • shardId: number

  Returns number

createWorker

• createWorker(
      workerData: WorkerData,
  ):
      | Worker
      | Worker
      | { ready?: boolean } & {
          disconnected?: boolean;
          ready?: boolean;
          resharded?: boolean;
      }

  Parameters

  • workerData: WorkerData

  Returns
      | Worker
      | Worker
      | { ready?: boolean } & {
          disconnected?: boolean;
          ready?: boolean;
          resharded?: boolean;
      }

getShardInfo

• getShardInfo(shardId: number): Promise<WorkerShardInfo>

  Parameters

  • shardId: number

  Returns Promise<WorkerShardInfo>

getWorkerInfo

• getWorkerInfo(workerId: number): Promise<WorkerInfo>

  Parameters

  • workerId: number

  Returns Promise<WorkerInfo>

handleWorkerMessage

• handleWorkerMessage(message: WorkerMessages): Promise<void>

  Parameters

  • message: WorkerMessages

  Returns Promise<void>

postMessage

• postMessage(id: number, body: ManagerMessages | SendHeartbeat): void

  Parameters

  • id: number
  • body: ManagerMessages | SendHeartbeat

  Returns void

prepareWorkers

• prepareWorkers(shards: number[][], rawResharding?: boolean): void

  Parameters

  • shards: number[][]
  • rawResharding: boolean = false

  Returns void

send

• send(data: GatewaySendPayload, shardId: number): Promise<true>

  Parameters

  • data: GatewaySendPayload
  • shardId: number

  Returns Promise<true>

setCache

• setCache(adapter: Adapter): void

  Parameters

  • adapter: Adapter

  Returns void

setRest

• setRest(rest: ApiHandler): void

  Parameters

  • rest: ApiHandler

  Returns void

spawn

• spawn(workerId: number, shardId: number, resharding?: boolean): void

  Parameters

  • workerId: number
  • shardId: number
  • resharding: boolean = false

  Returns void

start

• start(): Promise<void>

  Returns Promise<void>

startResharding

• startResharding(): Promise<void>

  Returns Promise<void>

syncLatency

• syncLatency(
      __namedParameters:
          | { shardId: number; workerId?: number }
          | { shardId?: number; workerId: number },
  ): Promise<number>

  Parameters

  • __namedParameters: { shardId: number; workerId?: number } | { shardId?: number; workerId: number }

  Returns Promise<number>

tellWorker

• tellWorker<R, V extends Record<string, unknown>>(
      workerId: number,
      func: (_: WorkerClient<boolean> & UsingClient, vars: V) => R,
      vars: V,
  ): Promise<R>

  Type Parameters

  • R
  • V extends Record<string, unknown>

  Parameters

  • workerId: number
  • func: (_: WorkerClient<boolean> & UsingClient, vars: V) => R
  • vars: V

  Returns Promise<R>

tellWorkers

• tellWorkers<R, V extends Record<string, unknown>>(
      func: (_: WorkerClient<boolean> & UsingClient, vars: V) => R,
      vars: V,
  ): Promise<Awaited<R>[]>

  Type Parameters

  • R
  • V extends Record<string, unknown>

  Parameters

  • func: (_: WorkerClient<boolean> & UsingClient, vars: V) => R
  • vars: V

  Returns Promise<Awaited<R>[]>

StaticprepareSpaces

• prepareSpaces(
      options: {
          shardEnd: number;
          shardsPerWorker: number;
          shardStart: number;
      },
      logger?: Logger,
  ): number[][]

  Parameters

  • options: { shardEnd: number; shardsPerWorker: number; shardStart: number }
  • Optionallogger: Logger

  Returns number[][]