@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/io/VersionedSerializer.ts

@@ -1,230 +0,0 @@
-import type {ByteBuffer} from '../utils/buffer.ts';
-import {readUtf, writeUtf} from './util.ts';
-import {readUnsignedVInt32, setUnsignedVInt, setUnsignedVInt32} from '../utils/vint.ts';
-
-export interface DataOutput {
-    writeInt8(value: number): void
-    writeUint8(value: number): void
-    writeInt16(value: number): void
-    writeUint16(value: number): void
-    writeInt32(value: number): void
-    writeUint32(value: number): void
-    writeUtf8String(value: string): void
-    writeUint8Array(value: Uint8Array, offset?: number, length?: number): void
-    writeBoolean(value: boolean): void
-    writeUnsignedVInt(value: bigint | number): void
-    writeUnsignedVInt32(value: number): void
-}
-
-export interface DataInput {
-    readInt8(): number
-    readUint8(): number
-    readInt16(): number
-    readUint16(): number
-    readInt32(): number
-    // readUint32(): number
-    readUtf8String(): string
-    readUint8Array(b: Uint8Array): void
-    readUint8Array(b: Uint8Array, offset:number, length: number): void
-    // readBoolean(): boolean
-    readUnsignedVInt32(): number
-
-    skipBytes(n: number): number;
-    skipBytesFully(n: number): void;
-}
-
-export interface VersionedSerializer<T> {
-    serialize(value: T, output: DataOutput, version: number): void
-
-    deserialize(input: DataInput, version: number): T
-
-    serializedSize(value: T, version: number): number
-}
-
-
-export class ByteBufferOutput implements DataOutput {
-    private readonly _buffer: ByteBuffer;
-
-    constructor(buffer: ByteBuffer) {
-        this._buffer = buffer;
-    }
-
-    get buffer() {
-        return this._buffer.duplicate().flip();
-    }
-
-    writeUtf8String(value: string) {
-        writeUtf(value, this);
-    }
-
-    writeBoolean(value: boolean) {
-        this._buffer.setUint8(value ? 1 : 0);
-    }
-
-    writeUint8(value: number) {
-        this._buffer.setUint8(value);
-    }
-
-    writeInt8(value: number) {
-        this._buffer.setInt8(value);
-    }
-
-    writeInt16(value: number) {
-        this._buffer.setInt16(value);
-    }
-
-    writeUint16(value: number) {
-        this._buffer.setUint16(value);
-    }
-
-    writeInt32(value: number) {
-        this._buffer.setInt32(value);
-    }
-
-    writeUint32(value: number) {
-        this._buffer.setUint32(value);
-    }
-
-    writeUint8Array(value: Uint8Array, offset: number = 0, length?: number) {
-        length ??= value.length - offset;
-
-        if (offset < 0 || offset > value.length || length < 0 || length > value.length - offset) {
-            throw new Error(`index out of bounds: ${offset} + ${length} > ${value.length}`);
-        }
-
-        if (length === 0) {
-            return;
-        }
-
-        let copied = 0;
-        while (copied < length) {
-            if (this._buffer.hasRemaining) {
-                const chunkSize = Math.min(length - copied, this._buffer.remaining);
-                this._buffer.setUint8Array(value, offset + copied, chunkSize);
-                copied += chunkSize;
-            }
-            else {
-                throw new Error(`Buffer overflow: ${this._buffer.remaining} remaining, ${length - copied} to copy`);
-            }
-        }
-    }
-
-    writeUnsignedVInt(value: bigint | number) {
-        setUnsignedVInt(value, this._buffer);
-    }
-
-    writeUnsignedVInt32(value: number) {
-        setUnsignedVInt32(value, this._buffer);
-    }
-}
-
-export class ByteBufferInput implements DataInput {
-
-    private readonly buffer: ByteBuffer;
-
-    constructor(buffer: ByteBuffer, duplicate: boolean) {
-        this.buffer = duplicate ? buffer.duplicate() : buffer;
-    }
-
-    readInt8(): number {
-        if (this.buffer.hasRemaining) {
-            return this.buffer.getInt8();
-        }
-        throw new Error('Buffer underflow');
-    }
-
-    readUint8(): number {
-        if (this.buffer.hasRemaining) {
-            return this.buffer.getUint8();
-        }
-        throw new Error('Buffer underflow');
-    }
-
-    readUint16(): number {
-        if (this.buffer.remaining >= 2) {
-            return this.buffer.getUint16();
-        }
-        throw new Error('Buffer underflow');
-    }
-
-    readInt16(): number {
-        if (this.buffer.remaining > 1) {
-            return this.buffer.getInt16();
-        }
-        throw new Error('Buffer underflow');
-    }
-
-    readInt32(): number {
-        if (this.buffer.remaining >= 4) {
-            return this.buffer.getInt32();
-        }
-        throw new Error('Buffer underflow');
-    }
-
-    readUtf8String(): string {
-        return readUtf(this);
-    }
-
-    readUint8Array(b: Uint8Array, offset: number = 0, length?: number): void {
-        length ??= b.length - offset;
-
-        if (offset < 0 || offset > b.length || length < 0 || length > b.length - offset) {
-            throw new Error(`index out of bounds: ${offset} + ${length} > ${b.length}`);
-        }
-
-        if (length === 0) {
-            return;
-        }
-
-        let copied = 0;
-        while (copied < length) {
-            if (this.buffer.hasRemaining) {
-                const chunkSize = Math.min(length - copied, this.buffer.remaining);
-                this.buffer.getUint8Array(b, offset + copied, chunkSize);
-                copied += chunkSize;
-            }
-            else {
-                throw new Error(`Buffer underflow: ${this.buffer.remaining} remaining, ${length - copied} to copy`);
-            }
-        }
-    }
-    readUnsignedVInt32(): number {
-        return readUnsignedVInt32(this);
-    }
-
-    skipBytesFully(n: number) {
-        const skipped = this.skipBytes(n);
-        if (skipped !== n) {
-            throw new Error(`Buffer underflow: ${n} bytes requested, ${skipped} bytes skipped`);
-        }
-    }
-
-    skipBytes(n: number): number {
-        if (n <= 0) {
-            return 0;
-        }
-
-        const requested = n;
-        let position = this.buffer.position;
-        let limit = this.buffer.limit;
-        let remaining: number;
-
-        while ((remaining = limit - position) < n) {
-            n -= remaining;
-            this.buffer.position = limit;
-            position = this.buffer.position;
-            limit = this.buffer.limit;
-            if (position == limit) {
-                return requested - n;
-            }
-        }
-        this.buffer.position = position + n;
-
-
-        return requested;
-    }
-
-    available(): number {
-        return this.buffer.remaining;
-    }
-}

