@interopio/bridge 0.0.1-alpha → 0.0.4-beta.0

package/src/discovery/multicast/MulticastDiscoveryStrategy.ts

@@ -1,141 +0,0 @@
-import {createSocket, type RemoteInfo, Socket} from 'node:dgram';
-import {type DiscoveryNode, type DiscoveryStrategy} from '../index.ts';
-import {SimpleDiscoveryNode} from '../SimpleDiscoveryNode.ts';
-import {type Properties} from '../../config/Properties.ts';
-import {GROUP, PORT} from './MulticastProperties.ts';
-import {getOrDefault} from '../settings.ts';
-import {fromHostname, toIpAddress} from '../../cluster/Address.ts';
-import {isLoopback} from '../../utils/network.ts';
-import {type Logger} from '../../logging.ts';
-
-const DATA_OUTPUT_BUFFER_SIZE = 64 * 1024;
-const DEFAULT_MULTICAST_PORT = 34567;
-const DEFAULT_MULTICAST_GROUP = '239.1.2.3';
-const SOCKET_TIME_TO_LIVE = 255; // unrestricted (other possible values would be 1 (local-network), 15 (site-local), 32(local-area), 64(regional), 128(global))
-
-interface MulticastMemberInfo {
-    readonly host: string;
-    readonly port: number;
-}
-
-function multicastDiscoverySender(discoveryNode: DiscoveryNode | undefined, socket: Socket, group: string, port: number): () => void {
-    let multicastMemberInfo: MulticastMemberInfo;
-    if (discoveryNode) {
-        const address = discoveryNode.publicAddress;
-        multicastMemberInfo = {host: address.host, port: address.port};
-    }
-    const msg: Buffer = Buffer.from(JSON.stringify(multicastMemberInfo));
-
-    return () => {
-        socket.send(msg, port, group, (error) => {
-            console.error(error);
-        });
-    }
-}
-
-function multicastDiscoveryReceiver(socket: Socket): () => Promise<MulticastMemberInfo> {
-    return () => {
-        return new Promise<MulticastMemberInfo>((resolve, reject) => {
-            socket.on('message', (message: Buffer, remote: RemoteInfo) => {
-                resolve(JSON.parse(message as unknown as string));
-            });
-            socket.on('error', (err: Error) => {
-                reject(err);
-            });
-        });
-    }
-}
-
-export class MulticastDiscoveryStrategy implements DiscoveryStrategy {
-    private readonly logger: Logger;
-    private readonly properties: Properties;
-    private readonly discoveryNode?: DiscoveryNode;
-    private isClient?: boolean;
-    private discoverySender?: () => void;
-    private discoveryReceiver?: () => Promise<MulticastMemberInfo>;
-    private sendIntervalId?: ReturnType<typeof setInterval>;
-    private socket?: Socket;
-    constructor(discoveryNode: DiscoveryNode | undefined,
-                logger: Logger,
-                properties: Properties) {
-        this.logger = logger;
-        this.properties = properties;
-        this.discoveryNode = discoveryNode;
-    }
-
-    private async initializeMulticastSocket() {
-        const port = getOrDefault(this.properties, '', PORT, DEFAULT_MULTICAST_PORT);
-        if (port < 0 || port > 65535) {
-            throw new Error('port number must be between 0 and 65535');
-        }
-        const group = getOrDefault(this.properties, '', GROUP, DEFAULT_MULTICAST_GROUP);
-        this.socket = createSocket({
-            type: 'udp4',
-            reuseAddr: true,
-            recvBufferSize: DATA_OUTPUT_BUFFER_SIZE,
-            sendBufferSize: DATA_OUTPUT_BUFFER_SIZE});
-
-        if (this.discoveryNode) {
-            const address = await toIpAddress(this.discoveryNode.privateAddress);
-            if (!isLoopback(address)) {
-                this.socket.setMulticastInterface(address.address);
-            }
-        }
-
-        this.socket.bind(port, () => {
-            this.socket.setMulticastTTL(SOCKET_TIME_TO_LIVE);
-            this.socket.addMembership(group);
-        });
-
-        this.discoverySender = multicastDiscoverySender(this.discoveryNode, this.socket, group, port);
-        this.discoveryReceiver = multicastDiscoveryReceiver(this.socket);
-        if (this.discoveryNode == null) {
-            this.isClient = true;
-        }
-    }
-
-    async discover(): Promise<Iterable<DiscoveryNode> | undefined> {
-        const multicastMemberInfo = await this.discoveryReceiver();
-        if (multicastMemberInfo) {
-            const list = [];
-            try {
-                const discoveryNode = new SimpleDiscoveryNode(await fromHostname(multicastMemberInfo.host, multicastMemberInfo.port));
-                list.push(discoveryNode);
-            }
-            catch (e) {
-                this.logger.trace(e.message);
-            }
-            return list;
-        }
-    }
-
-    async start() {
-        await this.initializeMulticastSocket();
-        if (!this.isClient) {
-            this.sendIntervalId = setInterval(() => {
-                this.discoverySender();
-            }, 2000);
-        }
-    }
-
-    async close() {
-        if (this.sendIntervalId) {
-            clearInterval(this.sendIntervalId);
-            delete this.sendIntervalId;
-        }
-        return new Promise<void>((resolve, reject) => {
-            if (this.socket)
-            {
-                this.socket.close(() => {
-                    resolve()
-                });
-            }
-            else
-            {
-                resolve();
-            }
-        });
-
-    }
-
-}

