@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/config/Config.ts

@@ -1,100 +0,0 @@
-import {type Properties, type PropertyType} from './Properties.ts';
-import {KubernetesConfig} from './KubernetesConfig.ts';
-import {
-    DefaultDiscoveryConfig,
-    type DiscoveryConfig
-} from './DiscoveryConfig.ts';
-
-export class AutoDetectionConfig {
-    enabled: boolean = true;
-}
-
-export interface MulticastConfig {
-    readonly group: string
-    readonly port: number
-}
-class DefaultMulticastConfig implements MulticastConfig {
-    enabled: boolean = false;
-    group: string = '239.1.2.3';
-    port: number = 34567;
-}
-export interface TcpIpConfig {
-    members: string[]
-}
-class DefaultTcpIpConfig implements TcpIpConfig {
-    enabled: boolean = false;
-    members: string[] = [];
-}
-export class JoinConfig {
-    private _multicast= new DefaultMulticastConfig();
-    private _tcpIp = new DefaultTcpIpConfig();
-    private _kubernetes = new KubernetesConfig();
-    private _discovery = new DefaultDiscoveryConfig();
-    private _autoDetection = new AutoDetectionConfig();
-
-    get discovery(): DiscoveryConfig {
-        return this._discovery;
-    }
-
-    get multicast(): MulticastConfig {
-        return this._multicast;
-    }
-
-    get autoDetectionEnabled(): boolean {
-        return this._autoDetection.enabled
-            && !this._multicast.enabled
-            && !this._tcpIp.enabled
-            && !this._kubernetes.enabled
-            && !this._discovery.enabled;
-    }
-}
-
-export class NetworkConfig {
-    public static readonly DEFAULT_PORT: number = 8383;
-    port: number = NetworkConfig.DEFAULT_PORT;
-    reuseAddress: boolean;
-    publicAddress?: string;
-    join = new JoinConfig();
-
-    constructor() {
-        this.reuseAddress = process.platform !== "win32";
-    }
-}
-
-export class ServerConfig {
-    port?: number = undefined;
-    host?: string = undefined;
-    mesh: {
-        ping?: number
-    } = {};
-    gateway: {
-        enabled?: boolean,
-        contexts: {
-            lifetime: 'retained' | 'ref-counted' | 'ownership'
-        }
-    } = {
-        contexts: {
-            lifetime: 'retained'
-        }
-    }
-}
-
-export class Config {
-    properties: Properties = {};
-    network = new NetworkConfig();
-    license: string
-    readonly server: ServerConfig;
-    constructor() {
-        this.server = new ServerConfig();
-    }
-
-    get<T extends PropertyType>(name: string): T {
-        const value = this.properties[name] as T;
-        return value;
-    }
-
-    set<T extends PropertyType>(name: string, value: T): Config {
-        this.properties[name] = value;
-        return this;
-    }
-}

package/src/config/DiscoveryConfig.ts

@@ -1,21 +0,0 @@
-import type {DiscoveryServiceFactory, DiscoveryStrategyFactory} from '../discovery/index.ts';
-import type {Properties} from './Properties.ts';
-
-export interface DiscoveryStrategyConfig {
-    readonly discoveryStrategyFactory?: DiscoveryStrategyFactory
-    readonly properties: Properties
-}
-export interface DiscoveryConfig {
-    readonly discoveryStrategyConfigs: ReadonlyArray<DiscoveryStrategyConfig>
-    readonly discoveryServiceFactory?: DiscoveryServiceFactory
-}
-
-export class DefaultDiscoveryConfig implements DiscoveryConfig
-{
-    discoveryStrategyConfigs: DiscoveryStrategyConfig[] = [];
-    discoveryServiceFactory?: DiscoveryServiceFactory;
-
-    get enabled() {
-        return this.discoveryStrategyConfigs.length > 0;
-    }
-}

package/src/config/Duration.ts