package/src/io/util.ts

@@ -1,117 +0,0 @@
-import type {DataInput, DataOutput} from './VersionedSerializer.ts';
-
-const MAX_BUFFER_SIZE = 8192;
-let tmpBuffer: Uint8Array = new Uint8Array(16);
-
-function retrieveTemporaryBuffer(minSize: number): Uint8Array {
-    let array = tmpBuffer;
-    if (array.length < Math.min(minSize, MAX_BUFFER_SIZE)) {
-        array = new Uint8Array(Math.min(MAX_BUFFER_SIZE, Math.pow(minSize, 2)));
-        tmpBuffer = array;
-    }
-    return array;
-}
-
-export function encodedUtfLength(value: string): number {
-    const strlen = value.length;
-    let utflen = 0;
-    for (let i = 0; i < strlen; i++)
-    {
-        const c = value.charCodeAt(i);
-        if ((c >= 0x0001) && (c <= 0x007F))
-            utflen++;
-        else if (c > 0x07FF)
-            utflen += 3;
-        else
-            utflen += 2;
-    }
-    return utflen;
-}
-
-export function writeUtf(value: string, out: DataOutput): void {
-    let length = value.length;
-    if (length === 0) {
-        out.writeUint8(0);
-        out.writeUint8(0);
-        return;
-    }
-    let utfCount = 0;
-    let maxSize = 2;
-
-    for (let i = 0; i < length; i++) {
-        const ch = value.charCodeAt(i);
-        if ((ch > 0) && (ch < 128)) {
-            utfCount++;
-        } else if (ch < 2047) {
-            utfCount += 2;
-        } else {
-            utfCount += maxSize = 3;
-        }
-    }
-    if (utfCount > 65535) {
-        throw new Error(`String too long: ${value}`);
-    }
-
-    const utfBytes = retrieveTemporaryBuffer(utfCount);
-
-    const bufferLength = utfBytes.length;
-    if (utfCount == length) {
-        utfBytes[0] = (utfCount >> 8);
-        utfBytes[1] = (utfCount);
-        let firstIndex = 2;
-        for (let offset = 0; offset < length; offset += bufferLength) {
-            const runLength = Math.min(bufferLength - firstIndex, length - offset) + firstIndex;
-            offset -= firstIndex;
-            for (let i = firstIndex; i < runLength; i++) {
-                utfBytes[i] = value.charCodeAt(offset + i);
-            }
-            out.writeUint8Array(utfBytes, 0, runLength);
-            firstIndex = 0;
-        }
-    } else {
-        let utfIndex = 2;
-        let offset = 0;
-
-        utfBytes[0] = (utfCount >> 8);
-        utfBytes[1] = (utfCount);
-
-        while (length > 0) {
-            let charRunLength = Math.floor((utfBytes.length - utfIndex) / maxSize);
-
-            if (charRunLength < 128 && charRunLength < length) {
-                out.writeUint8Array(utfBytes, 0, utfIndex);
-                utfIndex = 0;
-            }
-            if (charRunLength > length) {
-                charRunLength = length;
-            }
-
-            for (let i = 0; i < charRunLength; i++) {
-                const ch = value.charCodeAt(offset + i);
-                if (ch > 0 && ch < 128) {
-                    utfBytes[utfIndex++] = ch;
-                } else if (ch < 2048) {
-                    utfBytes[utfIndex++] = (0xc0 | (0x1f & (ch >> 6)));
-                    utfBytes[utfIndex++] = (0x80 | (0x3f & (ch & 0x3f)));
-                } else {
-                    utfBytes[utfIndex++] = (0xe0 | (0x0f & (ch >> 12)));
-                    utfBytes[utfIndex++] = (0x80 | (0x3f & (ch >> 6)));
-                    utfBytes[utfIndex++] = (0x80 | (0x3f & ch));
-                }
-            }
-
-            offset += charRunLength;
-            length -= charRunLength;
-        }
-        out.writeUint8Array(utfBytes, 0, utfIndex);
-    }
-}
-
-const decoder = new TextDecoder('utf-8');
-export function readUtf(input: DataInput): string {
-    const length = input.readUint16();
-
-    const utfBytes = new Uint8Array(length);
-    input.readUint8Array(utfBytes);
-    return decoder.decode(utfBytes);
-}