package/src/discovery/multicast/MulticastDiscoveryStrategyFactory.ts

@@ -1,30 +0,0 @@
-import {
-    type DiscoveryNode,
-    type DiscoveryStrategy,
-    type DiscoveryStrategyFactory,
-    DiscoveryStrategyPriorities
-} from '../index.ts';
-import {MulticastDiscoveryStrategy} from './MulticastDiscoveryStrategy.ts';
-import {GROUP, PORT} from './MulticastProperties.ts';
-import {type Properties, type  PropertyDefinition} from '../../config/Properties.ts';
-import {type Logger} from '../../logging.ts';
-
-const PROPERTY_DEFINITIONS: ReadonlyArray<PropertyDefinition> = [
-    GROUP,
-    PORT
-];
-
-export class MulticastDiscoveryStrategyFactory implements DiscoveryStrategyFactory {
-    readonly priority = DiscoveryStrategyPriorities.UNKNOWN;
-    newDiscoveryStrategy(discoveryNode: DiscoveryNode, logger: Logger, prop: Properties): DiscoveryStrategy {
-        return new MulticastDiscoveryStrategy(discoveryNode, logger, prop);
-    }
-
-    async isAutoDetectionApplicable(): Promise<boolean> {
-        return false;
-    }
-
-    getConfigurationProperties(): ReadonlyArray<PropertyDefinition> {
-        return PROPERTY_DEFINITIONS;
-    }
-}

package/src/discovery/multicast/MulticastProperties.ts

@@ -1,4 +0,0 @@
-import {NUMBER, property, STRING} from '../../config/Properties.ts';
-
-export const PORT = property<number>('port', NUMBER);
-export const GROUP = property<string>('group', STRING);

package/src/discovery/settings.ts

@@ -1,37 +0,0 @@
-import {type Properties, type PropertyDefinition, type PropertyType} from '../config/Properties.ts';
-
-function getProperty(prefix: string, property: PropertyDefinition) {
-    let s = prefix;
-    if (!s.endsWith('.')) {
-        s += '.';
-    }
-    return s + property.key;
-}
-
-function readProperty(prefix: string | undefined, property: PropertyDefinition): PropertyType | undefined {
-    if (prefix) {
-        const p = getProperty(prefix, property);
-        const v = process.env[p];
-        // todo convert
-        return v;
-    }
-}
-
-export function getOrUndefined<T extends PropertyType>(properties: Properties, prefix: string, property?: PropertyDefinition): T | undefined {
-    return getOrDefault(properties, prefix, property);
-}
-
-export function getOrDefault<T extends PropertyType>(properties: Properties, prefix: string, property?: PropertyDefinition, defaultValue?: T) {
-    if (property === undefined) {
-        return defaultValue;
-    }
-
-    let value = readProperty(prefix, property);
-    if (value === undefined) {
-        value = properties[property.key];
-    }
-    if (value === undefined) {
-        return defaultValue;
-    }
-    return value as T;
-}

