@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/gossip/HeartbeatState.ts

@@ -1,66 +0,0 @@
-import type {DataInput, DataOutput, VersionedSerializer} from '../io/VersionedSerializer.ts';
-import {getNextVersion} from './VersionedValue.ts';
-
-export const EMPTY_VERSION = -1;
-
-export class HeartbeatState {
-    private _generation: number;
-    private _version: number;
-
-    constructor(generation: number, version?: number) {
-        this._generation = generation;
-        this._version = version ?? 0;
-    }
-
-    copy(): HeartbeatState {
-        return new HeartbeatState(this._generation, this._version);
-
-    }
-
-    public static empty(): HeartbeatState {
-        return new HeartbeatState(-1);
-    }
-
-    public isEmpty(): boolean {
-        return this.generation === EMPTY_VERSION;
-    }
-
-    public get generation(): number {
-        return this._generation;
-    }
-
-    updateHeartbeatVersion(): void {
-        this._version = getNextVersion();
-    }
-
-    public get version(): number {
-        return this._version;
-    }
-
-    /*unsafe*/ forceNewerGeneration(): void {
-        this._generation += 1;
-    }
-
-    /*testing*/ forceHighestPossibleVersion(): void {
-        this._version = Number.MAX_SAFE_INTEGER;
-    }
-
-    toString(): string {
-        return `Heartbeat: {generation: ${this.generation}, version: ${this.version}}`;
-    }
-}
-
-export const HeartbeatStateSerializer = new (class implements VersionedSerializer<HeartbeatState> {
-    serialize(value: HeartbeatState, output: DataOutput, version: number): void {
-        output.writeInt32(value.generation);
-        output.writeInt32(value.version);
-    }
-
-    deserialize(input: DataInput, version: number): HeartbeatState {
-        return new HeartbeatState(input.readInt32(), input.readInt32());
-    }
-
-    serializedSize(value: HeartbeatState, version: number): number {
-        return 8;
-    }
-});

package/src/gossip/Messenger.ts

