@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/license/LicenseValidator.ts

@@ -1,114 +0,0 @@
-import getLogger, {type Logger} from "../logging.ts";
-import {
-    type LicensePayload,
-    type LicenseEvaluationResult,
-    type LicenseValidatorOptions,
-    licenseValidationResults, type LicenseValidationOptions
-} from "./types.ts";
-import {KJUR} from 'jsrsasign';
-
-export class LicenseError extends Error {
-    public readonly licensePayload: LicensePayload | string;
-
-    constructor(message: string, licensePayload: string | LicensePayload) {
-        super(message);
-        this.licensePayload = licensePayload;
-    }
-}
-
-export class LicenseEvaluator {
-    private readonly tokenResultMap = {
-        'trial-false': licenseValidationResults.TRIAL_LICENSE_VALID,
-        'trial-true': licenseValidationResults.TRIAL_LICENSE_EXPIRED,
-        'paid-false': licenseValidationResults.PAID_LICENSE_VALID,
-        'paid-true': licenseValidationResults.PAID_LICENSE_EXPIRED,
-    };
-
-    private readonly validationKey: string;
-
-    constructor(validationKey: string) {
-        if (!validationKey || typeof validationKey !== 'string') {
-            throw new Error(`Validation key must be a non-empty string`);
-        }
-        this.validationKey = validationKey;
-    }
-
-    private decrypt(token: string): object {
-        if (KJUR.jws.JWS.verifyJWT(token, this.validationKey, {alg: ['RS256']})) {
-            return KJUR.jws.JWS.parse(token).payloadObj;
-        } else {
-            throw new LicenseError('invalid jwt token', token);
-        }
-    }
-
-    private validateBasicTokenData(token: string): LicensePayload {
-        const decoded = this.decrypt(token) as LicensePayload;
-        if (['paid', 'trial'].indexOf(decoded.type) === -1) {
-            throw new LicenseError('Invalid license type', token);
-        }
-        return decoded;
-    }
-
-    getLicenseStatus(token: string, now: Date = new Date()): LicenseEvaluationResult {
-        try {
-            const license = this.validateBasicTokenData(token);
-            const isExpired = license.expiration < now.getTime();
-            const licenseValidationResult = this.tokenResultMap[`${license.type}-${isExpired}`];
-            return {
-                ...licenseValidationResult,
-                license
-            };
-        } catch (e) {
-            return {
-                ...licenseValidationResults.NO_LICENSE,
-                error: e.message,
-            };
-        }
-
-    }
-}
-
-export class LicenseValidator {
-    private readonly licenseHelper: LicenseEvaluator;
-    private readonly logger: Logger;
-
-    constructor({validationKey, logger}: LicenseValidatorOptions) {
-        this.licenseHelper = new LicenseEvaluator(validationKey);
-        this.logger = logger ?? getLogger("LicenseValidator"); // Default to console if no logger provided
-    }
-
-    public validate(licenseKeyString: string, options?: LicenseValidationOptions): void {
-        if (typeof licenseKeyString !== 'string') {
-            throw new LicenseError('Invalid license key format', licenseKeyString);
-        }
-
-        const licenseStatus = this.licenseHelper.getLicenseStatus(licenseKeyString);
-        this.printLicenseMessage(licenseStatus, options?.logSuccessMessages ?? true);
-        if (licenseStatus.fatal) {
-            throw new LicenseError('License validation failed', licenseStatus.license);
-        }
-    }
-
-    private printLicenseMessage(licenseStatus: LicenseEvaluationResult, logSuccessMessages: boolean): void {
-        if (!licenseStatus || licenseStatus.licenseType === 'none') {
-            this.logger.error('This license is invalid. Please contact us at sales@interop.io to get a valid license');
-            return;
-        }
-
-        const message = [
-            licenseStatus.licenseType === 'paid' ? `This is a paid license that was issued for client ` : `This is a trial license that was issued for `,
-            licenseStatus.license.organization.displayName,
-            licenseStatus.expired ? `, but it has expired at ` : ` and is valid until `,
-            new Date(licenseStatus.license.expiration).toString(),
-            '.'
-        ].join('');
-
-        if (licenseStatus.fatal) {
-            this.logger.error(message);
-        } else if (licenseStatus.expired) {
-            this.logger.warn(message);
-        } else if(logSuccessMessages) {
-            this.logger.info(message);
-        }
-    }
-}

package/src/license/types.ts

