Saltearse al contenido

Entendiendo el sharding

Sharding

En seyfert el enfoque de sharding (fragmentación para los amigos) es dar todo el beneficio del escalado manteniendo la misma estructura en tu proyecto.

¿Por qué hacer sharding?

Los runtimes de JavaScript son de un solo hilo, lo que significa que sin sharding, todo el procesamiento ocurriría en un único hilo. Esto crea un límite de procesamiento donde toda la carga se evalúa junta. Seyfert maneja el sharding internamente en la instancia del Client para ayudar a distribuir esta carga a través de múltiples procesos o hilos (aunque sigue siendo una técnica imperfecta).

Manejando los shards

La base de los Worker es permitir ejecutar código en paralelo en diferentes partes de la CPU, ya sea en hilos o procesos diferentes. En términos de Discord, esto significa la capacidad de conectar varios shards repartiendo la carga en cada Worker. Para Seyfert esto es tan simple como cambiar la propiedad mode en el WorkerManager para decidir el modo de ejecución entre threads para hacer spawn de clientes en los hilos del procesador o cluster para hacer spawn de los clientes en procesos diferentes del runtime.

import { 
class WorkerManager
WorkerManager } from 'seyfert';


const 
const manager: WorkerManager
manager = new 
new WorkerManager(options: Omit<PickPartial<WorkerManagerOptions, "token" | "intents" | "info" | "handlePayload" | "handleWorkerMessage">, "resharding"> & {
    resharding?: PickPartial<NonNullable<WorkerManagerOptions["resharding"]>, "getInfo">;
}): WorkerManager
WorkerManager({
  
mode: "threads" | "clusters" | "custom"
mode: "threads",
  // ./src/client.ts para bun y deno (?
  
path: string
path: "./dist/client.js",
  // puedes sobrescribir muchas opciones, como el número de workers y la cantidad de shards en cada worker
});


const manager: WorkerManager
manager.
WorkerManager.start(): Promise<void>
start();

¿Demasiado simple? Seyfert se encarga de toda la lógica por lo que tu proyecto no debería cambiar mucho solo por pasarte a un WorkerSharding.

Cache

A diferencia de las bibliotecas tradicionales de Discord, Seyfert ofrece una gestión de caché unificada a través de todos los shards. El caché puede centralizarse en el proceso principal (el ejecutor de WorkerManager), asegurando un acceso consistente a los datos en toda tu aplicación.

Para implementar el caché centralizado, usa el WorkerAdapter:

import { 
class WorkerClient<Ready extends boolean = boolean>
WorkerClient, 
class WorkerAdapter
WorkerAdapter } from 'seyfert';


const 
const client: WorkerClient<boolean>
client = new 
new WorkerClient<boolean>(options?: WorkerClientOptions): WorkerClient<boolean>
WorkerClient();


const client: WorkerClient<boolean>
client.
WorkerClient<boolean>.setServices(rest: ServicesOptions): void
setServices({
  
ServicesOptions.cache?: {
    adapter?: Adapter;
    disabledCache?: boolean | DisabledCache | ((cacheType: keyof DisabledCache) => boolean);
}
cache: {
    
adapter?: Adapter
adapter: new 
new WorkerAdapter(workerData: WorkerData): WorkerAdapter
WorkerAdapter(
const client: WorkerClient<boolean>
client.
WorkerClient<boolean>.workerData: WorkerData
workerData)
  }
});


await 
const client: WorkerClient<boolean>
client.
WorkerClient<boolean>.start(options?: Omit<DeepPartial<StartOptions>, "httpConnection" | "token" | "connection">): Promise<void>
start();

Hablando con otros workers

Si por alguna razón (no encontré ninguna para el ejemplo), deseas que un worker específico ejecute una acción que otro recibió, puedes simplemente pedírselo.

const client: WorkerClient<boolean>
client.
WorkerClient<boolean>.tellWorker<void, {
    workerId: number;
}>(workerId: number, func: (_: WorkerClient<boolean>, vars: {
    workerId: number;
}) => void, vars: {
    workerId: number;
}): Promise<void>
tellWorker(
  1,
  (
worker: WorkerClient<boolean>
worker, 
vars: {
    workerId: number;
}
vars) => 
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.


The module exports two specific components:


    

  • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
    • 

  • A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
    • 



Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.


Example using the global console:


console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3


const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr


Example using the Console class:


const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);


myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err


const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).


const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout


See util.format() for more information.
@since ― v0.1.100
log(`Hola worker #${
worker: WorkerClient<boolean>
worker.
WorkerClient<boolean>.workerId: number
workerId} desde ${
vars: {
    workerId: number;
}
vars.
workerId: number
workerId}`),
  { 
workerId: number
workerId: 
const client: WorkerClient<boolean>
client.
WorkerClient<boolean>.workerId: number
workerId }
);