package/src/kubernetes/DnsEndpointResolver.ts

@@ -1,70 +0,0 @@
-import {type DiscoveryNode} from '../discovery/index.ts';
-import {getAllByName, type IpAddress} from '../utils/network.ts';
-import {KubernetesEndpointResolver} from './KubernetesEndpointResolver.ts';
-import {KubernetesConfig} from './KubernetesConfig.ts';
-import {NetworkConfig} from '../config/Config.ts';
-import type {Logger} from '../logging.ts';
-import {SimpleDiscoveryNode} from "../discovery/SimpleDiscoveryNode";
-import {fromHostname} from "../cluster/Address";
-
-export type LookupProvider = (host: string) => Promise<IpAddress[]>;
-
-export class DnsEndpointResolver extends KubernetesEndpointResolver {
-    private readonly lookupProvider: LookupProvider;
-    private readonly serviceDns: string;
-    private readonly port: number;
-
-    static of(logger: Logger, config: KubernetesConfig): DnsEndpointResolver {
-        return new DnsEndpointResolver(logger, getAllByName, config.serviceDns, config.servicePort);
-    }
-
-    /*testing*/ constructor(logger: Logger, lookupProvider: LookupProvider, serviceDns?: string, port: number = 0) {
-        super(logger);
-        this.lookupProvider = lookupProvider;
-        this.serviceDns = serviceDns;
-        this.port = port;
-    }
-
-    async resolve(): Promise<DiscoveryNode[]> {
-        try {
-            return await this.lookup();
-        } catch (e) {
-            return [];
-        }
-    }
-
-    private async  lookup() {
-
-        const addresses = new Set<string>();
-
-        for (const ipAddress of await this.lookupProvider(this.serviceDns)) {
-            const address = ipAddress.address;
-            if (addresses.has(address)) {
-                continue;
-            }
-            if (this.logger.enabledFor('debug')) {
-                this.logger.debug(`Found node service with address: ${ipAddress}`);
-            }
-            addresses.add(address);
-        }
-        if (addresses.size === 0) {
-            this.logger.warn(`No nodes found for service: ${this.serviceDns}`);
-            return [];
-        }
-
-        const result: Array<DiscoveryNode> = [];
-        for (const address of addresses) {
-            const privateAddress = await fromHostname(address, DnsEndpointResolver.getBridgePort(this.port));
-            const node = new SimpleDiscoveryNode(privateAddress);
-            result.push(node);
-        }
-        return result;
-    }
-
-    private static getBridgePort(port: number): number {
-        if (port > 0) {
-            return port;
-        }
-        return NetworkConfig.DEFAULT_PORT;
-    }
-}