@@ -1,40 +0,0 @@
-import type {Logger} from "../logging.ts";
-
-export type LicenseValidatorOptions = {
-    validationKey: string;
-    logger?: Logger
-}
-
-export type LicenseValidationOptions = {
-    logSuccessMessages?: boolean
-};
-
-export type LicensePayload = {
-    "type": "paid" | "trial";
-    "expiration": number // in milliseconds
-    "email": string,
-    "issuedBy": string;
-    "iat": number; // in seconds
-    "licensee": string;
-    "organization": {
-        "displayName": string,
-        "identifier": string
-    }
-}
-
-export type LicenseEvaluationResult = {
-    licenseType: 'paid' | 'trial' | 'none';
-    expired: boolean;
-    fatal: boolean;
-    license?: LicensePayload;
-    error?: string;
-}
-
-
-export const licenseValidationResults = {
-    TRIAL_LICENSE_EXPIRED: {licenseType: 'trial', expired: true, fatal: true} as LicenseEvaluationResult,
-    TRIAL_LICENSE_VALID: {licenseType: 'trial', expired: false, fatal: false} as LicenseEvaluationResult,
-    PAID_LICENSE_EXPIRED: {licenseType: 'paid', expired: true, fatal: false} as LicenseEvaluationResult,
-    PAID_LICENSE_VALID: {licenseType: 'paid', expired: false, fatal: false} as LicenseEvaluationResult,
-    NO_LICENSE: {licenseType: 'none', expired: false, fatal: true} as LicenseEvaluationResult,
-};

package/src/logging.ts

@@ -1,22 +0,0 @@
-import {IOGateway} from '@interopio/gateway';
-
-export type Logger = ReturnType<typeof IOGateway.Logging.getLogger>;
-IOGateway.Logging.getLogger(`gateway.server.app`); // ensure the logger is created
-IOGateway.Logging.getLogger(`gateway.bridge`); // ensure the logger is created
-IOGateway.Logging.getLogger(`gateway.bridge.gossiper`); // ensure the logger is created
-IOGateway.Logging.getLogger(`gateway.bridge.net.callbacks`); // ensure the logger is created
-IOGateway.Logging.configure({
-    level: {
-        "gateway": 'info',
-        "gateway.server": 'trace',
-        "gateway.server.app": 'info',
-        "gateway.bridge": 'trace',
-        "gateway.bridge.gossiper": 'info',
-        // "gateway.bridge.net.callbacks": 'debug'
-        "gateway.bridge.net.internal.channel": 'debug'
-    }
-});
-
-export default function getLogger(name: string): Logger {
-    return IOGateway.Logging.getLogger(`gateway.bridge.${name}`);
-}

package/src/main.mts

@@ -1,53 +0,0 @@
-import {BridgeNode} from './instance/BridgeNode.ts';
-import {Config} from './config/Config.ts';
-import {BOOLEAN, NUMBER, type PropertyType, type PropertyTypeConverter, STRING} from './config/Properties.ts';
-
-import info from '@interopio/bridge/package.json' with {type: 'json'};
-
-let hadFatalError = false;
-const reportedErrors = new Set();
-function onFatalError(error) {
-
-    process.exitCode = 2;
-    hadFatalError = true;
-
-    const errorMessage = `io.Bridge: ${info.version}`
-
-    if (!reportedErrors.has(errorMessage)) {
-        console.error(error);
-        reportedErrors.add(errorMessage);
-    }
-}
-
-function loadConfig<T extends PropertyType=string>(name: string, converter: PropertyTypeConverter<T>): T | undefined {
-    const cmdArg = process.argv.find(arg => {return arg.startsWith(`--${name}=`);})?.split('=')[1];
-    if (cmdArg) {
-        return converter.convert(cmdArg);
-    }
-    const envKey = `IO_BRIDGE_${name.toUpperCase().replace('-', '_').replace('.', '_')}`;
-    const envVar = process.env[envKey];
-    if (envVar) {
-        return converter.convert(envVar);
-    }
-}
-
-try {
-    process.on('uncaughtException', onFatalError);
-    process.on('unhandledRejection', onFatalError);
-
-    await import('dotenv/config');
-    const config = new Config();
-    config.license ??= loadConfig('license-key', STRING);
-    config.server.port ??= loadConfig('server.port', NUMBER) ?? 8383;
-    config.server.host ??= loadConfig('server.host', STRING);
-    config.server.mesh.ping ??= loadConfig('mesh.ping-interval', NUMBER);
-    config.server.gateway.enabled ??= loadConfig('gateway.enabled', BOOLEAN);
-    config.server.gateway.contexts.lifetime ??= loadConfig('gateway.contexts.lifetime', STRING) as 'retained' | 'ref-counted' | 'ownership';
-    const bridge = new BridgeNode(config);
-
-    await bridge.start();
-
-}
-catch (error) {
-    onFatalError(error);
-}