@@ -1,168 +0,0 @@
-const UNITS_PATTERN = /^(\d+)(d|h|m|s|ms|us|µs|ns)$/;
-
-export type Unit = keyof typeof SCALES;
-
-export function unitForSymbol(symbol: string): Unit {
-    switch (symbol.toLowerCase()) {
-        case 'ns':
-            return 'nanoseconds';
-        case 'us':
-        case 'µs':
-            return 'microseconds';
-        case 'ms':
-            return 'milliseconds';
-        case 's':
-            return 'seconds';
-        case 'm':
-            return 'minutes';
-        case 'h':
-            return 'hours';
-        case 'd':
-            return 'days';
-    }
-    throw new Error(`Unsupported unit symbol: ${symbol}`);
-}
-
-export function symbolForUnit(unit: Unit): string {
-    switch (unit) {
-        case 'days': return 'd';
-        case 'hours': return 'h';
-        case 'minutes': return 'm';
-        case 'seconds': return 's';
-        case 'milliseconds': return 'ms';
-        case 'microseconds': return 'us';
-        case 'nanoseconds': return 'ns';
-    }
-}
-
-const SCALES: { [key :string ]: bigint } = {
-    nanoseconds: 1n,
-    microseconds: 1000n,
-    milliseconds: 1000000n,
-    seconds: 1000000000n,
-    minutes: 60n * 1000000000n,
-    hours: 60n * 60n * 1000000000n,
-    days: 24n * 60n * 60n * 1000000000n,
-}
-
-function toNanos(unit: Unit, duration: number | bigint) {
-    const scale = SCALES[unit];
-    const ns = BigInt(duration) * scale;
-    return ns;
-}
-
-function toMicros(unit: Unit, duration: number | bigint): bigint {
-    const scale = SCALES[unit];
-    let microScale = SCALES.microseconds;
-    if (scale <= microScale) {
-        return scale === microScale ? BigInt(duration) : BigInt(duration) / (microScale / scale);
-    }
-    else {
-        return BigInt(duration) * (scale / microScale);
-    }
-}
-
-function toMillis(unit: Unit, duration: number | bigint) : bigint {
-    const scale = SCALES[unit];
-    let milliScale = SCALES.milliseconds;
-    if (scale <= milliScale) {
-        return scale === milliScale ? BigInt(duration) : BigInt(duration) / (milliScale / scale);
-    }
-    else {
-        return BigInt(duration) * (scale / milliScale);
-    }
-}
-
-function toSeconds(unit: Unit, duration: number | bigint): bigint {
-    const scale = SCALES[unit];
-    const secondScale = SCALES.seconds;
-    if (scale <= secondScale) {
-        return scale === secondScale ? BigInt(duration) : BigInt(duration) / (secondScale / scale);
-    }
-    else {
-        return BigInt(duration) * (scale / secondScale);
-    }
-}
-
-export function convert(targetUnit: Unit, quantity: number | bigint, sourceUnit: Unit): bigint {
-    switch (targetUnit) {
-        case 'nanoseconds': return toNanos(sourceUnit, quantity);
-        case 'microseconds': return toMicros(sourceUnit, quantity);
-        case 'milliseconds': return toMillis(sourceUnit, quantity);
-        case 'seconds': return toSeconds(sourceUnit, quantity);
-        default: throw new Error('not implemented');
-    }
-}
-
-abstract class Duration {
-    readonly unit: Unit;
-    readonly quantity: number;
-
-    /*protected*/ constructor(value: string, minUnit: Unit, max?: number) {
-        const match = UNITS_PATTERN.exec(value);
-        if (!match) {
-            throw new Error(`Invalid duration: ${value}`);
-        }
-        this.quantity = parseInt(match[1]);
-        this.unit = unitForSymbol(match[2]);
-        if (max) {
-            if (SCALES[this.unit] < SCALES[minUnit]) {
-                throw new Error(`Duration must be at least ${minUnit}`);
-            }
-            if (convert(minUnit, this.quantity, this.unit) > max) {
-                throw new Error(`Invalid Duration: ${value}. Must be at most ${max - 1} in ${minUnit}`);
-            }
-        }
-    }
-}
-
-export class NanosecondsDuration extends Duration {
-    constructor(value: string) {
-        super(value, 'nanoseconds', Number.MAX_SAFE_INTEGER);
-    }
-
-    toNanoseconds() {
-        return toNanos(this.unit, this.quantity);
-    }
-}
-export class MicrosecondsDuration extends Duration {
-    constructor(value: string) {
-        super(value, 'microseconds', Number.MAX_SAFE_INTEGER);
-    }
-
-    toMicroseconds() {
-        return convert('microseconds', this.quantity, this.unit);
-    }
-
-    toSeconds() {
-        return convert('seconds', this.quantity, this.unit);
-    }
-}
-
-export class MillisecondsDuration extends Duration {
-    constructor(value: string) {
-        super(value, 'milliseconds', Number.MAX_SAFE_INTEGER);
-    }
-
-    toMilliseconds() {
-        return convert('milliseconds', this.quantity, this.unit);
-    }
-}
-
-export class SecondsDuration extends Duration {
-    constructor(value: string) {
-        super(value, 'seconds', Number.MAX_SAFE_INTEGER);
-    }
-
-    toMilliseconds() {
-        return toMillis(this.unit, this.quantity);
-    }
-
-    toNanoSeconds() {
-        return toNanos(this.unit, this.quantity);
-    }
-
-    toSeconds() {
-        return toSeconds(this.unit, this.quantity);
-    }
-}