package/src/error/RequestFailure.ts

@@ -1,48 +0,0 @@
-import type {DataInput, DataOutput, VersionedSerializer} from '../io/VersionedSerializer.ts';
-
-export const RequestFailure = {
-    UNKNOWN: 0,
-}
-
-export type RequestFailureReason = keyof typeof RequestFailure
-
-const codeToReason: RequestFailureReason[] = function initCodeToReason() {
-    const result: RequestFailureReason[] = [];
-    for (const [reason, code] of Object.entries(RequestFailure)) {
-        if (result[code] !== undefined) {
-            throw new Error(`Duplicate RequestFailure code: ${code}`);
-        }
-        result[code] = reason as RequestFailureReason;
-    }
-    if (result.length >= 1<<8) {
-        throw new Error('RequestFailure codes exceed 8 bits');
-    }
-    return result;
-} ();
-
-export function fromCode(code: number): RequestFailureReason {
-    if (code < 0) {
-        throw new Error(`Invalid RequestFailure code: ${code}`);
-    }
-    return codeToReason[code] ?? 'UNKNOWN';
-}
-
-export function forError(error: Error): RequestFailureReason {
-    return 'UNKNOWN';
-}
-
-export const RequestFailureReasonSerializer: VersionedSerializer<RequestFailureReason> = new (class implements VersionedSerializer<RequestFailureReason> {
-    serializedSize(value: RequestFailureReason, version?: number): number {
-        return 1;
-    }
-
-    serialize(value: RequestFailureReason, output: DataOutput, version?: number) {
-        const code = RequestFailure[value];
-        output.writeUint8(code);
-    }
-
-    deserialize(input: DataInput, version?: number): RequestFailureReason {
-        const code = input.readUint8();
-        return fromCode(code);
-    }
-})

package/src/gossip/ApplicationState.ts

@@ -1,48 +0,0 @@
-const ApplicationStates = {
-    _STATUS: 0,
-    LOAD: 1,
-    _SCHEMA: 2,
-    DC: 3,
-    RACK: 4,
-    RELEASE_VERSION: 5,
-    _INTERNAL_IP: 7,
-    _RPC_ADDRESS: 8,
-    NET_VERSION: 11,
-    HOST_ID: 12,
-    _TOKENS: 13,
-    _RPC_READY: 14,
-    INTERNAL_ADDRESS: 15,
-    NATIVE_ADDRESS: 16,
-    STATUS: 17,
-    _SSTABLE_VERSIONS: 18,
-    _DISK_USAGE: 19,
-    _INDEX_STATUS: 20,
-    _X1: 21,
-    _X2: 22,
-    _X3: 23,
-    _X4: 24,
-    _X5: 25,
-    _X6: 26,
-    _X7: 27,
-    _X8: 28,
-    _X9: 29
-}
-
-export function forId(id: number): ApplicationState {
-    const entry = Object.entries(ApplicationStates)
-        .find(([, code]) => id === code);
-    if (!entry) {
-        throw new Error(`No ApplicationState found for id ${id}`);
-    }
-    return entry[0] as ApplicationState;
-}
-export function toId(name: ApplicationState): number {
-    const entry = Object.entries(ApplicationStates)
-        .find(([state]) => name === state);
-    if (!entry) {
-        throw new Error(`No ApplicationState found for name ${name}`);
-    }
-    return entry[1] as number;
-}
-
-export type ApplicationState = keyof typeof ApplicationStates;

package/src/gossip/EndpointState.ts