@@ -1,130 +0,0 @@
-import {type Address, addressAsString} from '../cluster/Address.ts';
-import {ObjectMap, ObjectSet} from '../utils/collections.ts';
-import {OutboundConnection, OutboundConnectionSettings} from '../net/OutboundConnection.ts';
-import {InboundSocket} from '../net/InboundConnection.ts';
-import {getInbound, InboundMessageHandlers} from '../net/InboundMessageHandler.ts';
-import {type Message, MessageFactory} from '../net/Message.ts';
-import {RequestCallbacks, type RequestCallback} from '../net/RequestCallbacks.ts';
-import {InboundSink} from '../net/InboundSink.ts';
-import getLogger from '../logging.ts';
-import {fromId} from '../net/Action.ts';
-
-const logger = getLogger('messaging');
-
-export interface MessageDelivery {
-    send<T>(message: Message<T>, to: Address): void
-    sendWithCallback<T, R>(message: Message<T>, to: Address, callback: RequestCallback<R>): void
-    readonly callbacks: RequestCallbacks;
-}
-
-export interface Messenger extends MessageDelivery {
-    listen(): Promise<void>
-    //
-    markExpiredCallback(address: Address): void;
-
-    closeOutbound(endpoint: Address): void;
-
-    removeInbound(from: Address): void;
-
-}
-
-class OutboundSink {
-    private readonly sink: (message: Message<unknown>, to: Address) => void;
-
-    constructor(sink: (message: Message<unknown>, to: Address) => void) {
-        this.sink = sink;
-    }
-
-    accept(message: Message<unknown>, to: Address): void {
-        this.sink(message, to);
-    }
-}
-
-export class MessagingService implements Messenger {
-    public static CURRENT_VERSION = 12;
-    public readonly callbacks: RequestCallbacks = new RequestCallbacks(this);
-    public readonly inboundSink: InboundSink;
-    public readonly outboundSink = new OutboundSink(this.doSend.bind(this));
-    private sockets: Map<Address, OutboundConnection> = new ObjectMap<Address, OutboundConnection>();
-    private handlers: Map<Address, InboundMessageHandlers> = new ObjectMap<Address, InboundMessageHandlers>();
-    private readonly inboundSocket: InboundSocket;
-    private shuttingDown: boolean;
-    private readonly messageFactory: MessageFactory;
-
-    constructor(bindAddress: Address, context: {messageFactory: () => MessageFactory}) {
-        this.inboundSink = new InboundSink({...context, messaging: () => this});
-        this.inboundSocket = new InboundSocket({bindAddress: bindAddress, handlers: this.getInbound.bind(this), handshakeTimeout: 30000, acceptVersions: {min: MessagingService.CURRENT_VERSION, max: 13}});
-        this.messageFactory = context.messageFactory();
-    }
-
-    send<T>(message: Message<T>, to: Address): void {
-        if (this.shuttingDown) {
-            logger.warn(`Messenger is shutting down, cannot send message ${message} to ${to}`);
-            return;
-        }
-
-        if (logger.enabledFor('trace')) {
-            const from = this.inboundSocket.settings.bindAddress;
-
-            logger.debug(`${addressAsString(from)} sending ${fromId(message.header.verb().id)}@${message.header.seq} to ${addressAsString(to)}`);
-            if (new ObjectSet<Address>([from]).has(to)) {
-                logger.debug(`Message is sent to self, ${message}`);
-            }
-        }
-
-        this.outboundSink.accept(message, to);
-    }
-
-    private doSend(message: Message<unknown>, to: Address) {
-        const connection = this.getOutbound(to);
-        connection.enqueue(message);
-    }
-
-    private getOutbound(to: Address): OutboundConnection {
-        let connection = this.sockets.get(to);
-        if (!connection) {
-            connection = new OutboundConnection(new OutboundConnectionSettings(this.messageFactory.from, to, this.callbacks));
-            this.sockets.set(to, connection);
-        }
-        return connection;
-    }
-
-    closeOutbound(to: Address) {
-        const connection = this.sockets.get(to);
-        if (connection !== undefined) {
-            connection.scheduleClose(5, 'minutes', true).promise.then(() => {
-                const e = this.sockets.get(to);
-                if (e === connection) {
-                    this.sockets.delete(to);
-                }
-            });
-        }
-    }
-
-    removeInbound(from: Address) {
-        const handlers = this.handlers.get(from);
-        if (handlers) {
-            this.handlers.delete(from);
-        }
-    }
-
-    /*private */getInbound(from: Address) {
-        return getInbound(from, this.handlers, this.inboundSink, this.inboundSocket.settings);
-    }
-
-    sendWithCallback<T, R>(message: Message<T>, to: Address, callback: RequestCallback<R>) {
-        this.callbacks.addWithExpiration(callback, message, to);
-        if (callback.onFailure !== undefined && !message.callbackOnFailure) {
-            message = message.withCallbackOnFailure();
-        }
-        this.send(message, to);
-    }
-
-    markExpiredCallback(address: Address) {
-
-    }
-
-    async listen() {
-        await this.inboundSocket.open()
-    }
-}

package/src/gossip/VersionedValue.ts

@@ -1,59 +0,0 @@
-import type {DataInput, DataOutput, VersionedSerializer} from '../io/VersionedSerializer.ts';
-import {encodedUtfLength} from '../io/util.ts';
-
-let version = 0;
-
-export function getNextVersion(): number {
-    return ++version;
-}
-
-export const VersionedValueDelimiter = ',';
-
-class VersionedValue {
-    public readonly version: number
-    public readonly value: string
-
-    constructor(value: string, version?: number) {
-        this.value = value;
-        this.version = version ?? getNextVersion();
-    }
-
-    public withVersion(version: number) {
-        return new VersionedValue(this.value, version);
-    }
-}
-export type {VersionedValue};
-
-class VersionedValueFactory {
-    private readonly nextVersion: () => number
-
-    constructor(version: () => number) {
-        this.nextVersion = version ?? getNextVersion;
-    }
-
-    public uuid(uuid: string): VersionedValue {
-        return new VersionedValue(uuid, this.nextVersion());
-    }
-}
-
-export const VersionedValueSerializer = new (class implements VersionedSerializer<VersionedValue> {
-    serialize(value: VersionedValue, output: DataOutput, version: number) {
-        output.writeUtf8String(this.outValue(value, version));
-        output.writeInt32(value.version);
-    }
-
-    deserialize(input: DataInput, version: number): VersionedValue {
-        const value  = input.readUtf8String();
-        const valueVersion = input.readInt32();
-        return new VersionedValue(value, valueVersion);
-    }
-
-    serializedSize(value: VersionedValue, version: number): number {
-        return 2 + encodedUtfLength(this.outValue(value, version)) + 4;
-    }
-
-
-    outValue(value: VersionedValue, version: number): string {
-        return value.value;
-    }
-});

