@interopio/bridge 0.0.1-alpha

package/src/kubernetes/KubernetesClient.ts

@@ -0,0 +1,264 @@
+import {type ExposeExternallyMode} from './KubernetesConfig.ts';
+import {KubernetesApiEndpointSlicesProvider, type KubernetesApiProvider} from './KubernetesApiProvider.ts';
+import {type ClusterTopologyIntentTracker} from '../instance/ClusterTopologyIntentTracker.ts';
+
+class Address {
+    readonly ip: string;
+
+    readonly port?: number;
+
+    constructor(ip: string, port?: number) {
+        this.ip = ip;
+        this.port = port;
+    }
+}
+
+export type {Address};
+
+export class EndpointAddress {
+    readonly targetRefName?: string;
+
+    private readonly address: Address;
+
+    constructor(address: Address, targetRefName?: string) {
+        this.address = address;
+        this.targetRefName = targetRefName;
+    }
+
+    get ip(): string {
+        return this.address.ip;
+    }
+
+    get port(): number | undefined {
+        return this.address.port;
+    }
+}
+
+export class Endpoint {
+
+    readonly privateAddress: EndpointAddress;
+    readonly publicAddress: EndpointAddress | undefined = undefined;
+    readonly ready: boolean;
+    readonly additionalProperties: ReadonlyMap<string, string> = new Map();
+
+    constructor(privateAddress: EndpointAddress,
+                publicAddress: EndpointAddress | undefined = undefined,
+                ready: boolean,
+                additionalProperties: ReadonlyMap<string, string> = new Map()) {
+        this.privateAddress = privateAddress;
+        this.publicAddress = publicAddress;
+        this.ready = ready;
+        this.additionalProperties = additionalProperties;
+    }
+}
+
+const READ_TIMEOUT_SECONDS = 10;
+
+function isReady(podItemStatus: { containerStatuses?: Array<{ ready?: boolean }> }): boolean {
+    for (const containerStatus of podItemStatus.containerStatuses) {
+        if (containerStatus.ready !== true) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function containerPort(container: {
+    ports?: Array<{
+        containerPort?: number
+    }>
+}): number | undefined {
+    const ports = container.ports;
+    if (ports.length > 0) {
+        const port = ports[0];
+        return port.containerPort;
+    }
+}
+
+function extractContainerPort(item: {
+    spec: {
+        containers?: Array<{ name?: string, ports?: Array<{ containerPort?: number }> }>
+    }
+}): number | undefined {
+    const containers = item.spec.containers;
+    if (containers.length === 1) {
+        const container = containers[0];
+        return containerPort(container);
+    } else {
+        for (const container of containers) {
+            if (container.name === 'io-bridge') {
+                return containerPort(container);
+            }
+        }
+    }
+}
+
+function parsePodsList(podList: {
+    items?: Array<{
+        metadata: {
+            name: string
+        },
+        status: {
+            podIP?: string
+            containerStatuses?: Array<{ ready?: boolean }>
+        },
+        spec: {}
+    }>
+}): Array<Endpoint> {
+    const addresses = new Array<Endpoint>();
+    for (const item of podList.items) {
+        const podName = item.metadata.name;
+        const status = item.status;
+        const ip = status.podIP;
+        if (ip) {
+            const port = extractContainerPort(item);
+            addresses.push(new Endpoint(new EndpointAddress({ip, port}, podName), undefined, isReady(status)));
+        }
+    }
+    return addresses;
+}
+
+function getLabelSelectorParameter(labelNames: string, labelValues: string): string {
+    const labelNameArray = labelNames.split(',');
+    const labelValueArray = labelValues.split(',');
+    const selectorList = [];
+    for (let i = 0; i < labelNameArray.length; i++) {
+        selectorList[i] = (`${labelNameArray[i]}=${labelValueArray[i]}`);
+    }
+    return `labelSelector=${selectorList.join(',')}`;
+}
+
+export class KubernetesClient {
+
+    private readonly namespace: string;
+    private readonly kubernetesMaster: string;
+    private readonly exposeExternallyMode: ExposeExternallyMode;
+    private readonly tokenProvider: () => string;
+    private readonly servicePerPodLabelName?: string;
+    private readonly servicePerPodLabelValue?: string;
+    private readonly clientTopologyIntentTracker?: ClusterTopologyIntentTracker;
+    private readonly apiProvider: KubernetesApiProvider
+
+    /*testing*/
+    constructor(namespace: string,
+                kubernetesMaster: string,
+                exposeExternallyMode: ExposeExternallyMode,
+                tokenProvider: () => string,
+                servicePerPodLabelName?: string,
+                servicePerPodLabelValue?: string,
+                clientTopologyIntentTracker?: ClusterTopologyIntentTracker,
+                apiProvider?: KubernetesApiProvider) {
+
+        this.namespace = namespace;
+        this.kubernetesMaster = kubernetesMaster;
+        this.exposeExternallyMode = exposeExternallyMode;
+        this.tokenProvider = tokenProvider;
+        this.servicePerPodLabelName = servicePerPodLabelName;
+        this.servicePerPodLabelValue = servicePerPodLabelValue;
+        if (clientTopologyIntentTracker) {
+            clientTopologyIntentTracker.init();
+        }
+        this.apiProvider = apiProvider ?? new KubernetesApiEndpointSlicesProvider();
+    }
+
+    start(): void {
+
+    }
+
+    destroy(): void {
+        if (this.clientTopologyIntentTracker) {
+            this.clientTopologyIntentTracker.destroy();
+        }
+    }
+
+    /**
+     * Returns POD addresses in the specified namespace.
+     *
+     */
+    async endpoints(): Promise<Endpoint[]> {
+        try {
+            const url = `${this.kubernetesMaster}/api/v1/namespaces/${this.namespace}/pods`;
+            return this.enrichWithPublicAddresses(parsePodsList(await this.callGet(url)));
+        } catch (e) {
+            return this.handleUnknownError(e);
+        }
+    }
+
+    /**
+     * Retrieves POD addresses for all services in the specified namespace filtered by service labels and values.
+     * @param serviceLabels      comma separated list of service labels
+     * @param serviceLabelValues comma separated list of service label values
+     * @return all POD addresses from the specified namespace filtered by labels
+     */
+    async endpointsByServiceLabel(serviceLabels: string, serviceLabelValues: string): Promise<Endpoint[]> {
+        try {
+            const param = getLabelSelectorParameter(serviceLabels, serviceLabelValues);
+            const url = this.apiProvider.getEndpointsByServiceLabelUrlString(this.kubernetesMaster, this.namespace, param);
+            return this.enrichWithPublicAddresses(this.apiProvider.parseEndpoints(this.callGet(url)));
+        } catch (e) {
+            return this.handleUnknownError(e);
+        }
+    }
+
+    /**
+     * Retrieves POD addresses from the specified namespace and given endpointName.
+     * @param endpointName endpoint name
+     * @return all POD addresses from the specified namespace and the given endpointName
+     */
+    async endpointsByName(endpointName: string): Promise<Endpoint[]> {
+        try {
+            const url = this.apiProvider.getEndpointsByNameUrlString(this.kubernetesMaster, this.namespace, endpointName);
+            return this.enrichWithPublicAddresses(this.apiProvider.parseEndpoints(await this.callGet(url)));
+        } catch (e) {
+            return this.handleUnknownError(e);
+        }
+    }
+
+    /**
+     * Retrieves POD addresses for all services in the specified namespace filtered by pod labels and values.
+     * @param podLabels      comma separated list of pod labels
+     * @param podLabelValues comma separated list of pod label values
+     * @return all POD addresses from the specified namespace filtered by the labels
+     */
+    async endpointsByPodLabel(podLabels: string, podLabelValues: string) {
+        try {
+            const param = getLabelSelectorParameter(podLabels, podLabelValues);
+            const url = `${this.kubernetesMaster}/api/v1/namespaces/${this.namespace}/pods?${param}`;
+            return this.enrichWithPublicAddresses(parsePodsList(await this.callGet(url)));
+        } catch (e) {
+            return this.handleUnknownError(e);
+        }
+    }
+
+    private enrichWithPublicAddresses(endpoints: Endpoint[]): Endpoint[] {
+        if (this.exposeExternallyMode === 'disabled') {
+            return endpoints;
+        }
+
+    }
+
+    private handleUnknownError(e): Endpoint[] {
+        // todo handle error
+        return [];
+    }
+
+    private async callGet(url: string): Promise<any> {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort(`request to ${url} timed out`);
+        }, READ_TIMEOUT_SECONDS * 1000);
+        try {
+            const response = await fetch(url, {
+                signal: controller.signal,
+                headers: [["Authorization", `Bearer ${this.tokenProvider()}`]]
+            }).catch((err) => {
+                throw err;
+            });
+
+            return await response.json();
+
+        } finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/src/kubernetes/KubernetesConfig.ts

@@ -0,0 +1,130 @@
+import { readFileSync} from 'node:fs';
+import { getOrDefault, getOrUndefined } from '../discovery/settings.ts';
+import {
+    KUBERNETES_API_TOKEN,
+    KUBERNETES_MASTER_URL,
+    KUBERNETES_ENV_PREFIX,
+    NAMESPACE,
+    RESOLVE_NOT_READY_ADDRESSES,
+    SERVICE_DNS,
+    SERVICE_NAME,
+    SERVICE_PORT,
+    EXPOSE_EXTERNALLY,
+    SERVICE_LABEL_NAME,
+    SERVICE_LABEL_VALUE,
+    POD_LABEL_NAME,
+    POD_LABEL_VALUE,
+    SERVICE_PER_POD_LABEL_NAME, SERVICE_PER_POD_LABEL_VALUE
+} from './KubernetesProperties.ts';
+import {type Properties} from '../config/Properties.ts';
+
+export type DiscoveryMode = 'kubernetes-api' | 'dns-lookup';
+export type ExposeExternallyMode = 'auto' | 'enabled' | 'disabled';
+
+function readFileContents(fileName: string): string {
+    return readFileSync(fileName, 'utf-8').toString();
+}
+
+
+export class KubernetesConfig {
+    readonly serviceDns?: string
+
+    readonly serviceName?: string
+    readonly serviceLabelName?: string
+    readonly serviceLabelValue?: string
+    readonly namespace: string
+    readonly podLabelName?: string
+    readonly podLabelValue?: string
+    readonly resolveNotReadyAddresses: boolean
+    readonly exposeExternallyMode: ExposeExternallyMode
+    readonly servicePerPodLabelName?: string
+    readonly servicePerPodLabelValue?: string
+    readonly kubernetesMasterUrl: string
+    readonly kubernetesApiToken?: string
+
+    readonly servicePort: number
+    private readonly fileContentsReader: (fileName: string) => string;
+
+    readonly tokenProvider: () => string;
+
+    constructor(properties: Properties, fileContentsReader: (fileName: string) => string = readFileContents) {
+        this.fileContentsReader = fileContentsReader;
+        this.serviceDns = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_DNS);
+        this.serviceName = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_NAME);
+        this.serviceLabelName = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, SERVICE_LABEL_NAME);
+        this.serviceLabelValue = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_LABEL_VALUE, "true");
+        this.resolveNotReadyAddresses = getOrDefault(properties, KUBERNETES_ENV_PREFIX, RESOLVE_NOT_READY_ADDRESSES, true);
+        this.podLabelName = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, POD_LABEL_NAME);
+        this.podLabelValue = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, POD_LABEL_VALUE);
+
+        this.exposeExternallyMode = this.getExposeExternallyMode(properties);
+        this.servicePerPodLabelName = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, SERVICE_PER_POD_LABEL_NAME);
+        this.servicePerPodLabelValue = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, SERVICE_PER_POD_LABEL_VALUE);
+        this.kubernetesMasterUrl = getOrDefault(properties, KUBERNETES_ENV_PREFIX, KUBERNETES_MASTER_URL, "https://kubernetes.default.svc");
+        this.tokenProvider = this.buildTokenProvider(properties);
+        this.servicePort = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_PORT, 0);
+        this.namespace = this.getNamespaceWithFallbacks(properties);
+    }
+
+    private getExposeExternallyMode(properties: Properties): ExposeExternallyMode {
+        const exposeExternally: boolean | undefined = getOrUndefined<boolean>(properties, KUBERNETES_ENV_PREFIX, EXPOSE_EXTERNALLY);
+        if (exposeExternally === undefined) {
+            return 'auto';
+        }
+        else if (exposeExternally) {
+            return 'enabled';
+        }
+        else {
+            return 'disabled';
+        }
+    }
+
+    private getNamespaceWithFallbacks(properties: Properties): string {
+        let namespace: string | undefined = getOrDefault(properties, KUBERNETES_ENV_PREFIX, NAMESPACE);
+        if (!namespace) {
+            namespace = process.env['KUBERNETES_NAMESPACE'];
+        }
+        if (!namespace && this.mode === 'kubernetes-api') {
+            namespace = this.readNamespace();
+        }
+        return namespace;
+    }
+
+    private buildTokenProvider(properties: {}): () => string {
+        const apiToken: string | undefined = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, KUBERNETES_API_TOKEN);
+        if (!apiToken && this.mode === 'kubernetes-api') {
+            return () => readFileContents('/var/run/secrets/kubernetes.io/serviceaccount/token')
+        } else {
+            return () => apiToken;
+        }
+    }
+
+    private readNamespace(): string {
+        return this.fileContentsReader('/var/run/secrets/kubernetes.io/serviceaccount/namespace');
+    }
+
+
+    get mode(): DiscoveryMode {
+        if (this.serviceDns) {
+            return 'dns-lookup';
+        }
+        return 'kubernetes-api';
+    }
+
+    toString() {
+        return "KubernetesConfig: {"
+            + "service-dns: " + this.serviceDns
+            + ", service-name: " + this.serviceName
+            + ", service-port: " + this.servicePort
+            + ", service-label-name: " + this.serviceLabelName
+            + ", service-label-value: " + this.serviceLabelValue
+            + ", namespace: " + this.namespace
+            + ", pod-label-name: " + this.podLabelName
+            + ", pod-label-value: " + this.podLabelValue
+            + ", resolve-not-ready-addresses: " + this.resolveNotReadyAddresses
+            + ", expose-externally-mode: " + this.exposeExternallyMode
+            + ", service-per-pod-label-name: " + this.servicePerPodLabelName
+            + ", service-per-pod-label-value: " + this.servicePerPodLabelValue
+            + ", kubernetes-master-url: " + this.kubernetesMasterUrl + "}";
+    }
+}

