@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/kubernetes/KubernetesClient.ts

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

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

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

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

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

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

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