@interopio/bridge 0.0.1-alpha

package/src/discovery/index.ts

@@ -0,0 +1,207 @@
+import {type Address} from '../cluster/Address.ts';
+import {type Properties, type PropertyDefinition} from '../config/Properties.ts';
+import {type DiscoveryConfig, type DiscoveryStrategyConfig} from '../config/DiscoveryConfig.ts';
+import {type Logger} from '../logging.ts';
+import {KubernetesDiscoveryStrategyFactory} from '../kubernetes/KubernetesDiscoveryStrategyFactory.ts';
+import {MulticastDiscoveryStrategyFactory} from './multicast/MulticastDiscoveryStrategyFactory.ts';
+
+export interface DiscoveryServiceFactory {
+    newDiscoveryService(settings: DiscoveryServiceSettings): DiscoveryService
+}
+
+export interface DiscoveryService {
+    start(): Promise<void>
+    discover(): Promise<Iterable<DiscoveryNode>>
+    close(): Promise<void>
+}
+
+
+export type DiscoveryServiceSettings = {
+    readonly node: Promise<DiscoveryNode>
+    readonly mode: DiscoveryMode
+    readonly conf: DiscoveryConfig
+    readonly auto: boolean
+    readonly logger: Logger
+}
+
+export type DiscoveryMode = 'member' | 'client';
+
+export class DefaultDiscoveryServiceFactory implements DiscoveryServiceFactory {
+    newDiscoveryService(settings: DiscoveryServiceSettings): DiscoveryService {
+        return new DefaultDiscoveryService(settings);
+    }
+}
+
+function verifyNoUnknownProperties(mappedProperties: Properties, allProperties: Properties) {
+    const unknownProperties = Object.keys(allProperties).filter(key => !mappedProperties.hasOwnProperty(key));
+    if (unknownProperties.length > 0) {
+        throw new Error(`Unknown properties: ${unknownProperties.join(', ')} on discovery strategy`);
+    }
+}
+
+function prepareProperties(properties: Properties,
+                           propertyDefinitions: readonly PropertyDefinition[]) {
+    const mappedProperties: Properties = {};
+    for (const propertyDefinition of propertyDefinitions) {
+        const propertyKey = propertyDefinition.key;
+        if (properties[propertyKey] == undefined) {
+            if (!propertyDefinition.optional) {
+                throw new Error(`Missing required property: ${propertyKey} on discovery strategy`);
+            }
+            continue;
+        }
+        const value = properties[propertyKey];
+        const converter = propertyDefinition.converter;
+        const mappedValue = converter.convert(value);
+
+        mappedProperties[propertyKey] = mappedValue;
+    }
+
+    verifyNoUnknownProperties(mappedProperties, properties);
+    return mappedProperties;
+
+}
+
+export class DefaultDiscoveryService implements DiscoveryService {
+    private readonly settings: DiscoveryServiceSettings;
+    private readonly strategies: Array<DiscoveryStrategy> = [];
+    constructor(settings: DiscoveryServiceSettings) {
+        this.settings = settings;
+    }
+
+    async start(): Promise<void> {
+        this.strategies.push(...await this.loadDiscoveryStrategies());
+        for (const strategy of this.strategies) {
+            await strategy.start();
+        }
+    }
+
+    async discover(): Promise<Iterable<DiscoveryNode>> {
+        const discoveryNodes = new Set<DiscoveryNode>();
+        for (const strategy of this.strategies) {
+            const candidates = await strategy.discover();
+            if (candidates) {
+                for (const candidate of candidates) {
+                    if (this.validateCandidate(candidate)) {
+                        discoveryNodes.add(candidate);
+                    }
+                }
+            }
+
+        }
+
+        return discoveryNodes;
+    }
+
+    async close(): Promise<void> {
+        for (const strategy of this.strategies) {
+            await strategy.close();
+        }
+    }
+
+    private validateCandidate(candidate: DiscoveryNode) : boolean {
+        // todo
+        return true;
+    }
+
+    private async loadDiscoveryStrategies(): Promise<Iterable<DiscoveryStrategy>> {
+
+        const discoveryStrategyConfigs = this.settings.conf.discoveryStrategyConfigs;
+        const factories = this.collectFactories(discoveryStrategyConfigs);
+
+        const discoveryStrategies = new Array<DiscoveryStrategy>();
+        for (const config of discoveryStrategyConfigs) {
+            const discoveryStrategy = await this.buildDiscoveryStrategy(config, factories);
+            discoveryStrategies.push(discoveryStrategy);
+        }
+        const logger = this.settings.logger;
+        if (discoveryStrategies.length == 0 && this.settings.auto) {
+            logger.debug(`Discovery auto-detection enabled, trying to detect discovery strategy`);
+            const autoDetectedFactory = await this.detectDiscoveryStrategyFactory(factories);
+            if (autoDetectedFactory) {
+                logger.debug(`Auto-detected discovery strategy: ${autoDetectedFactory.constructor.name}`);
+                discoveryStrategies.push(autoDetectedFactory.newDiscoveryStrategy(await this.settings.node, logger, {}));
+            }
+            else {
+                logger.debug(`No discovery strategy auto-detected`);
+            }
+        }
+        return discoveryStrategies;
+    }
+
+    private collectFactories(strategyConfigs: ReadonlyArray<DiscoveryStrategyConfig>): DiscoveryStrategyFactory[] {
+
+        const knownFactories = [new MulticastDiscoveryStrategyFactory(), new KubernetesDiscoveryStrategyFactory()]
+
+        const factories = new Array<DiscoveryStrategyFactory>();
+
+        for (const factory of knownFactories) {
+            factories.push(factory);
+        }
+
+        for (const config of strategyConfigs) {
+            const factory = config.discoveryStrategyFactory;
+            if (factory) {
+                factories.push(factory);
+            }
+        }
+
+        return factories;
+    }
+
+    private async buildDiscoveryStrategy(config: DiscoveryStrategyConfig,
+                                         factories: DiscoveryStrategyFactory[]): Promise<DiscoveryStrategy> {
+        const discoveryNode = await this.settings.node;
+        const logger = this.settings.logger;
+
+        for (const factory of factories) {
+            if (factory.constructor.name == config.discoveryStrategyFactory.constructor.name) {
+                const properties = prepareProperties(config.properties, factory.getConfigurationProperties());
+                return factory.newDiscoveryStrategy(discoveryNode, logger, properties);
+            }
+        }
+        throw new Error('DiscoveryStrategyFactory not found');
+    }
+
+    private async detectDiscoveryStrategyFactory(factories: DiscoveryStrategyFactory[]) {
+        let highestPriorityFactory: DiscoveryStrategyFactory;
+        for (const factory of factories) {
+            try {
+                if (await factory.isAutoDetectionApplicable()) {
+                    if (highestPriorityFactory === undefined || factory.priority > highestPriorityFactory.priority) {
+                        highestPriorityFactory = factory;
+                    }
+                }
+            } catch (error) {
+                // todo log error
+            }
+        }
+        return highestPriorityFactory;
+    }
+
+
+}
+
+export interface DiscoveryStrategy {
+    start(): Promise<void>
+    discover(): Promise<Iterable<DiscoveryNode> | undefined>
+    close(): Promise<void>
+}
+
+export interface DiscoveryStrategyFactory {
+    readonly priority: number
+    isAutoDetectionApplicable(): Promise<boolean>
+    newDiscoveryStrategy(node: DiscoveryNode, logger: Logger, settings: Properties): DiscoveryStrategy
+    getConfigurationProperties(): ReadonlyArray<PropertyDefinition>
+}
+export const DiscoveryStrategyPriorities = {
+    UNKNOWN: 0,
+    PLATFORM: 20,
+    CUSTOM: 50,
+}
+
+export interface DiscoveryNode {
+    readonly publicAddress: Address;
+    readonly privateAddress: Address;
+    readonly properties: ReadonlyMap<string, unknown>;
+}

package/src/discovery/multicast/MulticastDiscoveryStrategy.ts

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,141 @@
+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;
+    }
+});
+