package/src/kubernetes/KubernetesApiEndpointResolver.ts

@@ -1,111 +0,0 @@
-import {Endpoint, EndpointAddress, KubernetesClient} from './KubernetesClient.ts';
-import {type DiscoveryNode} from '../discovery/index.ts';
-import {type Address, fromIpAddress} from '../cluster/Address.ts';
-import {type Logger} from '../logging.ts';
-import {KubernetesEndpointResolver} from './KubernetesEndpointResolver.ts';
-import {KubernetesConfig} from './KubernetesConfig.ts';
-import {NetworkConfig} from '../config/Config.ts';
-import {type ClusterTopologyIntentTracker} from '../instance/ClusterTopologyIntentTracker.ts';
-import {SimpleDiscoveryNode} from '../discovery/SimpleDiscoveryNode.ts';
-
-function buildKubernetesClient(config: KubernetesConfig, clusterTopologyIntentTracker?: ClusterTopologyIntentTracker): KubernetesClient {
-    return new KubernetesClient(config.namespace, config.kubernetesMasterUrl, config.exposeExternallyMode, config.tokenProvider, config.servicePerPodLabelName, config.servicePerPodLabelValue, clusterTopologyIntentTracker);
-}
-
-export class KubernetesApiEndpointResolver extends KubernetesEndpointResolver {
-
-    private readonly client: KubernetesClient;
-    private readonly serviceName?: string;
-    private readonly port: number = 0;
-    private readonly serviceLabel?: string;
-    private readonly serviceLabelValue?: string;
-    private readonly podLabel?: string;
-    private readonly podLabelValue?: string;
-    private readonly resolveNotReadyAddresses?: boolean;
-
-    static of(logger: Logger, config: KubernetesConfig, tracker?: ClusterTopologyIntentTracker): KubernetesApiEndpointResolver {
-        return new KubernetesApiEndpointResolver(logger, buildKubernetesClient(config, tracker),
-            config.serviceName, config.servicePort, config.serviceLabelName,
-            config.serviceLabelValue, config.podLabelName, config.podLabelValue, config.resolveNotReadyAddresses);
-    }
-
-    /*testing*/ constructor(logger: Logger,
-                            client: KubernetesClient,
-                            serviceName?: string,
-                            port: number = 0,
-                            serviceLabel?: string,
-                            serviceLabelValue?: string,
-                            podLabel?: string,
-                            podLabelValue?: string,
-                            resolveNotReadyAddresses?: boolean) {
-        super(logger);
-        this.client = client;
-        this.serviceName = serviceName;
-        this.port = port;
-        this.serviceLabel = serviceLabel;
-        this.serviceLabelValue = serviceLabelValue;
-        this.podLabel = podLabel;
-        this.podLabelValue = podLabelValue;
-        this.resolveNotReadyAddresses = resolveNotReadyAddresses;
-    }
-
-    async resolve(): Promise<DiscoveryNode[]> {
-        if (this.serviceName) {
-            return await this.getSimpleDiscoveryNodes(await this.client.endpointsByName(this.serviceName));
-        }
-        else if (this.serviceLabel) {
-            return await this.getSimpleDiscoveryNodes(await this.client.endpointsByServiceLabel(this.serviceLabel, this.serviceLabelValue));
-        }
-        else if (this.podLabel) {
-            return await this.getSimpleDiscoveryNodes(await this.client.endpointsByPodLabel(this.podLabel, this.podLabelValue));
-        }
-        return await this.getSimpleDiscoveryNodes(await this.client.endpoints());
-    }
-
-    private async getSimpleDiscoveryNodes(endpoints: readonly Endpoint[]): Promise<DiscoveryNode[]> {
-        const discoveredNodes = new Array<DiscoveryNode>();
-        for (const endpoint of endpoints) {
-            await this.addAddress(discoveredNodes, endpoint);
-        }
-        return discoveredNodes;
-    }
-
-    private async addAddress(discoveredNodes: Array<DiscoveryNode>, endpoint: Endpoint): Promise<void> {
-        if (this.resolveNotReadyAddresses === true || endpoint.ready) {
-            const privateAddress = await this.createAddress(endpoint.privateAddress, this.resolvePort.bind(this));
-            const publicAddress = await this.createAddress(endpoint.publicAddress, this.resolvePortPublic.bind(this));
-            discoveredNodes.push(new SimpleDiscoveryNode(privateAddress, publicAddress, new Map<string, string>()));
-        }
-    }
-
-    private async createAddress(address: EndpointAddress | undefined, portResolver: (address: EndpointAddress) => number): Promise<Address> {
-        if (address === undefined) {
-            return undefined;
-        }
-        const ip = address.ip;
-        const ipAddress = await this.mapAddress(ip);
-        const port = portResolver(address);
-        return fromIpAddress(ipAddress, port);
-    }
-
-    private resolvePort(address: EndpointAddress) {
-        if (this.port > 0) {
-            return this.port;
-        }
-        if (address.port) {
-
-            return address.port;
-        }
-        return NetworkConfig.DEFAULT_PORT;
-    }
-
-    private resolvePortPublic(address: EndpointAddress) {
-        if (address.port) {
-            return address.port;
-        }
-        if (this.port > 0) {
-            return this.port;
-        }
-        return NetworkConfig.DEFAULT_PORT;
-    }
-}

