@interopio/bridge 0.0.1-alpha

package/src/io/VersionedSerializer.ts

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

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

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

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

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