package/src/index.ts

@@ -1,3 +0,0 @@
-
-export {Config} from './config/Config.ts';
-export {BridgeNode} from './instance/BridgeNode.ts';

package/src/instance/AddressPicker.ts

@@ -1,245 +0,0 @@
-import {type Address} from '../cluster/Address.ts';
-import {getByName, getNetworkInterfaces, type IpAddress} from '../utils/network.ts';
-import { type AddressInfo, Server, createServer} from 'node:net';
-import { type Logger } from '../logging.ts';
-import { type Config} from '../config/Config.ts';
-
-export interface AddressPicker {
-    pickAddress(): Promise<void>;
-    getPublicAddressFor(endpoint: 'member' | 'client'): Address ;
-    getServers(): ReadonlyMap<string, Server>;
-}
-
-async function createAddress(addressDef:AddressDef, port: number): Promise<Address> {
-    if (addressDef.host) {
-        return {type: addressDef.ipAddress.family, host: addressDef.host, port};
-    }
-    return {type: addressDef.ipAddress.family, host: await addressDef.ipAddress.getHost(), port}
-}
-
-function createNetServer(logger: Logger, host: string, range: number | string): Promise<Server> {
-    const ports = portRange(range);
-    return new Promise((resolve, reject) => {
-        let server = createServer({}, () => {});
-        server.on('error', (err: Error) => {
-            if (err['code'] === 'EADDRINUSE') {
-                logger.debug(`port ${err['port']} already in use on address ${err['address']}`);
-                const {value: port} = ports.next();
-                if (port) {
-                    logger.info(`retry starting server on port ${port} and host ${host ?? '<unspecified>'}`);
-                    server.close();
-                    server.listen(port, host);
-                } else {
-                    logger.warn(`all configured port(s) ${range} are in use. closing...`);
-                    server.close();
-                    reject(err);
-                }
-            } else {
-                logger.error(`server error: ${err.message}`, err);
-                reject(err);
-            }
-        });
-        server.on('listening', () => {
-            const info = server.address() as AddressInfo;
-            logger.info(`listening on ${info.address}:${info.port}`);
-            resolve(server);
-        });
-        try {
-            const {value: port} = ports.next();
-            server.listen(port, host);
-        } catch (e) {
-            logger.error(`error starting socket server`, e);
-            reject(e instanceof Error ? e : new Error(`listen failed: ${e}`));
-        }
-    });
-}
-
-class InterfaceAddress {
-    readonly address: string;
-    readonly host?: string;
-    constructor(address: string, host?: string) {
-        this.address = address;
-        this.host = host;
-    }
-}
-
-class AddressDef extends InterfaceAddress {
-
-    readonly ipAddress: IpAddress;
-    readonly port: number;
-    constructor(ipAddress: IpAddress, host?: string, port?: number) {
-        super(ipAddress.address, host);
-        this.ipAddress = ipAddress;
-        this.port = port ?? 0;
-    }
-}
-
-export class DefaultAddressPicker implements AddressPicker {
-
-    private readonly logger: Logger;
-    private readonly config: Config;
-    private readonly publicAddressConfig?: string;
-    private publicAddress: Address;
-    private bindAddress: Address;
-    private server: Server;
-    private readonly port: string | number;
-    constructor(config: Config,
-                logger: Logger)
-    {
-        this.logger = logger;
-        this.config = config;
-        this.port = config.network.port;
-        this.publicAddressConfig = config.network.publicAddress;
-    }
-
-    async pickAddress(): Promise<void> {
-        if (this.publicAddress || this.bindAddress)
-        {
-            return;
-        }
-        const publicAddressDef = await this.getPublicAddressByPortSearch();
-        this.publicAddress = this.bindAddress;
-
-    }
-
-    getPublicAddressFor(endpoint: 'member' | 'client'): Address {
-        return this.publicAddress;
-    }
-
-    getServers(): ReadonlyMap<string, Server> {
-        return new Map([['member', this.server]]);
-    }
-
-    private async getPublicAddressByPortSearch() {
-        const bindAddressDef = await this.pickAddressDef();
-
-
-        this.server = await createNetServer(this.logger, '0.0.0.0', bindAddressDef.port === 0 ? this.port: bindAddressDef.port);
-
-        const port = (this.server.address() as AddressInfo).port;
-        this.bindAddress = await createAddress(bindAddressDef, port);
-
-        return this.getPublicAddress(port);
-    }
-
-    private async getPublicAddress(port: number) {
-        let address = this.publicAddressConfig;
-        if (address) {
-            address = address.trim();
-            if (!address) {
-                throw new Error('Public address is empty');
-            } else if ('127.0.0.1' === address) {
-                return this.pickLoopbackAddressDef(address, port);
-            }
-            else
-            {
-                const ipAddress = await getByName(address);
-                return new AddressDef(ipAddress, address, port);
-            }
-        }
-    }
-
-    private async pickAddressDef() {
-        let addressDef = this.pickInterfaceAddressDef();
-        if (addressDef) {
-
-        }
-        if (!addressDef) {
-            addressDef = await this.pickLoopbackAddressDef();
-        }
-        return addressDef;
-    }
-
-    private pickInterfaceAddressDef(): AddressDef {
-        const interfaces =  this.getInterfaces();
-        if (interfaces) {
-            const address = this.pickMatchingAddress(interfaces);
-            if (address) {
-                return address;
-            }
-        }
-        return this.pickMatchingAddress();
-    }
-
-    private getInterfaces(): InterfaceAddress[] | undefined {
-        return [];
-    }
-
-    private async pickLoopbackAddressDef(host?: string, defaultPort?: number) {
-        const address = await getByName('127.0.0.1');
-        return new AddressDef(address, host, defaultPort);
-    }
-
-    private match(ipAddress: IpAddress, interfaces: InterfaceAddress[]) {
-        for (const iface of interfaces) {
-            if (ipAddress.address === iface.address) {
-                return iface;
-            }
-        }
-        return undefined;
-    }
-
-    private getMatchingAddress(ipAddress: IpAddress, interfaces?: InterfaceAddress[]) {
-        if (interfaces) {
-            return this.match(ipAddress, interfaces);
-        } else {
-            return ipAddress;
-        }
-    }
-
-    private pickMatchingAddress(interfaces?: InterfaceAddress[]): AddressDef | undefined {
-        const preferIPv4 = true;
-        const networkInterfaces = getNetworkInterfaces();
-        let matchingAddress;
-        for (const ni of networkInterfaces) {
-            if (!interfaces && ni.loopback) {
-                continue;
-            }
-            for (const ipAddress of ni.addresses) {
-                if (preferIPv4 && ipAddress.family === 6) {
-                    continue;
-                }
-                const address = this.getMatchingAddress(ipAddress, interfaces);
-                break;
-            }
-        }
-        return matchingAddress;
-    }
-}
-
-
-
-// stolen from gateway-server
-
-
-const PORT_RANGE_MATCHER = /^(\d+|(0x[\da-f]+))(-(\d+|(0x[\da-f]+)))?$/i;
-function validPort(port: number) {
-    if (port > 0xFFFF) throw new Error(`bad port ${port}`);
-    return port;
-}
-
-/**
- * parse port range. port can be number or string representing comma separated
- *   list of port ranges for e.g. "3434,8380-8385"
- * @param port
- */
-function* portRange(port: number | string): Generator<number> {
-    if (typeof port === 'string') {
-        for (const portRange of port.split(',')) {
-            const trimmed = portRange.trim();
-            const matchResult = PORT_RANGE_MATCHER.exec(trimmed);
-            if (matchResult) {
-                const start = parseInt(matchResult[1]);
-                const end = parseInt(matchResult[4] ?? matchResult[1]);
-                for (let i = validPort(start); i < validPort(end) + 1; i++) {
-                    yield i;
-                }
-            }
-            else {
-                throw new Error(`'${portRange}' is not a valid port or range.`);
-            }
-        }
-    } else {
-        yield validPort(port);
-    }
-}

