realm-object-server-enterprise/dist/ReplicatedSyncService.d.ts

Realm Object Server Enterprise

import { RealmSyncServer, RealmSyncServerOperatingMode, IRealmSyncServerConfiguration } from "realm-sync-server";
import { Logger, Discovery, Server, SyncServiceConfig, stats } from "realm-object-server";
import { ConsulDiscovery } from "./ConsulDiscovery";
import * as consul from "consul";
export declare class MasterRecord {
    master: {
        id: string;
        address: string;
        port: string | number;
    };
    slave: {
        id: string;
        complete: boolean;
    };
}
export declare enum ReplicatedSyncBackupMode {
    Asynchronous = 1,
    Synchronous = 2
}
export interface ReplicatedSyncServiceConfig extends SyncServiceConfig {
    consul: consul.Consul;
    id: string;
    featureToken: string;
    namespace?: string;
    backupMode?: ReplicatedSyncBackupMode;
}
export declare class BaseSyncService {
    tags: string[];
    protected logger: Logger;
    protected wrapperService: ReplicatedSyncService;
    protected syncConfig: IRealmSyncServerConfiguration;
    protected server: RealmSyncServer;
    constructor(syncConfig: IRealmSyncServerConfiguration);
    start(wrapperService: ReplicatedSyncService): Promise<void>;
    stop(): Promise<void>;
    protected getAddress(): {
        address: string;
        port: number;
    };
    protected register(roleTag?: string): Promise<void>;
    protected deregister(): Promise<void>;
}
export declare class MasterSyncService extends BaseSyncService {
    private callbackQueue;
    private settingSlaveStatus;
    start(wrapperService: ReplicatedSyncService): Promise<void>;
    private setSlaveStatus;
}
export declare class SlaveSyncService extends BaseSyncService {
    start(wrapperService: ReplicatedSyncService): Promise<void>;
}
export declare class SpareSyncService extends BaseSyncService {
    start(wrapperService: ReplicatedSyncService): Promise<void>;
}
export declare class ReplicatedSyncService {
    tags: string[];
    discovery: ConsulDiscovery;
    label: string;
    logger: Logger;
    namespace: string;
    backupMode: RealmSyncServerOperatingMode;
    stats: stats.StatsSink;
    private consul;
    private promoter;
    private masterKey;
    private slaveKey;
    private syncConfig;
    private timeout;
    private service;
    private statsdReceiver;
    private statsdToStatsSink;
    private statsdSocket;
    constructor(serviceConfig: ReplicatedSyncServiceConfig);
    setLogger(logger: Logger): void;
    start(discovery: Discovery): Promise<void>;
    startWithServer(server: Server): Promise<void>;
    stop(): Promise<void>;
    getAddress(): {
        address: string;
        port: number;
    };
    getMasterRecord(): Promise<{
        cas: string;
        record: MasterRecord;
    }>;
    setMasterRecord(cas: string, record: MasterRecord): Promise<boolean>;
    private spare;
    private slave;
    private candidate;
    private master;
}