package/src/config/KubernetesConfig.ts

@@ -1,7 +0,0 @@
-import { NamedDiscoveryConfig } from './NamedDiscoveryConfig.ts';
-
-export class KubernetesConfig extends NamedDiscoveryConfig<KubernetesConfig> {
-    constructor() {
-        super("kubernetes");
-    }
-}

package/src/config/NamedDiscoveryConfig.ts

@@ -1,17 +0,0 @@
-export abstract class NamedDiscoveryConfig<T extends NamedDiscoveryConfig<T>>  {
-    readonly tag;
-    private _enabled: boolean = false;
-
-    constructor(tag: string) {
-        this.tag = tag;
-    }
-
-    setEnabled(enabled: boolean): T {
-        this._enabled = enabled;
-        return this as unknown as T;
-    }
-
-    get enabled(): boolean {
-        return this._enabled;
-    }
-}

package/src/config/Properties.ts

@@ -1,49 +0,0 @@
-export interface PropertyDefinition {
-    readonly key: string
-    readonly optional: boolean
-    readonly converter: PropertyTypeConverter<PropertyType>
-}
-
-export type PropertyType = string | number | boolean;
-export type Properties = { [key: string]: PropertyType };
-
-export interface PropertyTypeConverter<T extends PropertyType> {
-    convert(value: unknown): T
-}
-
-export const BOOLEAN = new class implements PropertyTypeConverter<boolean> {
-    convert(value: unknown): boolean {
-        if (typeof value === 'boolean') {
-            return value;
-        }
-        else if (typeof value === "string") {
-            return value.toLowerCase() === "true";
-        }
-        throw new Error("Cannot convert value to boolean: " + value);
-    }
-};
-
-export const STRING = new class implements PropertyTypeConverter<string> {
-    convert(value: unknown): string {
-        if (value === undefined) {
-            throw new Error("Cannot convert undefined ");
-        }
-        return String(value);
-    }
-}
-
-export const NUMBER = new class implements PropertyTypeConverter<number> {
-    convert(value: unknown): number {
-        if (value === undefined) {
-            throw new Error("Cannot convert undefined ");
-        }
-        if (typeof value === "object") {
-            throw new Error("Cannot convert object/array to number: " + value);
-        }
-        return Number(value);
-    }
-}
-
-export function property<T extends PropertyType>(name: string, converter: PropertyTypeConverter<T>): PropertyDefinition {
-    return {key: name, optional: true, converter: converter};
-}

package/src/config/index.ts

@@ -1 +0,0 @@
-

package/src/discovery/SimpleDiscoveryNode.ts

@@ -1,14 +0,0 @@
-import {type DiscoveryNode} from './index.ts';
-import {type Address} from '../cluster/Address.ts';
-
-export class SimpleDiscoveryNode implements DiscoveryNode {
-    readonly privateAddress: Address;
-    readonly publicAddress: Address;
-    readonly properties: ReadonlyMap<string, unknown>;
-    constructor(privateAddress: Address, publicAddress?: Address, properties?: ReadonlyMap<string, unknown>)
-    {
-        this.privateAddress = privateAddress;
-        this.publicAddress = publicAddress ?? privateAddress;
-        this.properties = properties ?? new Map();
-    }
-}

package/src/discovery/index.ts

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