package/src/kubernetes/KubernetesDiscoveryStrategy.ts

@@ -0,0 +1,30 @@
+import {type DiscoveryNode, type DiscoveryStrategy} from '../discovery/index.ts';
+import {KubernetesConfig} from './KubernetesConfig.ts';
+import {KubernetesApiEndpointResolver} from './KubernetesApiEndpointResolver.ts';
+import {KubernetesEndpointResolver} from './KubernetesEndpointResolver.ts';
+import {type ClusterTopologyIntentTracker} from '../instance/ClusterTopologyIntentTracker.ts';
+import {type Logger} from '../logging.ts';
+
+export class KubernetesDiscoveryStrategy implements DiscoveryStrategy {
+    private readonly logger: Logger;
+    private readonly endpointResolver: KubernetesEndpointResolver;
+
+    constructor(logger: Logger, properties: {[key: string]: string | number | boolean}, intentTracker?: ClusterTopologyIntentTracker) {
+        this.logger = logger;
+        const config = new KubernetesConfig(properties);
+        this.logger.info(`${config}`);
+        this.endpointResolver = KubernetesApiEndpointResolver.of(this.logger, config, intentTracker);
+        this.logger.info(`Kubernetes Discovery activated with mode: ${config.mode}`);
+    }
+    async start() {
+        await this.endpointResolver.start();
+    }
+
+    async discover(): Promise<Iterable<DiscoveryNode> | undefined> {
+        return undefined
+    }
+
+    async close() {
+        await this.endpointResolver.close();
+    }
+}