package/src/net/Action.ts

@@ -1,143 +0,0 @@
-import {type Message, type MessageFactory} from './Message.ts';
-import type {DataInput, DataOutput, VersionedSerializer} from '../io/VersionedSerializer.ts';
-import {convert, type Unit} from '../config/Duration.ts';
-import {
-    type Gossiper,
-    type GossipDigestSyn,
-    type GossipDigestAck,
-    type GossipDigestAck2,
-    gossipDigestSynHandler,
-    gossipDigestAckHandler,
-    gossipDigestAck2Handler,
-    echoHandler,
-    GossipDigestSynSerializer,
-    GossipDigestAckSerializer,
-    GossipDigestAck2Serializer
-} from '../gossip/Gossiper.ts';
-import {type RequestFailureReason, RequestFailureReasonSerializer} from '../error/RequestFailure.ts';
-import type {MessageDelivery} from '../gossip/Messenger.ts';
-import {responseHandler} from './ResponseHandler.ts';
-import {maxn} from '../utils/bigint.ts';
-
-const timeouts: {[keys: string]: (unit: Unit) => bigint} = {
-    rpcTimeout: (unit: Unit) => convert(unit, 10, 'seconds'),
-    writeTimeout: (unit: Unit) => convert(unit, 2, 'seconds'),
-    longTimeout: (unit: Unit) => maxn(timeouts.rpcTimeout(unit), convert(unit, 5, 'minutes')),
-    noTimeout: (unit: Unit) => { throw new Error(''); }
-}
-
-export interface VerbHandler<T> {
-    doVerb(message: Message<T>) : void
-}
-
-export type VerbHandlerContext = {
-    messageFactory: () => MessageFactory;
-    messaging: () => MessageDelivery
-    gossiper: () => Gossiper
-}
-
-export interface Verb<T> {
-    readonly id: number
-    readonly expirationNs: () => bigint
-    readonly serializer: VersionedSerializer<T>
-    handler(context: VerbHandlerContext): VerbHandler<T>
-    expiresAt(createdAt: bigint): bigint
-
-    responseVerb?: Verb<unknown>
-}
-
-
-class NetVerb<T> implements Verb<T> {
-    readonly id: number;
-    readonly expiration: (unit: Unit) => bigint;
-    private readonly _serializer: () => VersionedSerializer<T>;
-    private readonly _handler: (context: VerbHandlerContext) => VerbHandler<T>;
-    private readonly _responseVerb?: () => Verb<unknown>;
-
-    constructor(id: number,
-                expiration: (unit: Unit) => bigint,
-                serializer: () => VersionedSerializer<T>,
-                handler: (context: VerbHandlerContext) => VerbHandler<T>,
-                responseVerb?: () => Verb<unknown>) {
-        this.id = id;
-        this.expiration = expiration;
-        this._serializer = serializer;
-        this._handler = handler;
-        this._responseVerb = responseVerb;
-    }
-
-    get serializer(): VersionedSerializer<T> {
-        return this._serializer();
-    }
-
-    handler(context: VerbHandlerContext): VerbHandler<T> {
-        return this._handler(context);
-    }
-
-    expiresAt(nowNs: bigint): bigint {
-        return nowNs + this.expiration('nanoseconds');
-    }
-
-    expirationNs(): bigint {
-        return this.expiration('nanoseconds');
-    }
-
-    get responseVerb(): Verb<unknown> | undefined {
-        return this._responseVerb ? this._responseVerb() : undefined;
-    }
-
-    /* testing */ unsafeSetHandler(handler: (context: VerbHandlerContext) => VerbHandler<T>) {
-        const original = this._handler;
-        (this as any)._handler = handler;
-        return original;
-    }
-}
-
-export class NoPayload {
-    static readonly instance = new NoPayload();
-    toString() {
-        return '<NoPayload>';
-    }
-}
-export const NoPayloadSerializer: VersionedSerializer<NoPayload> = new (class implements VersionedSerializer<NoPayload> {
-    serialize(value: NoPayload, output: DataOutput, version?: number) {
-        if (value !== NoPayload.instance) {
-            throw new Error('NoPayload can only be serialized as NoPayload.instance');
-        }
-    }
-
-    deserialize(input: DataInput, version?: number): NoPayload {
-        return NoPayload.instance;
-    }
-
-    serializedSize(value: NoPayload, version?: number): number {
-       return 0;
-   }
-});
-
-export const Verbs = {
-    GOSSIP_DIGEST_SYN: new NetVerb<GossipDigestSyn>(14, timeouts.longTimeout, () => GossipDigestSynSerializer, gossipDigestSynHandler),
-    GOSSIP_DIGEST_ACK: new NetVerb<GossipDigestAck>(15, timeouts.longTimeout, () => GossipDigestAckSerializer, gossipDigestAckHandler),
-    GOSSIP_DIGEST_ACK2: new NetVerb<GossipDigestAck2>(16, timeouts.longTimeout, () => GossipDigestAck2Serializer, gossipDigestAck2Handler),
-    // GOSSIP_SHUTDOWN: new NetVerb<GossipShutdown>(29, timeouts.longTimeout, () => GossipShutdownSerializer, gossipShutdownHandler),
-
-    ECHO_RSP: new NetVerb<NoPayload>(91, timeouts.rpcTimeout, () => NoPayloadSerializer, responseHandler),
-    ECHO_REQ: new NetVerb<NoPayload>(31, timeouts.rpcTimeout, () => NoPayloadSerializer, echoHandler, () => Verbs.ECHO_RSP),
-
-    // generic failure
-    FAILURE_RESPONSE: new NetVerb<RequestFailureReason>(99, timeouts.noTimeout, () => RequestFailureReasonSerializer, responseHandler),
-
-    // dummy verb for testing
-    _TEST1: new NetVerb<NoPayload>(10, timeouts.writeTimeout, () => NoPayloadSerializer, () => undefined)
-};
-
-export type MessageType = keyof typeof Verbs;
-
-export function fromId(id: number): MessageType {
-    for (const [key, value] of Object.entries<Verb<unknown>>(Verbs)) {
-        if (value.id === id) {
-            return key as MessageType;
-        }
-    }
-    throw new Error(`Unknown verb id: ${id}`);
-}

