@kapeta/local-cluster-service 0.38.0 → 0.39.1

package/src/utils/BlockInstanceRunner.ts

@@ -5,7 +5,7 @@
 
 import FSExtra from 'fs-extra';
 import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { getBindHost, getBlockInstanceContainerName, readYML, toPortInfo } from './utils';
+import { getDockerHostIp, getBlockInstanceContainerName, getOperatorInstancePorts, readYML, toPortInfo } from './utils';
 import { KapetaURI, parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { DEFAULT_PORT_TYPE, HTTP_PORT_TYPE, HTTP_PORTS, serviceManager } from '../serviceManager';
 import {
@@ -18,13 +18,23 @@ import {
 } from '../containerManager';
 import { LogData } from './LogData';
 import { clusterService } from '../clusterService';
-import { AnyMap, BlockProcessParams, InstanceType, KIND_BLOCK_TYPE_OPERATOR, ProcessInfo, StringMap } from '../types';
+import {
+    AnyMap,
+    BlockProcessParams,
+    DOCKER_HOST_INTERNAL,
+    InstanceType,
+    KIND_BLOCK_TYPE_OPERATOR,
+    ProcessInfo,
+    StringMap,
+} from '../types';
 import { definitionsManager } from '../definitionsManager';
 import Docker from 'dockerode';
 import OS from 'node:os';
 import Path from 'node:path';
 import { taskManager } from '../taskManager';
 import { LocalDevContainer, LocalInstance } from '@kapeta/schemas';
+import { createInternalConfigProvider } from './InternalConfigProvider';
+import { resolveKapetaVariables, writeConfigTemplates } from '@kapeta/config-mapper';
 
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -36,7 +46,7 @@ const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
  */
 const DOCKER_ENV_VARS = [
     `KAPETA_LOCAL_SERVER=0.0.0.0`,
-    `KAPETA_LOCAL_CLUSTER_HOST=host.docker.internal`,
+    `KAPETA_LOCAL_CLUSTER_HOST=${DOCKER_HOST_INTERNAL}`,
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
 
@@ -105,20 +115,6 @@ export class BlockInstanceRunner {
     }
 
     private async _execute(blockInstance: BlockProcessParams): Promise<ProcessInfo> {
-        const env: StringMap = {};
-
-        if (this._systemId) {
-            env[KAPETA_SYSTEM_ID] = this._systemId;
-        }
-
-        if (blockInstance.ref) {
-            env[KAPETA_BLOCK_REF] = blockInstance.ref;
-        }
-
-        if (blockInstance.id) {
-            env[KAPETA_INSTANCE_ID] = blockInstance.id;
-        }
-
         const blockUri = parseKapetaUri(blockInstance.ref);
 
         if (!blockUri.version) {
@@ -139,18 +135,32 @@ export class BlockInstanceRunner {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
 
+        const baseDir = ClusterConfig.getRepositoryAssetPath(blockUri.handle, blockUri.name, blockUri.version);
+        const realBaseDir = await FSExtra.realpath(baseDir);
+        const internalConfigProvider = await createInternalConfigProvider(
+            this._systemId,
+            blockInstance.id,
+            assetVersion
+        );
+
+        // Resolve the environment variables
+        const envVars = await resolveKapetaVariables(realBaseDir, internalConfigProvider);
+
+        // Write out the config templates if they exist
+        await writeConfigTemplates(envVars, realBaseDir);
+
         let processInfo: ProcessInfo;
 
         if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
-            processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
+            processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, envVars);
         } else {
             //We need a port type to know how to connect to the block consistently
             const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
 
             if (blockUri.version === 'local') {
-                processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startLocalProcess(blockInstance, blockUri, envVars, assetVersion);
             } else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, envVars, assetVersion);
             }
 
             if (portTypes.length > 0) {
@@ -250,9 +260,13 @@ export class BlockInstanceRunner {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
 
-        const Mounts = containerManager.toDockerMounts({
-            [workingDir]: toLocalBindVolume(realLocalPath),
-        });
+        const Mounts = isDockerImage
+            ? // For docker images we mount the local directory to the working directory
+              containerManager.toDockerMounts({
+                  [workingDir]: toLocalBindVolume(realLocalPath),
+              })
+            : // For dockerfiles we don't mount anything
+              [];
 
         const systemUri = parseKapetaUri(this._systemId);
 
@@ -415,34 +429,30 @@ export class BlockInstanceRunner {
             `container:start:${containerName}`,
             async () => {
                 const logs = new LogData();
-
-                const bindHost = getBindHost();
+                const hostIp = getDockerHostIp();
 
                 const ExposedPorts: AnyMap = {};
                 const addonEnv: StringMap = {};
                 const PortBindings: AnyMap = {};
                 let HealthCheck = undefined;
                 let Mounts: DockerMounts[] = [];
-                const localPorts = local.ports ?? {};
+                const instancePorts = await getOperatorInstancePorts(this._systemId, operatorId, local);
                 const labels: { [key: string]: string } = {};
-                const promises = Object.entries(localPorts).map(async ([portType, value]) => {
-                    const portInfo = toPortInfo(value);
-                    const dockerPort = `${portInfo.port}/${portInfo.type}`;
+                instancePorts.forEach((portInfo) => {
+                    const dockerPort = `${portInfo.port}/${portInfo.protocol}`;
                     ExposedPorts[dockerPort] = {};
-                    addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
-                    const publicPort = await serviceManager.ensureServicePort(this._systemId, operatorId, portType);
+                    addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portInfo.portType.toUpperCase()}`] = `${portInfo.port}`;
+
                     PortBindings[dockerPort] = [
                         {
-                            HostIp: bindHost,
-                            HostPort: `${publicPort}`,
+                            HostIp: hostIp,
+                            HostPort: `${portInfo.hostPort}`,
                         },
                     ];
 
-                    labels[CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
+                    labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.portType;
                 });
 
-                await Promise.all(promises);
-
                 if (local.env) {
                     Object.entries(local.env).forEach(([key, value]) => {
                         addonEnv[key] = value as string;
@@ -525,7 +535,7 @@ export class BlockInstanceRunner {
         assetVersion: DefinitionInfo,
         providerVersion: DefinitionInfo
     ) {
-        const bindHost = getBindHost();
+        const hostIp = getDockerHostIp();
         const ExposedPorts: AnyMap = {};
         const addonEnv: StringMap = {};
         const PortBindings: AnyMap = {};
@@ -541,7 +551,7 @@ export class BlockInstanceRunner {
 
             PortBindings[dockerPort] = [
                 {
-                    HostIp: bindHost,
+                    HostIp: hostIp,
                     HostPort: `${publicPort}`,
                 },
             ];

package/src/utils/InternalConfigProvider.ts

@@ -0,0 +1,214 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import {
+    BlockInstanceDetails,
+    ConfigProvider,
+    DefaultCredentials,
+    DefaultResourceOptions,
+    InstanceOperator,
+    ResourceInfo,
+} from '@kapeta/sdk-config';
+import { Definition, DefinitionInfo } from '@kapeta/local-cluster-config';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { configManager } from '../configManager';
+import { AnyMap, EnvironmentType } from '../types';
+import _ from 'lodash';
+import { serviceManager } from '../serviceManager';
+import { operatorManager } from '../operatorManager';
+import { instanceManager } from '../instanceManager';
+import { definitionsManager } from '../definitionsManager';
+import { getBindAddressForEnvironment } from './utils';
+
+/**
+ * A configuration provider that does the same as the LocalConfigProvider
+ * but without calling the API of the local cluster service (since it's running in the same process)
+ */
+export class InternalConfigProvider implements ConfigProvider {
+    private readonly info: DefinitionInfo;
+    private readonly systemId: string;
+    private readonly instanceId: string;
+    private readonly config: AnyMap;
+    private readonly environment: EnvironmentType;
+
+    constructor(
+        systemId: string,
+        instanceId: string,
+        info: DefinitionInfo,
+        config: AnyMap,
+        environment: EnvironmentType = 'docker'
+    ) {
+        this.info = info;
+        this.systemId = normalizeKapetaUri(systemId);
+        this.instanceId = instanceId;
+        this.config = config;
+        this.environment = environment;
+    }
+
+    getBlockDefinition() {
+        return this.info.definition;
+    }
+    getBlockReference(): string {
+        return normalizeKapetaUri(this.info.definition.metadata.name + ':' + this.info.version);
+    }
+    getSystemId(): string {
+        return this.systemId;
+    }
+    getInstanceId(): string {
+        return this.instanceId;
+    }
+    getServerPort(portType?: string | undefined): Promise<string> {
+        return serviceManager.ensureServicePort(this.systemId, this.instanceId, portType);
+    }
+    async getServiceAddress(serviceName: string, portType: string): Promise<string | null> {
+        return serviceManager.getConsumerAddress(
+            this.systemId,
+            this.instanceId,
+            serviceName,
+            portType,
+            this.environment
+        );
+    }
+    getResourceInfo<Options = DefaultResourceOptions, Credentials = DefaultCredentials>(
+        resourceType: string,
+        portType: string,
+        resourceName: string
+    ): Promise<ResourceInfo<Options, Credentials> | null> {
+        return operatorManager.getConsumerResourceInfo(
+            this.systemId,
+            this.instanceId,
+            resourceType,
+            portType,
+            resourceName,
+            this.environment,
+            false
+        );
+    }
+    async getInstanceHost(instanceId: string): Promise<string | null> {
+        const instance = instanceManager.getInstance(this.systemId, instanceId);
+        return instance?.address ?? null;
+    }
+    async getServerHost(): Promise<string> {
+        return getBindAddressForEnvironment(this.environment);
+    }
+    getProviderId(): string {
+        return 'internal';
+    }
+    getOrDefault<T = any>(path: string, defaultValue: T): T {
+        return this.get(path) ?? defaultValue;
+    }
+    get<T = any>(path: string): T | undefined {
+        return _.get(this.config, path);
+    }
+
+    getInstanceOperator<Options = any, Credentials extends DefaultCredentials = DefaultCredentials>(
+        instanceId: string
+    ): Promise<InstanceOperator<Options, Credentials> | null> {
+        return instanceManager.getInstanceOperator(this.systemId, instanceId, this.environment, false);
+    }
+
+    public async getInstanceForConsumer<BlockType = BlockDefinition>(
+        resourceName: string
+    ): Promise<BlockInstanceDetails<BlockType> | null> {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+        const connection = plan.spec.connections.find(
+            (connection) =>
+                connection.consumer.blockId === instanceId && connection.consumer.resourceName === resourceName
+        );
+
+        if (!connection) {
+            throw new Error(`Could not find connection for consumer ${resourceName}`);
+        }
+
+        const instance = plan.spec.blocks.find((b) => b.id === connection.provider.blockId);
+
+        if (!instance) {
+            throw new Error(`Could not find instance ${connection.provider.blockId} in plan`);
+        }
+
+        const block = await this.getBlock(instance.block.ref);
+
+        if (!block) {
+            throw new Error(`Could not find block ${instance.block.ref} in plan`);
+        }
+
+        return {
+            instanceId: connection.provider.blockId,
+            connections: [connection],
+            block: block as BlockType,
+        };
+    }
+
+    public async getInstancesForProvider<BlockType = BlockDefinition>(
+        resourceName: string
+    ): Promise<BlockInstanceDetails<BlockType>[]> {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+
+        const blockDetails: { [key: string]: BlockInstanceDetails<BlockType> } = {};
+        const connections = plan.spec.connections.filter(
+            (connection) =>
+                connection.provider.blockId === instanceId && connection.provider.resourceName === resourceName
+        );
+
+        for (const connection of connections) {
+            const blockInstanceId = connection.consumer.blockId;
+            if (blockDetails[blockInstanceId]) {
+                blockDetails[blockInstanceId].connections.push(connection);
+                continue;
+            }
+
+            const instance = plan.spec.blocks.find((b) => b.id === blockInstanceId);
+            if (!instance) {
+                throw new Error(`Could not find instance ${blockInstanceId} in plan`);
+            }
+
+            const block = await this.getBlock(instance.block.ref);
+            if (!block) {
+                throw new Error(`Could not find block ${instance.block.ref} in plan`);
+            }
+
+            blockDetails[blockInstanceId] = {
+                instanceId: blockInstanceId,
+                connections: [connection],
+                block: block as BlockType,
+            };
+        }
+
+        return Object.values(blockDetails);
+    }
+
+    async getBlock(ref: any): Promise<Definition> {
+        const definition = await definitionsManager.getDefinition(ref);
+        if (!definition) {
+            throw new Error(`Could not find definition for ${ref}`);
+        }
+        return definition.definition;
+    }
+
+    async getPlan(): Promise<Plan> {
+        const definition = await definitionsManager.getDefinition(this.systemId);
+        if (!definition) {
+            throw new Error(`Could not find plan ${this.systemId}`);
+        }
+        return definition.definition as Plan;
+    }
+}
+
+export async function createInternalConfigProvider(
+    systemId: string,
+    instanceId: string,
+    info: DefinitionInfo
+): Promise<InternalConfigProvider> {
+    const config = await configManager.getConfigForBlockInstance(systemId, instanceId);
+    return new InternalConfigProvider(systemId, instanceId, info, config);
+}

package/src/utils/utils.ts

@@ -6,13 +6,15 @@
 import FS from 'node:fs';
 import YAML from 'yaml';
 import md5 from 'md5';
-import { EntityList, LocalInstancePort, LocalInstancePortType } from '@kapeta/schemas';
+import { EntityList, LocalInstance, LocalInstancePort, LocalInstancePortType } from '@kapeta/schemas';
 import _ from 'lodash';
-import { AnyMap, KIND_BLOCK_TYPE_OPERATOR } from '../types';
+import { AnyMap, DOCKER_HOST_INTERNAL, EnvironmentType, KIND_BLOCK_TYPE_OPERATOR } from '../types';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { definitionsManager } from '../definitionsManager';
 import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { assetManager } from '../assetManager';
+import { serviceManager } from '../serviceManager';
+import { clusterService } from '../clusterService';
 
 export async function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string) {
     if (!blockType) {
@@ -52,6 +54,53 @@ export function toPortInfo(port: LocalInstancePort) {
     return port;
 }
 
+export async function getOperatorInstancePorts(systemId: string, operatorId: string, local: LocalInstance) {
+    const localPorts = local.ports ?? {};
+
+    const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+        const portInfo = toPortInfo(value);
+        const hostPort = await serviceManager.ensureServicePort(systemId, operatorId, portType);
+        return {
+            portType,
+            port: portInfo.port,
+            hostPort,
+            protocol: portInfo.type,
+        };
+    });
+    return await Promise.all(promises);
+}
+
+/**
+ * Gets the hostname where all services are available - including the cluster service.
+ *
+ * For docker this is the internal docker host - otherwise it's the local machine
+ * Assumed to be the same address as the cluster service outside docker.
+ */
+export function getRemoteHostForEnvironment(environment: EnvironmentType | undefined): string {
+    return environment === 'docker' ? DOCKER_HOST_INTERNAL : clusterService.getClusterServiceHost();
+}
+
+/**
+ * Get the bind address for the given environment.
+ *
+ * Outside of docker we bind to 127.0.0.1 - inside we bind to everything (0.0.0.0)
+ */
+export function getBindAddressForEnvironment(
+    environment: EnvironmentType | undefined,
+    preferredHost = '127.0.0.1'
+): string {
+    return environment === 'docker' ? '0.0.0.0' : preferredHost;
+}
+
+/**
+ * Get the docker host IP address for port binding.
+ */
+export function getDockerHostIp(preferredHost = '127.0.0.1') {
+    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
+    // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
+    return isLinux() ? '0.0.0.0' : preferredHost;
+}
+
 export function getRemoteUrl(id: string, defautValue: string) {
     const remoteConfig = ClusterConfiguration.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;
@@ -79,12 +128,6 @@ export function isLinux() {
     return !isWindows() && !isMac();
 }
 
-export function getBindHost(preferredHost = '127.0.0.1') {
-    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
-    // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
-    return isLinux() ? '0.0.0.0' : preferredHost;
-}
-
 export function getResolvedConfiguration(entities?: EntityList, config?: AnyMap, globalConfiguration?: AnyMap): AnyMap {
     if (!entities || !globalConfiguration) {
         return config || {};