hamok/lib/raft/MemoryStoredRaftLogs.d.ts

Lightweight Distributed Object Storage on RAFT consensus algorithm

import { EventEmitter } from 'events';
import { HamokMessage } from '../messages/HamokMessage';
import { LogEntry } from './LogEntry';
import { RaftLogs } from './RaftLogs';
export type MemoryStoredRaftLogsEventMap = {
    committed: [commitIndex: number, message: HamokMessage];
    expired: [commitIndex: number, message: HamokMessage];
    removed: [commitIndex: number, message: HamokMessage];
    highWaterMark: [memorySize: number];
};
export type MemoryStoredRaftLogsConfig = {
    expirationTimeInMs: number;
    memorySizeHighWaterMark: number;
};
export declare interface MemoryStoredRaftLogs {
    on<U extends keyof MemoryStoredRaftLogsEventMap>(event: U, listener: (...args: MemoryStoredRaftLogsEventMap[U]) => void): this;
    once<U extends keyof MemoryStoredRaftLogsEventMap>(event: U, listener: (...args: MemoryStoredRaftLogsEventMap[U]) => void): this;
    off<U extends keyof MemoryStoredRaftLogsEventMap>(event: U, listener: (...args: MemoryStoredRaftLogsEventMap[U]) => void): this;
    emit<U extends keyof MemoryStoredRaftLogsEventMap>(event: U, ...args: MemoryStoredRaftLogsEventMap[U]): boolean;
}
export declare class MemoryStoredRaftLogs extends EventEmitter implements RaftLogs {
    readonly config: MemoryStoredRaftLogsConfig;
    /**
     * index of highest log entry applied to state
     * machine (initialized to 0, increases
     * monotonically)
     */
    private _firstIndex;
    /**
     * The next log index
     */
    private _nextIndex;
    /**
     * index of highest log entry known to be
     * committed (initialized to 0, increases
     * monotonically)
     */
    private _commitIndex;
    private _mssingEntriesLogged;
    private _memoryEstimateBytesLength;
    private readonly _entries;
    constructor(config: MemoryStoredRaftLogsConfig, entries?: Map<number, LogEntry>);
    /**
     * index of highest log entry known to be
     * committed (initialized to 0, increases
     * monotonically)
     */
    get commitIndex(): number;
    /**
     * The next index for the logs to be used if an entry is added or submitted
     * @return
     */
    get nextIndex(): number;
    get firstIndex(): number;
    get size(): number;
    get bytesInMemory(): number;
    commitUntil(newCommitIndex: number): Readonly<LogEntry[]>;
    submit(term: number, entry: HamokMessage): number;
    compareAndOverride(index: number, expectedTerm: number, entry: HamokMessage): LogEntry | undefined;
    compareAndAdd(expectedNextIndex: number, term: number, entry: HamokMessage): boolean;
    get(index: number): LogEntry | undefined;
    collectEntries(startIndex: number, endIndex?: number): LogEntry[];
    /**
     * Direct iterator for the logs. Starts with commitIndex + 1, and iterates the logs until nextIndex.
     * if a log is comitted after this iterator has been created but before the next is called on this iterator
     * @return
     */
    [Symbol.iterator](): IterableIterator<LogEntry>;
    reset(newCommitIndex: number): void;
    removeUntil(newFirstIndex: number): void;
    private _expire;
}
//# sourceMappingURL=MemoryStoredRaftLogs.d.ts.map