package/src/kubernetes/KubernetesApiProvider.ts

@@ -1,75 +0,0 @@
-import {Endpoint, EndpointAddress} from './KubernetesClient.ts';
-
-export interface KubernetesApiProvider {
-    getEndpointsByNameUrlString(kubernetesMaster: string, namespace: string, endpointName: string): string;
-
-    getEndpointsByServiceLabelUrlString(kubernetesMaster: string, namespace: string, serviceLabel: string): string;
-
-    parseEndpoints(param: any): Endpoint[];
-}
-
-export class KubernetesApiEndpointSlicesProvider implements KubernetesApiProvider {
-    getEndpointsByServiceLabelUrlString(kubernetesMaster: string, namespace: string, param: string): string {
-        return `${kubernetesMaster}/apis/discovery.k8s.io/v1/namespaces/${namespace}/endpointslices?${param}`;
-    }
-
-    getEndpointsByNameUrlString(kubernetesMaster: string, namespace: string, endpointName: string): string {
-        return `${kubernetesMaster}/apis/discovery.k8s.io/v1/namespaces/${namespace}/endpointslices?labelSelector=kubernetes.io/service-name=${endpointName}`;
-    }
-
-    parseEndpoints(param: {
-        items: Array<{ endpoints: Array<{ conditions: { ready: boolean }, addresses: Array<string> }>, ports: Array<{}> }>
-    }): Endpoint[] {
-        const endpoints = new Array<Endpoint>();
-        for (const item of param.items) {
-            endpoints.push(...this.parseEndpointSlices(item));
-        }
-        return endpoints;
-    }
-
-    private parseEndpointSlices(item: {
-        endpoints: Array<{
-            conditions: {
-                ready: boolean
-            },
-            addresses: Array<string>
-        }>,
-        ports: Array<{name?: string, port?: number}>
-    }): Endpoint[] {
-        const addresses = new Array<Endpoint>();
-        const endpointPort = this.extractPort(item);
-        for (const endpoint of item.endpoints) {
-            const ready = endpoint.conditions.ready;
-            for (const address of endpoint.addresses) {
-                addresses.push(new Endpoint(new EndpointAddress({ip: address, port: endpointPort}), undefined, ready))
-            }
-
-        }
-        return addresses;
-    }
-
-    private extractPort(item: {
-        ports: Array<{
-            name?: string,
-            port?: number
-
-        }>
-    }): number | undefined {
-        for (const port of item.ports) {
-            const bridgeServicePort = port.name;
-            if (bridgeServicePort && bridgeServicePort === 'io-bridge') {
-                const servicePort = port.port;
-                if (servicePort !== undefined) {
-                    return servicePort;
-                }
-            }
-        }
-        if (item.ports.length === 1) {
-            const port = item.ports[0];
-            const servicePort = port.port;
-            if (servicePort !== undefined) {
-                return servicePort;
-            }
-        }
-    }
-}