@@ -1,141 +0,0 @@
-import type {DataInput, DataOutput, VersionedSerializer} from '../io/VersionedSerializer.ts';
-import {HeartbeatState, HeartbeatStateSerializer} from './HeartbeatState.ts';
-import {type ApplicationState, forId, toId} from './ApplicationState.ts';
-import {type VersionedValue, VersionedValueSerializer} from './VersionedValue.ts';
-import {globalClock} from '../utils/clock.ts';
-
-export class EndpointState {
-    private _heartbeat: HeartbeatState
-    private _application: Map<ApplicationState, VersionedValue>
-    private _timestamp: bigint
-    private _alive: boolean
-
-    constructor(heartbeat: HeartbeatState, states?: Map<ApplicationState, VersionedValue>) {
-        this._heartbeat = heartbeat;
-        this._application = states ?? new Map<ApplicationState, VersionedValue>();
-        this._timestamp = globalClock.nanoTime();
-        this._alive = true;
-    }
-
-    copy(): EndpointState {
-        return new EndpointState(this.heartbeat.copy(), new Map(this._application));
-    }
-
-    updateTimestamp(): void {
-        this._timestamp = globalClock.nanoTime();
-    }
-
-    get timestamp(): bigint {
-        return this._timestamp;
-    }
-
-    /*testing*/ set timestamp(timestamp: bigint) {
-        this._timestamp = timestamp
-    }
-
-    public get heartbeat(): HeartbeatState {
-        return this._heartbeat;
-    }
-
-    set heartbeat(heartbeat: HeartbeatState) {
-        this.updateTimestamp();
-        this._heartbeat = heartbeat
-    }
-
-    getApplicationState(key: ApplicationState): VersionedValue {
-        return this._application.get(key);
-    }
-
-    hasApplicationState(key: ApplicationState): boolean {
-        return this._application.has(key);
-    }
-
-    public states() {
-        return this._application.entries();
-    }
-
-    addApplicationState(key: ApplicationState, value: VersionedValue): void {
-        this.addApplicationStates([[key, value]]);
-    }
-
-    addApplicationStates(values: [ApplicationState, VersionedValue][]): void {
-        while (true) {
-            const orig = this._application;
-            const copy = new Map(orig);
-
-            for (const [key, value] of values) {
-                copy.set(key, value);
-            }
-
-            if (this._application === orig) {
-                this._application = copy;
-                return;
-            }
-        }
-    }
-
-    get isAlive(): boolean {
-        return this._alive;
-    }
-
-    markAsDead(): void {
-        this._alive = false;
-    }
-
-    markAsAlive(): void {
-        this._alive = true;
-    }
-
-    get isStateEmpty(): boolean {
-        return this._application.size === 0;
-    }
-
-    get isEmptyWithoutStatus(): boolean {
-        const state = this._application;
-        const hasStatus = state.has('STATUS') || state.has('_STATUS');
-        return this._heartbeat.isEmpty() && !hasStatus;
-    }
-
-    toString() {
-        return `EndpointState{heartbeat=${this._heartbeat}, ApplicationState=${this._application}`;
-    }
-}
-
-export const EndpointStateSerializer = new (class implements VersionedSerializer<EndpointState> {
-    serialize(value: EndpointState, output: DataOutput, version: number) {
-        const heartbeat = value.heartbeat;
-        HeartbeatStateSerializer.serialize(heartbeat, output, version);
-
-        const states = Array.from(value.states());
-        output.writeInt32(states.length);
-        for (const [key, state] of states) {
-            output.writeInt32(toId(key));
-            VersionedValueSerializer.serialize(state, output, version);
-        }
-    }
-
-    deserialize(input: DataInput, version: number): EndpointState {
-        const heartbeat = HeartbeatStateSerializer.deserialize(input, version);
-        const size = input.readInt32();
-
-        const state = new EndpointState(heartbeat);
-        for (let i = 0; i < size; i++) {
-            const key = input.readInt32();
-            const value = VersionedValueSerializer.deserialize(input, version);
-            state.addApplicationState(forId(key), value);
-        }
-        return state;
-    }
-
-    serializedSize(value: EndpointState, version: number): number {
-        let size = HeartbeatStateSerializer.serializedSize(value.heartbeat, version);
-        const states = value.states();
-        size += 4; // size of states
-        for (const [key, state] of states) {
-            size += 4; // key
-            size += VersionedValueSerializer.serializedSize(state, version);
-        }
-        return size;
-    }
-});
-

package/src/gossip/FailureDetector.ts

