@kapeta/local-cluster-service 0.41.0 → 0.42.0

package/src/utils/BlockInstanceRunner.ts

@@ -5,8 +5,8 @@
 
 import FSExtra from 'fs-extra';
 import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { getDockerHostIp, getBlockInstanceContainerName, getOperatorInstancePorts, readYML, toPortInfo } from './utils';
-import { KapetaURI, parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
+import { getBlockInstanceContainerName, getDockerHostIp, getOperatorInstancePorts, readYML } from './utils';
+import { KapetaURI, normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { DEFAULT_PORT_TYPE, HTTP_PORT_TYPE, HTTP_PORTS, serviceManager } from '../serviceManager';
 import {
     COMPOSE_LABEL_PROJECT,
@@ -32,7 +32,7 @@ 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 { EntityList, EntityType, LocalDevContainer, LocalInstance } from '@kapeta/schemas';
 import { createInternalConfigProvider, InternalConfigProvider } from './InternalConfigProvider';
 import {
     getConfigFilePath,
@@ -46,6 +46,8 @@ import {
     writeEnvConfigFile,
 } from '@kapeta/config-mapper';
 import crypto from 'crypto';
+import { configManager } from '../configManager';
+import _ from 'lodash';
 
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -121,11 +123,10 @@ export class BlockInstanceRunner {
      * Start a block
      *
      */
-    async start(blockRef: string, instanceId: string, configuration: AnyMap): Promise<ProcessInfo> {
+    async start(blockRef: string, instanceId: string): Promise<ProcessInfo> {
         return this._execute({
             ref: blockRef,
             id: instanceId,
-            configuration,
         });
     }
 
@@ -152,10 +153,18 @@ export class BlockInstanceRunner {
 
         const baseDir = ClusterConfig.getRepositoryAssetPath(blockUri.handle, blockUri.name, blockUri.version);
         const realBaseDir = await FSExtra.realpath(baseDir);
+
+        const config = await configManager.getConfigForBlockInstance(this._systemId, blockInstance.id);
+        const configSchema = (
+            assetVersion.definition.spec.configuration ? assetVersion.definition.spec.configuration : {}
+        ) as EntityList;
+        const fileMapping = configManager.rewriteFilePaths(configSchema, config);
+
         const internalConfigProvider = await createInternalConfigProvider(
             this._systemId,
             blockInstance.id,
-            assetVersion
+            assetVersion,
+            config
         );
 
         // Resolve the environment variables
@@ -189,9 +198,9 @@ export class BlockInstanceRunner {
             const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
 
             if (blockUri.version === 'local') {
-                processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion, fileMapping);
             } else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion, fileMapping);
             }
 
             if (portTypes.length > 0) {
@@ -209,7 +218,8 @@ export class BlockInstanceRunner {
         blockInstance: BlockProcessParams,
         blockInfo: KapetaURI,
         env: StringMap,
-        assetVersion: DefinitionInfo
+        assetVersion: DefinitionInfo,
+        fileMapping: StringMap
     ): Promise<ProcessInfo> {
         const baseDir = ClusterConfig.getRepositoryAssetPath(blockInfo.handle, blockInfo.name, blockInfo.version);
 
@@ -299,14 +309,7 @@ export class BlockInstanceRunner {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
 
-        if (env[KAPETA_CONFIG_ENV_VAR]) {
-            // If we have a config file, we need to bind it to the container and adjust the env var
-            const localConfig = `/${KAPETA_ENV_CONFIG_FILE}`;
-            Binds.push(`${toLocalBindVolume(env[KAPETA_CONFIG_ENV_VAR])}:${localConfig}:ro`);
-            // We also provide the hash to detect changes to the config file
-            env['KAPETA_CONFIG_HASH'] = await this.getFileHash(env[KAPETA_CONFIG_ENV_VAR]);
-            env[KAPETA_CONFIG_ENV_VAR] = localConfig;
-        }
+        await this.prepareBinds(env, Binds, fileMapping);
 
         const Mounts = isDockerImage
             ? // For docker images we mount the local directory to the working directory
@@ -366,11 +369,29 @@ export class BlockInstanceRunner {
         });
     }
 
+    private async prepareBinds(env: StringMap, Binds: string[], fileMapping: StringMap) {
+        if (env[KAPETA_CONFIG_ENV_VAR]) {
+            // If we have a config file, we need to bind it to the container and adjust the env var
+            const localConfig = `/${KAPETA_ENV_CONFIG_FILE}`;
+            Binds.push(`${toLocalBindVolume(env[KAPETA_CONFIG_ENV_VAR])}:${localConfig}:ro`);
+            // We also provide the hash to detect changes to the config file
+            env['KAPETA_CONFIG_HASH'] = await this.getFileHash(env[KAPETA_CONFIG_ENV_VAR]);
+            env[KAPETA_CONFIG_ENV_VAR] = localConfig;
+        }
+
+        if (fileMapping) {
+            Object.entries(fileMapping).forEach(([src, dst]) => {
+                Binds.push(`${toLocalBindVolume(src)}:${dst}:ro`);
+            });
+        }
+    }
+
     private async _startDockerProcess(
         blockInstance: BlockProcessParams,
         blockInfo: KapetaURI,
         env: StringMap,
-        assetVersion: DefinitionInfo
+        assetVersion: DefinitionInfo,
+        fileMapping: StringMap
     ) {
         const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(
             blockInfo.handle,
@@ -414,14 +435,7 @@ export class BlockInstanceRunner {
         const systemUri = parseKapetaUri(this._systemId);
 
         const Binds = [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`];
-        if (env[KAPETA_CONFIG_ENV_VAR]) {
-            // If we have a config file, we need to bind it to the container and adjust the env var
-            const localConfig = `/${KAPETA_ENV_CONFIG_FILE}`;
-            Binds.push(`${toLocalBindVolume(env[KAPETA_CONFIG_ENV_VAR])}:${localConfig}:ro`);
-            // We also provide the hash to detect changes to the config file
-            env['KAPETA_CONFIG_HASH'] = await this.getFileHash(env[KAPETA_CONFIG_ENV_VAR]);
-            env[KAPETA_CONFIG_ENV_VAR] = localConfig;
-        }
+        await this.prepareBinds(env, Binds, fileMapping);
 
         return this.ensureContainer({
             Image: dockerImage,
@@ -664,14 +678,20 @@ export class BlockInstanceRunner {
         const connectedBlockIds = [
             ...new Set(
                 plan.spec.connections
-                    .filter((connection) => connection.provider.blockId == blockInstance.id || connection.consumer.blockId == blockInstance.id)
+                    .filter(
+                        (connection) =>
+                            connection.provider.blockId == blockInstance.id ||
+                            connection.consumer.blockId == blockInstance.id
+                    )
                     .flatMap((connection) => [connection.provider.blockId, connection.consumer.blockId])
                     .filter((blockId) => blockId !== blockInstance.id)
             ),
         ];
 
         for (const connectedBlockId of connectedBlockIds) {
-            const connectedBlockInstance = plan.spec.blocks.find((blockInstance) => blockInstance.id == connectedBlockId);
+            const connectedBlockInstance = plan.spec.blocks.find(
+                (blockInstance) => blockInstance.id == connectedBlockId
+            );
             if (!connectedBlockInstance) {
                 continue;
             }

package/src/utils/InternalConfigProvider.ts

@@ -207,8 +207,8 @@ export class InternalConfigProvider implements ConfigProvider {
 export async function createInternalConfigProvider(
     systemId: string,
     instanceId: string,
-    info: DefinitionInfo
+    info: DefinitionInfo,
+    config: AnyMap
 ): Promise<InternalConfigProvider> {
-    const config = await configManager.getConfigForBlockInstance(systemId, instanceId);
     return new InternalConfigProvider(systemId, instanceId, info, config);
 }