package/src/net/AddressSerializer.ts

@@ -1,44 +0,0 @@
-import type {DataInput, DataOutput, VersionedSerializer} from '../io/VersionedSerializer.ts';
-import {type Address, fromIpAddress} from '../cluster/Address.ts';
-import {getByAddress} from '../utils/network.ts';
-
-class AddressSerializer implements VersionedSerializer<Address> {
-    readonly MAX_SIZE = 1 + 16 + 2; // 1 byte for length, 16 bytes for address, 2 bytes for port
-    serialize(value: Address, output: DataOutput, version?: number) {
-        this.serializeAddressAndPort(value.address.addressBytes, value.port, output, version);
-    }
-    deserialize(input: DataInput, version?: number): Address {
-        const size = input.readInt8() & 0xFF;
-        switch (size) {
-            case 4:
-            case 16:
-                throw new Error(`unexpected address size: ${size}`);
-            case 6:
-            case 18: {
-                const address = new Uint8Array(size - 2);
-                input.readUint8Array(address);
-                const port = input.readInt16() & 0xFFFF;
-
-                const ipAddress = getByAddress(undefined, address);
-                return fromIpAddress(ipAddress, port);
-            }
-            default:
-                throw new Error(`unexpected address size: ${size}`);
-        }
-    }
-
-    private serializeAddressAndPort(address: Uint8Array, port: number, output: DataOutput, version?: number) {
-        output.writeUint8(address.length + 2);
-        output.writeUint8Array(address);
-        output.writeUint16(port);
-    }
-
-    serializedSize(value: Address, version?: number): number {
-        if (value.type === 4) {
-            return 1 + 4 + 2;
-        }
-        return 1 + 16 + 2;
-    }
-}
-
-export const addressSerializer = new AddressSerializer();

package/src/net/ByteBufferAllocator.ts

@@ -1,27 +0,0 @@
-import type {ByteBuffer} from '../utils/buffer.ts';
-import {forNetworking} from '../utils/memory/BufferPools.ts';
-
-const bufferPool= forNetworking();
-
-abstract class ByteBufferAllocator {
-
-    getAtLeast(size: number): ByteBuffer {
-        return bufferPool.getAtLeast(size);
-    }
-
-    put(buffer: ByteBuffer) {
-        return bufferPool.put(buffer);
-    }
-}
-
-export type {ByteBufferAllocator};
-
-class GlobalByteBufferAllocator extends ByteBufferAllocator {
-  public static readonly instance= new GlobalByteBufferAllocator();
-
-  private constructor() {
-    super();
-  }
-}
-
-export const globalByteBufferAllocator: ByteBufferAllocator = GlobalByteBufferAllocator.instance;