package/src/instance/BridgeNode.ts

@@ -1,141 +0,0 @@
-import {newUUID} from '../utils/uuid.ts';
-import {DefaultDiscoveryServiceFactory, type DiscoveryService, type DiscoveryServiceSettings} from '../discovery/index.ts';
-import {SimpleDiscoveryNode} from '../discovery/SimpleDiscoveryNode.ts';
-import {type Member} from '../cluster/Member.ts';
-import {type MemberVersion, parseVersion} from '../version/MemberVersion.ts';
-import {type DiscoveryConfig} from '../config/DiscoveryConfig.ts';
-import {VERSION} from '../../gen/instance/GeneratedBuildInfo.ts';
-import {type AddressPicker, DefaultAddressPicker} from './AddressPicker.ts';
-import getLogger, {type Logger} from '../logging.ts';
-import gatewayServer, {GatewayServer} from '@interopio/gateway-server';
-import {Config} from '../config/Config.ts';
-import {BridgeLicenseValidator} from "../license/BridgeLicenseValidator.ts";
-import { type LicenseValidator} from "../license/LicenseValidator.ts";
-
-
-function createDiscoveryService(logger: Logger,
-                                conf: DiscoveryConfig,
-                                isAutoDetectionEnabled: boolean,
-                                localMember: Promise<Member>): DiscoveryService {
-    const factory = new DefaultDiscoveryServiceFactory();
-
-    const node = localMember.then(member => new SimpleDiscoveryNode(member.address)) ;
-
-    const settings: DiscoveryServiceSettings = {
-        mode: 'member',
-        node: node,
-        conf: conf,
-        auto: isAutoDetectionEnabled,
-        logger: logger,
-    };
-    return factory.newDiscoveryService(settings);
-}
-
-function createAddressPicker(node: BridgeNode): AddressPicker {
-    const config = node.config;
-    const logger = node.getLogger('address-picker');
-    return new DefaultAddressPicker(config, logger);
-}
-
-export class BridgeNode {
-    readonly config: Config;
-    private readonly uuid: string;
-    private readonly discoveryService: DiscoveryService;
-    private readonly version: MemberVersion;
-    private server?: GatewayServer.Server;
-    private readonly licenseValidator: LicenseValidator;
-
-    constructor(config: Config) {
-        this.config = config;
-
-        this.licenseValidator = BridgeLicenseValidator(this.getLogger('license-validator'));
-        this.licenseValidator.validate(config.license);
-
-        this.uuid = newUUID();
-        this.version = parseVersion(VERSION);
-        const addressPicker = createAddressPicker(this);
-
-
-        const localMemberPromise: Promise<Member> = addressPicker.pickAddress()
-            .then(() => addressPicker.getPublicAddressFor('member'))
-            .then((publicAddress) => {
-                return {
-                    local: true,
-                    address: publicAddress,
-                    uuid: this.uuid,
-                    version: this.version,
-                };
-            });
-
-        const joinConfig = config.network.join;
-
-        const isAutoDetectionEnabled = joinConfig.autoDetectionEnabled;
-
-        const discoveryConfig: DiscoveryConfig = joinConfig.discovery;
-
-        this.discoveryService = createDiscoveryService(getLogger("discovery-service"), discoveryConfig, isAutoDetectionEnabled, localMemberPromise);
-    }
-
-    getLogger(name: string) {
-        return getLogger(name);
-    }
-
-    private async scheduleLicenseCheck() {
-        const task = async () => {
-            try {
-                this.licenseValidator.validate(this.config.license, {
-                    logSuccessMessages: false,
-                });
-            }
-            catch (error) {
-                // this.logger.error(error);
-                await this.stop();
-            }
-        };
-
-        const licenseCheckInterval = 1000 * 60 * 60 * 24; // 1 day
-        return setInterval(task, licenseCheckInterval);
-    }
-
-    async start() {
-        const config: GatewayServer.ServerConfig =  {
-            port: this.config.server.port,
-            host: this.config.server.host,
-            mesh: this.config.server.mesh,
-        };
-        if (this.config.server.gateway.enabled) {
-            config.gateway = {
-                clients: {
-                    inactive_seconds: 0,
-                },
-                contexts: {
-                    lifetime: this.config.server.gateway.contexts.lifetime,
-                    visibility: [{restrictions: 'cluster'}]
-                },
-                peers: {
-                    visibility: [{
-                        domain: 'interop',
-                        restrictions: 'local'
-                    }]
-                }
-            }
-        }
-        this.server = await gatewayServer(config);
-        if (false) {
-            await this.discoveryService.start();
-        }
-        await this.scheduleLicenseCheck();
-    }
-
-    async stop() {
-        if (this.server)
-        {
-            await this.server.close()
-        }
-        try {
-            await this.discoveryService.close();
-        } catch (e) {
-            // ignore
-        }
-    }
-}

package/src/instance/ClusterTopologyIntentTracker.ts

@@ -1,4 +0,0 @@
-export interface ClusterTopologyIntentTracker {
-    init(): void;
-    destroy(): void;
-}