@@ -1,235 +0,0 @@
-import {type Address, addressAsString} from '../cluster/Address.ts';
-import {ObjectMap} from '../utils/collections.ts';
-import {preciseClock} from '../utils/clock.ts';
-import {convert} from '../config/Duration.ts';
-import getLogger from '../logging.ts';
-
-export interface FailureDetector {
-
-    /**
-     * invoked by any entity (gossiper) wanting to interrogate the status of the endpoint.
-     *
-     * @param endpoint
-     */
-    interpret(endpoint: Address): void;
-
-    /**
-     * invoked by the receiver of the heartbeat (gossiper).
-     * @param endpoint endpoint being reported
-     */
-    report(endpoint: Address): void
-
-    /**
-     * remove an endpoint
-     */
-    remove(endpoint: Address): void
-
-    /**
-     * force conviction of the specified endpoint in the failure detector.
-     * @param endpoint endpoint to be convicted
-     */
-    forceConviction(endpoint: Address): void;
-
-
-}
-
-
-export interface IFailureDetectionEventListener {
-    /**
-     * Convict the specified endpoint
-     * @param endpoint endpoint to be convicted
-     * @param phi the value of phi with which the endpoint was convicted
-     */
-    convict(endpoint: Address, phi: number): void;
-}
-
-class ArrayBackedBoundedStats {
-    private readonly _arrivalIntervals: Array<bigint>;
-    private _sum: bigint = 0n;
-    private _index: number = 0;
-    private _full = false;
-    private _mean: number = 0.0;
-
-    constructor(size: number) {
-        this._arrivalIntervals = new Array<bigint>(size);
-    }
-
-    add(interval: bigint): void {
-        if (this._index === this._arrivalIntervals.length) {
-            this._full = true;
-            this._index = 0;
-        }
-        if (this._full) {
-            this._sum = this._sum - this._arrivalIntervals[this._index];
-        }
-
-        this._arrivalIntervals[this._index++] = interval;
-        this._sum += interval;
-
-        this._mean = Number(this._sum) / this.size();
-    }
-
-    private size(): number {
-        return this._full ? this._arrivalIntervals.length : this._index;
-    }
-
-    public get mean(): number {
-        return this._mean;
-    }
-
-    toString(): string {
-        return `${this._arrivalIntervals}`;
-    }
-
-}
-
-const logger = getLogger('gossip.fd');
-
-const INITIAL_VALUE_NS = convert('nanoseconds', 2 * 1000/*gossiper interval*/, 'milliseconds');
-
-
-
-class ArrivalWindow {
-    private static readonly MAX_INTERVAL_NS = ArrivalWindow.getMaxInterval();
-    private readonly _arrivalIntervals: ArrayBackedBoundedStats;
-    private _lastReportedPhi: number = Number.MIN_VALUE;
-    private _last: bigint = 0n;
-
-    constructor(size: number) {
-        this._arrivalIntervals = new ArrayBackedBoundedStats(size);
-    }
-
-    static getMaxInterval(): bigint {
-        return INITIAL_VALUE_NS;
-    }
-
-    add(now: bigint, endpoint: Address) {
-        if (this._last < 0n) {
-            throw new Error();
-        }
-        if (this._last > 0n) {
-            const interval = now - this._last;
-            if (interval <= ArrivalWindow.MAX_INTERVAL_NS) {
-                this._arrivalIntervals.add(interval);
-                logger.enabledFor(`trace`) && logger.debug(`Reporting Interval time for ${addressAsString(endpoint)}: ${interval}ns`);
-            }
-            else {
-                logger.enabledFor(`trace`) && logger.debug(`Ignoring Interval time for ${addressAsString(endpoint)}: ${interval}ns`);
-            }
-        }
-        else {
-            this._arrivalIntervals.add(INITIAL_VALUE_NS);
-        }
-        this._last = now;
-    }
-
-    get mean(): number {
-        return this._arrivalIntervals.mean;
-    }
-
-    get lastReportedPhi(): number {
-        return this._lastReportedPhi;
-    }
-
-    phi(now: bigint): number {
-        if (!(this._arrivalIntervals.mean > 0 && this._last > 0n)) {
-            throw new Error('mean and last should be > 0 (mean: ' + this._arrivalIntervals.mean + ', last: ' + this._last + ')');
-        }
-        const t = Number(now - this._last);
-        this._lastReportedPhi = t / this.mean;
-        return this._lastReportedPhi;
-    }
-}
-
-// "The Phi Accrual Failure Detector"
-export const failureDetector: FailureDetector = new (class implements FailureDetector {
-    private readonly SAMPLE_SIZE = 1000;
-
-
-    private readonly PHI_FACTOR = 1.0 / Math.log(10.0);
-    private readonly arrivalSamples: Map<Address, ArrivalWindow> = new ObjectMap<Address, ArrivalWindow>();
-    private readonly listeners = new Array<IFailureDetectionEventListener>()
-
-    private lastPause: bigint = 0n;
-    private lastInterpret = preciseClock.now();
-
-    report(endpoint: Address) {
-
-        const now = preciseClock.now();
-        let arrivalWindow = this.arrivalSamples.get(endpoint);
-        if (arrivalWindow === undefined) {
-            arrivalWindow = new ArrivalWindow(this.SAMPLE_SIZE);
-            arrivalWindow.add(now, endpoint);
-
-            this.arrivalSamples.set(endpoint, arrivalWindow);
-        }
-        else {
-            arrivalWindow.add(now, endpoint);
-        }
-        if (logger.enabledFor('trace')) {
-            logger.debug(`Average for ${addressAsString(endpoint)}: ${arrivalWindow.mean}ns`);
-        }
-    }
-
-    interpret(endpoint: Address) {
-        const arrivalWindow =  this.arrivalSamples.get(endpoint);
-        if (arrivalWindow === undefined) {
-            return;
-        }
-        const now = preciseClock.now();
-        const diff = now - this.lastInterpret;
-        this.lastInterpret = now;
-
-        if (diff > MAX_LOCAL_PAUSE_NS) {
-            logger.warn(`Not marking nodes down due to local pause of ${diff}ns > ${MAX_LOCAL_PAUSE_NS}ns`);
-            this.lastPause = now;
-            return;
-        }
-        if ((preciseClock.now() - this.lastPause) < MAX_LOCAL_PAUSE_NS) {
-            if (logger.enabledFor('debug')) {
-                logger.debug(`Still not marking nodes down due to local pause`);
-            }
-            return;
-        }
-
-        const phi = arrivalWindow.phi(now);
-        if (logger.enabledFor('trace')) {
-            logger.debug(`PHI for ${addressAsString(endpoint)}: ${phi}`);
-        }
-
-        if (this.PHI_FACTOR * phi > this.getPhiConvictThreshold()) {
-            if (logger.enabledFor('trace')) {
-                logger.debug(`Node ${addressAsString(endpoint)} phi ${this.PHI_FACTOR * phi} > ${this.getPhiConvictThreshold()}; intervals ${arrivalWindow}, mean: ${arrivalWindow.mean}ns`);
-            }
-            for (const listener of this.listeners) {
-                listener.convict(endpoint, phi);
-            }
-        }
-        else if (logger.enabledFor('debug') && (this.PHI_FACTOR * phi * DEBUG_PERCENTAGE /100.0 > this.getPhiConvictThreshold())) {
-            logger.debug(`PHI for ${addressAsString(endpoint)}: ${phi}`);
-        } else if (logger.enabledFor('trace')) {
-            logger.debug(`PHI for ${addressAsString(endpoint)}: ${phi}`);
-        }
-    }
-
-    forceConviction(endpoint: Address) {
-        if (logger.enabledFor('debug')) {
-            logger.debug(`Forcing conviction of ${addressAsString(endpoint)}`);
-        }
-        for (const listener of this.listeners) {
-            listener.convict(endpoint, this.getPhiConvictThreshold());
-        }
-    }
-
-    remove(endpoint: Address) {
-        this.arrivalSamples.delete(endpoint);
-    }
-
-    private getPhiConvictThreshold(): number {
-        return 8.0;
-    }
-
-
-});
-const MAX_LOCAL_PAUSE_NS = convert('nanoseconds', 5000, 'milliseconds');
-const DEBUG_PERCENTAGE = 80;