package/src/kubernetes/KubernetesDiscoveryStrategyFactory.ts

@@ -0,0 +1,71 @@
+import {type DiscoveryNode, type DiscoveryStrategyFactory, DiscoveryStrategyPriorities} from '../discovery/index.ts';
+import {stat} from 'node:fs/promises';
+import {lookup} from 'node:dns/promises'
+import {KubernetesDiscoveryStrategy} from './KubernetesDiscoveryStrategy.ts';
+import type {Properties, PropertyDefinition} from '../config/Properties.ts';
+import {
+    EXPOSE_EXTERNALLY, KUBERNETES_API_TOKEN,
+    KUBERNETES_MASTER_URL,
+    NAMESPACE, POD_LABEL_NAME, POD_LABEL_VALUE, RESOLVE_NOT_READY_ADDRESSES,
+    SERVICE_DNS,
+    SERVICE_LABEL_NAME,
+    SERVICE_LABEL_VALUE,
+    SERVICE_NAME, SERVICE_PORT
+} from './KubernetesProperties.ts';
+import {type ClusterTopologyIntentTracker} from '../instance/ClusterTopologyIntentTracker.ts';
+import {type Logger} from '../logging.ts';
+
+const PROPERTY_DEFINITIONS: ReadonlyArray<PropertyDefinition> = [
+    SERVICE_DNS,
+    SERVICE_NAME,
+    SERVICE_LABEL_NAME,
+    SERVICE_LABEL_VALUE,
+    NAMESPACE,
+    POD_LABEL_NAME,
+    POD_LABEL_VALUE,
+    RESOLVE_NOT_READY_ADDRESSES,
+    EXPOSE_EXTERNALLY,
+    KUBERNETES_MASTER_URL,
+    KUBERNETES_API_TOKEN,
+    SERVICE_PORT
+];
+
+export class KubernetesDiscoveryStrategyFactory implements DiscoveryStrategyFactory {
+    private readonly tokenPath: string;
+    readonly priority = DiscoveryStrategyPriorities.PLATFORM;
+    constructor(tokenPath = '/var/run/secrets/kubernetes.io/serviceaccount/token') {
+        this.tokenPath = tokenPath;
+    }
+
+    private async defaultKubernetesMasterReachable() {
+        try {
+            await lookup('kubernetes.default.svc');
+            return true;
+        } catch (e) {
+            // todo log that io.Bridge running on Kubernetes, but "kubernetes.default.svc" is not reachable.
+            return false;
+        }
+    }
+
+    async tokenFileExists(){
+        try {
+            await stat(this.tokenPath);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async isAutoDetectionApplicable() {
+        return await this.tokenFileExists() && await this.defaultKubernetesMasterReachable()
+    }
+
+    newDiscoveryStrategy(node: DiscoveryNode | undefined, logger: Logger, properties: Properties) {
+        const tracker = node?.properties.get("internal.discovery.cluster.topology.intent.tracker");
+        return new KubernetesDiscoveryStrategy(logger, properties, tracker as ClusterTopologyIntentTracker | undefined);
+    }
+
+    getConfigurationProperties(): ReadonlyArray<PropertyDefinition> {
+        return PROPERTY_DEFINITIONS;
+    }
+}

package/src/kubernetes/KubernetesEndpointResolver.ts

@@ -0,0 +1,43 @@
+import {type DiscoveryNode} from '../discovery/index.ts';
+import {getByName} from '../utils/network.ts';
+import type {Logger} from '../logging.ts';
+
+const DNS_RETRY = 5;
+
+export abstract class KubernetesEndpointResolver {
+    protected readonly logger: Logger;
+    constructor(logger: Logger) {
+        this.logger = logger;
+    }
+    async start() {
+        // do nothing
+    }
+
+    abstract resolve(): Promise<DiscoveryNode[]>
+
+    async close() {
+        // do nothing
+    }
+
+    protected async mapAddress(address?: string) {
+        if (!address) {
+            return;
+        }
+
+        try {
+            let retry = 0;
+            try {
+                return await getByName(address);
+            } catch (e) {
+                if (retry < DNS_RETRY) {
+                    retry++;
+                } else {
+                    throw e;
+                }
+            }
+        } catch (e) {
+            // todo log address cloud not be resolved
+        }
+
+    }
+}

package/src/kubernetes/KubernetesProperties.ts

@@ -0,0 +1,22 @@
+import {BOOLEAN, NUMBER, property, STRING} from '../config/Properties.ts';
+
+export const KUBERNETES_ENV_PREFIX = 'io.bridge.kubernetes';
+
+
+
+
+export const SERVICE_DNS = property<string>('service-dns', STRING);
+export const SERVICE_NAME = property<string>('service-name', STRING);
+export const SERVICE_LABEL_NAME = property<string>('service-label-name', STRING);
+export const SERVICE_LABEL_VALUE = property<string>('service-label-value', STRING);
+export const NAMESPACE = property<string>('namespace', STRING);
+export const POD_LABEL_NAME = property<string>('pod-label-name', STRING);
+export const POD_LABEL_VALUE = property<string>('pod-label-value', STRING);
+export const EXPOSE_EXTERNALLY = property<boolean>('expose-externally', BOOLEAN);
+export const SERVICE_PER_POD_LABEL_NAME = property<string>('service-per-pod-label-name', STRING);
+export const SERVICE_PER_POD_LABEL_VALUE = property<string>('service-per-pod-label-value', STRING);
+export const RESOLVE_NOT_READY_ADDRESSES = property<boolean>('resolve-not-ready-addresses', BOOLEAN);
+
+export const KUBERNETES_MASTER_URL = property<string>('kubernetes-master', STRING);
+export const KUBERNETES_API_TOKEN = property<string>('api-token', STRING);
+export const SERVICE_PORT = property<number>('service-port', NUMBER);

package/src/license/BridgeLicenseValidator.ts

@@ -0,0 +1,19 @@
+import type {Logger} from "../logging.ts";
+import {LicenseValidator} from "./LicenseValidator.ts";
+
+const validationKey = `-----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyyZrtwcQCMfyOkZDcjxZ
++07BrvgcAvoQETF+ho8VLfaDxgNPZd6Q7jZEfrtv0+wn0pxx8pUDeBh8mCYvkwmb
+9tkFH47GJuDhWasNgyp4ugRX4bzoPV3SnHsBR4KJ/F76kBbike6sdIfO2lYGZ36s
+LJPHV7epOYsfhoc4343/vOxEPvNbwacbXWl4NsCGev4qUmWhe9iMpb/JPd3o4hIU
+SR31AmR2xoh3BkAJc2q/cSeQK6Kn9nZYocyW367+7FOvYsrOYotsuUASp0OWp+Lh
+WGfR7F6d016+u6kbvLvcceGztiP1u25QmPNCUmw49cTatthiEwwGHb01CR58mStZ
+xg5t9+N7X9hPO2K59b8EbOnnFTlwtMMF7MKR56S4YwMamCChr9WGgpOQV+lrqyx2
+yn9lwn8Yf4gLoLPKBEhHTEy6r/we9qymmlSSe4wr5Fctov2odSE535nvtdRYZkKk
+t32gOXuwnKg2kRlRSAErpyou1mz7/mWEt1H3sGTRArjNTP2KqZkc14vPToEEJt93
+ZKjhD1pVEchDiWBOMj9o12pq80tGZ8PhGJasJVVi0JPUiaznG4r12JdyDAjuXMru
+6f4Tx0ULkdwn9ia7lchcq7xC2PlTnYz+fGpfU7V0Ci56QDTp6oP567L1EIeddkaI
+nIsi4KHT7Ctp047FTTelntUCAwEAAQ==
+-----END PUBLIC KEY-----`;
+
+export const BridgeLicenseValidator = (logger: Logger) => new LicenseValidator({validationKey, logger});