hamok/lib/raft/RaftEngine.d.ts

Lightweight Distributed Object Storage on RAFT consensus algorithm

import { EventEmitter } from 'events';
import { RaftMessageEmitter } from '../messages/RaftMessageEmitter';
import { SyncedProperties } from './SyncedProperties';
import { HamokMessage } from '../messages/HamokMessage';
import { RaftState } from './RaftState';
import type { HamokEventMap } from '../Hamok';
import { RaftLogs } from './RaftLogs';
/**
 * Configuration settings for the Raft engine.
 */
export type RaftEngineConfig = {
    /**
     * The unique identifier for the peer in the Raft cluster.
     */
    peerId: string;
    /**
     * The timeout duration in milliseconds for elections.
     * If an election has not been completed within this duration, a  candidate change state to follower.
     */
    electionTimeoutInMs: number;
    /**
     * The maximum idle time in milliseconds for a follower.
     * If the follower is idle for longer than this duration, it considers the leader to be unavailable and starts an election.
     */
    followerMaxIdleInMs: number;
    /**
     * The interval in milliseconds at which heartbeats are sent by the leader to maintain authority over followers,
     * and sending the logs.
     */
    heartbeatInMs: number;
    /**
     * If true, this peer will only be a follower and will never become a candidate or leader.
     */
    onlyFollower: boolean;
};
interface HamokController extends EventEmitter {
    on<U extends keyof HamokEventMap>(event: U, listener: (...args: HamokEventMap[U]) => void): this;
    once<U extends keyof HamokEventMap>(event: U, listener: (...args: HamokEventMap[U]) => void): this;
    off<U extends keyof HamokEventMap>(event: U, listener: (...args: HamokEventMap[U]) => void): this;
    emit<U extends keyof HamokEventMap>(event: U, ...args: HamokEventMap[U]): boolean;
}
export declare class RaftEngine {
    readonly config: RaftEngineConfig;
    readonly logs: RaftLogs;
    readonly events: HamokController;
    private _state;
    readonly props: SyncedProperties;
    private _leaderId?;
    readonly remotePeers: Set<string>;
    readonly transport: RaftMessageEmitter;
    private _failedElections;
    constructor(config: RaftEngineConfig, logs: RaftLogs, events: HamokController);
    get localPeerId(): string;
    get leaderId(): string | undefined;
    get failedElections(): number;
    set leaderId(newLeaderId: string | undefined);
    get state(): RaftState;
    set state(newState: RaftState);
    submit(message: HamokMessage): boolean;
}
export {};
//# sourceMappingURL=RaftEngine.d.ts.map