ziron-state/dist/lib/StateServer.d.ts

Ziron state

import { Server, Socket } from "ziron-server";
import StateServerOptions from "./StateServerOptions";
import { StandaloneProcedures } from "ziron-server/dist/lib/Procedure";
import { StandaloneReceivers } from "ziron-server/dist/lib/Receiver";
export declare const enum ClientType {
    Worker = 0,
    Broker = 1
}
declare module 'ziron-server' {
    interface Socket {
        node: {
            type: ClientType;
            id: string;
            ip: string;
            port: number;
            path: string;
            uri: string;
            leader: boolean;
            joinPayload?: Record<string, any>;
        };
    }
}
type WorkerJoinMiddleware = (socket: Socket, payload: Record<any, any>) => void;
export declare class StateServer {
    get id(): string;
    private readonly _options;
    private _workerLeader;
    private _joinedWorkers;
    private _joinedBrokers;
    protected get joinedWorkers(): Socket[];
    protected get joinedBrokers(): Socket[];
    protected get workerLeader(): Socket | null;
    private readonly _logger;
    /**
     * @description
     * Use the server object carefully.
     * Never change properties on the server; use it only to access state information.
     * @protected
     */
    protected readonly server: Server;
    readonly joinToken: string;
    private _clusterSession;
    private _scaleTimeout?;
    protected workerJoinMiddleware: WorkerJoinMiddleware | undefined;
    protected readonly procedures: StandaloneProcedures<'#leave' | '#join'>;
    protected readonly receivers: StandaloneReceivers;
    constructor(options?: StateServerOptions);
    private _initScaleDelayActive;
    private _startInitScaleDelayTicker;
    listen(): Promise<void>;
    private _logRunningState;
    private _getJoinToken;
    private _initServer;
    private _createClusterSession;
    private _resetClusterSession;
    private static _getJoinedState;
    getJoinedBrokersState(): {
        time: number;
        uris: string[];
    };
    getJoinedWorkersState(): {
        time: number;
        uris: string[];
    };
    private _handleWorkerJoin;
    private _handleWorkerLeave;
    private _handleBrokerJoin;
    private _handleBrokerLeave;
    private _getRandomWorker;
    private _workerLeaderSelectionPromise;
    private _selectWorkerLeader;
    private _selectWorkerLeaderProcess;
    private _scaleOut;
    private _scaleBack;
    private _setScaleTimeout;
    private _updateWorkersBrokerState;
    private _isNodeIdInUse;
    /**
     * Terminates the state server.
     * After termination, you should not use this instance anymore
     * or anything else from the state server.
     * [Use this method only when you know what you do.]
     */
    terminate(): void;
}
export {};