@kapeta/local-cluster-service 0.40.6 → 0.41.1

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.41.1](https://github.com/kapetacom/local-cluster-service/compare/v0.41.0...v0.41.1) (2024-04-16)
+
+
+### Bug Fixes
+
+* better missing file handling [CORE-2685] ([1baf002](https://github.com/kapetacom/local-cluster-service/commit/1baf002c18c6acc92a4f6ca1bff37cda9270e487))
+* bump local-cluster-config w/ improved error handling ([f9a945f](https://github.com/kapetacom/local-cluster-service/commit/f9a945f7761e472e45bc55839b40e563c5298719))
+
+# [0.41.0](https://github.com/kapetacom/local-cluster-service/compare/v0.40.6...v0.41.0) (2024-04-12)
+
+
+### Bug Fixes
+
+* review comments ([c0b75a0](https://github.com/kapetacom/local-cluster-service/commit/c0b75a08994c0505f4598327547ccd2199efa94a))
+
+
+### Features
+
+* append connected block operator specific env to blocks ([a003c4f](https://github.com/kapetacom/local-cluster-service/commit/a003c4fdb98706aebbc6bc8ae28cf9cc6e7ba9cf))
+
 ## [0.40.6](https://github.com/kapetacom/local-cluster-service/compare/v0.40.5...v0.40.6) (2024-04-11)
 
 

package/dist/cjs/src/assetManager.js

@@ -25,10 +25,17 @@ const node_os_1 = __importDefault(require("node:os"));
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
 const UPGRADE_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
 const toKey = (ref) => `assetManager:asset:${ref}`;
-function filterExists(asset) {
-    return fs_extra_1.default.existsSync(asset.path) && fs_extra_1.default.existsSync(asset.ymlPath);
-}
 function enrichAsset(asset) {
+    let exists = true;
+    let path = asset.path;
+    let ymlPath = asset.ymlPath;
+    try {
+        path = fs_extra_1.default.realpathSync(path);
+        ymlPath = fs_extra_1.default.realpathSync(ymlPath);
+    }
+    catch (e) {
+        exists = false;
+    }
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
         editable: asset.version === 'local', //Only local versions are editable
@@ -36,8 +43,8 @@ function enrichAsset(asset) {
         version: asset.version,
         kind: asset.definition.kind,
         data: asset.definition,
-        path: fs_extra_1.default.realpathSync(asset.path),
-        ymlPath: fs_extra_1.default.realpathSync(asset.ymlPath),
+        path,
+        ymlPath,
     };
 }
 function compareRefs(a, b) {
@@ -86,7 +93,7 @@ class AssetManager {
             assetKinds.push('core/plan');
         }
         const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
-        return assets.filter(filterExists).map(enrichAsset);
+        return assets.map(enrichAsset).filter((a) => a.exists);
     }
     async getPlans() {
         return this.getAssets(['core/plan']);
@@ -124,9 +131,14 @@ class AssetManager {
             throw new Error('Asset not found: ' + ref);
         }
         if (definitionInfo) {
-            const asset = enrichAsset(definitionInfo);
-            cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
-            return asset;
+            try {
+                const asset = enrichAsset(definitionInfo);
+                cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+                return asset;
+            }
+            catch (e) {
+                console.error('Failed to enrich asset', e);
+            }
         }
         return undefined;
     }

package/dist/cjs/src/utils/BlockInstanceRunner.d.ts

@@ -26,4 +26,5 @@ export declare class BlockInstanceRunner {
     private ensureContainer;
     private _handleContainer;
     private getFileHash;
+    private appendConnectedBlockOperatorEnv;
 }

package/dist/cjs/src/utils/BlockInstanceRunner.js

@@ -114,7 +114,8 @@ class BlockInstanceRunner {
         const realBaseDir = await fs_extra_1.default.realpath(baseDir);
         const internalConfigProvider = await (0, InternalConfigProvider_1.createInternalConfigProvider)(this._systemId, blockInstance.id, assetVersion);
         // Resolve the environment variables
-        const variables = await (0, config_mapper_1.resolveKapetaVariables)(realBaseDir, internalConfigProvider);
+        const blockVariables = await (0, config_mapper_1.resolveKapetaVariables)(realBaseDir, internalConfigProvider);
+        const variables = await this.appendConnectedBlockOperatorEnv(internalConfigProvider, blockInstance, blockVariables);
         // Write out the config templates if they exist
         await (0, config_mapper_1.writeConfigTemplates)(variables, realBaseDir);
         const env = await (0, config_mapper_1.getEnvironmentVariables)(variables);
@@ -409,6 +410,7 @@ class BlockInstanceRunner {
                     PortBindings,
                     Mounts,
                 },
+                Cmd: local.cmd,
                 Labels: {
                     ...labels,
                     instance: operatorId,
@@ -480,5 +482,39 @@ class BlockInstanceRunner {
         //Creating the hash in the required format
         return data.digest('hex');
     }
+    async appendConnectedBlockOperatorEnv(internalConfigProvider, blockInstance, variables) {
+        const plan = await internalConfigProvider.getPlan();
+        const connectedBlockIds = [
+            ...new Set(plan.spec.connections
+                .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);
+            if (!connectedBlockInstance) {
+                continue;
+            }
+            const connectedBlockDefinition = await internalConfigProvider.getBlock(connectedBlockInstance?.block.ref);
+            const connectedBlockDefinitionInfo = await getProvider((0, nodejs_utils_1.parseKapetaUri)(connectedBlockDefinition.kind));
+            const local = connectedBlockDefinitionInfo?.definition.spec.local;
+            if (!local || !local.addEnv) {
+                continue;
+            }
+            const connectedBlockInstanceOperator = await internalConfigProvider.getInstanceOperator(connectedBlockId);
+            for (const addEnv of local.addEnv) {
+                var result;
+                try {
+                    result = eval(addEnv)(connectedBlockInstanceOperator);
+                }
+                catch (error) {
+                    result = addEnv;
+                }
+                const parts = result.split('=');
+                variables[parts[0]] = { type: config_mapper_1.VariableType.ENV, value: parts[1], json: false };
+            }
+        }
+        return variables;
+    }
 }
 exports.BlockInstanceRunner = BlockInstanceRunner;

package/dist/esm/src/assetManager.js

@@ -25,10 +25,17 @@ const node_os_1 = __importDefault(require("node:os"));
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
 const UPGRADE_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
 const toKey = (ref) => `assetManager:asset:${ref}`;
-function filterExists(asset) {
-    return fs_extra_1.default.existsSync(asset.path) && fs_extra_1.default.existsSync(asset.ymlPath);
-}
 function enrichAsset(asset) {
+    let exists = true;
+    let path = asset.path;
+    let ymlPath = asset.ymlPath;
+    try {
+        path = fs_extra_1.default.realpathSync(path);
+        ymlPath = fs_extra_1.default.realpathSync(ymlPath);
+    }
+    catch (e) {
+        exists = false;
+    }
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
         editable: asset.version === 'local', //Only local versions are editable
@@ -36,8 +43,8 @@ function enrichAsset(asset) {
         version: asset.version,
         kind: asset.definition.kind,
         data: asset.definition,
-        path: fs_extra_1.default.realpathSync(asset.path),
-        ymlPath: fs_extra_1.default.realpathSync(asset.ymlPath),
+        path,
+        ymlPath,
     };
 }
 function compareRefs(a, b) {
@@ -86,7 +93,7 @@ class AssetManager {
             assetKinds.push('core/plan');
         }
         const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
-        return assets.filter(filterExists).map(enrichAsset);
+        return assets.map(enrichAsset).filter((a) => a.exists);
     }
     async getPlans() {
         return this.getAssets(['core/plan']);
@@ -124,9 +131,14 @@ class AssetManager {
             throw new Error('Asset not found: ' + ref);
         }
         if (definitionInfo) {
-            const asset = enrichAsset(definitionInfo);
-            cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
-            return asset;
+            try {
+                const asset = enrichAsset(definitionInfo);
+                cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+                return asset;
+            }
+            catch (e) {
+                console.error('Failed to enrich asset', e);
+            }
         }
         return undefined;
     }

package/dist/esm/src/utils/BlockInstanceRunner.d.ts

@@ -26,4 +26,5 @@ export declare class BlockInstanceRunner {
     private ensureContainer;
     private _handleContainer;
     private getFileHash;
+    private appendConnectedBlockOperatorEnv;
 }

package/dist/esm/src/utils/BlockInstanceRunner.js

@@ -114,7 +114,8 @@ class BlockInstanceRunner {
         const realBaseDir = await fs_extra_1.default.realpath(baseDir);
         const internalConfigProvider = await (0, InternalConfigProvider_1.createInternalConfigProvider)(this._systemId, blockInstance.id, assetVersion);
         // Resolve the environment variables
-        const variables = await (0, config_mapper_1.resolveKapetaVariables)(realBaseDir, internalConfigProvider);
+        const blockVariables = await (0, config_mapper_1.resolveKapetaVariables)(realBaseDir, internalConfigProvider);
+        const variables = await this.appendConnectedBlockOperatorEnv(internalConfigProvider, blockInstance, blockVariables);
         // Write out the config templates if they exist
         await (0, config_mapper_1.writeConfigTemplates)(variables, realBaseDir);
         const env = await (0, config_mapper_1.getEnvironmentVariables)(variables);
@@ -409,6 +410,7 @@ class BlockInstanceRunner {
                     PortBindings,
                     Mounts,
                 },
+                Cmd: local.cmd,
                 Labels: {
                     ...labels,
                     instance: operatorId,
@@ -480,5 +482,39 @@ class BlockInstanceRunner {
         //Creating the hash in the required format
         return data.digest('hex');
     }
+    async appendConnectedBlockOperatorEnv(internalConfigProvider, blockInstance, variables) {
+        const plan = await internalConfigProvider.getPlan();
+        const connectedBlockIds = [
+            ...new Set(plan.spec.connections
+                .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);
+            if (!connectedBlockInstance) {
+                continue;
+            }
+            const connectedBlockDefinition = await internalConfigProvider.getBlock(connectedBlockInstance?.block.ref);
+            const connectedBlockDefinitionInfo = await getProvider((0, nodejs_utils_1.parseKapetaUri)(connectedBlockDefinition.kind));
+            const local = connectedBlockDefinitionInfo?.definition.spec.local;
+            if (!local || !local.addEnv) {
+                continue;
+            }
+            const connectedBlockInstanceOperator = await internalConfigProvider.getInstanceOperator(connectedBlockId);
+            for (const addEnv of local.addEnv) {
+                var result;
+                try {
+                    result = eval(addEnv)(connectedBlockInstanceOperator);
+                }
+                catch (error) {
+                    result = addEnv;
+                }
+                const parts = result.split('=');
+                variables[parts[0]] = { type: config_mapper_1.VariableType.ENV, value: parts[1], json: false };
+            }
+        }
+        return variables;
+    }
 }
 exports.BlockInstanceRunner = BlockInstanceRunner;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.40.6",
+    "version": "0.41.1",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -50,7 +50,7 @@
     "dependencies": {
         "@kapeta/codegen": "^1.3.0",
         "@kapeta/config-mapper": "^1.2.0",
-        "@kapeta/local-cluster-config": "^0.4.1",
+        "@kapeta/local-cluster-config": "^0.4.2",
         "@kapeta/nodejs-api-client": ">=0.2.0 <2",
         "@kapeta/nodejs-process": "^1.2.0",
         "@kapeta/nodejs-registry-utils": ">=0.11.1 <2",

package/src/assetManager.ts

@@ -36,11 +36,16 @@ export interface EnrichedAsset {
     ymlPath: string;
 }
 
-function filterExists(asset: DefinitionInfo): boolean {
-    return FS.existsSync(asset.path) && FS.existsSync(asset.ymlPath);
-}
-
 function enrichAsset(asset: DefinitionInfo): EnrichedAsset {
+    let exists = true;
+    let path = asset.path;
+    let ymlPath = asset.ymlPath;
+    try {
+        path = FS.realpathSync(path);
+        ymlPath = FS.realpathSync(ymlPath);
+    } catch (e) {
+        exists = false;
+    }
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
         editable: asset.version === 'local', //Only local versions are editable
@@ -48,8 +53,8 @@ function enrichAsset(asset: DefinitionInfo): EnrichedAsset {
         version: asset.version,
         kind: asset.definition.kind,
         data: asset.definition,
-        path: FS.realpathSync(asset.path),
-        ymlPath: FS.realpathSync(asset.ymlPath),
+        path,
+        ymlPath,
     };
 }
 
@@ -106,7 +111,7 @@ class AssetManager {
 
         const assets = await definitionsManager.getDefinitions(assetKinds);
 
-        return assets.filter(filterExists).map(enrichAsset);
+        return assets.map(enrichAsset).filter((a) => a.exists);
     }
 
     async getPlans(): Promise<EnrichedAsset[]> {
@@ -159,9 +164,13 @@ class AssetManager {
         }
 
         if (definitionInfo) {
-            const asset = enrichAsset(definitionInfo);
-            cacheManager.set(cacheKey, asset, CACHE_TTL);
-            return asset;
+            try {
+                const asset = enrichAsset(definitionInfo);
+                cacheManager.set(cacheKey, asset, CACHE_TTL);
+                return asset;
+            } catch (e) {
+                console.error('Failed to enrich asset', e);
+            }
         }
 
         return undefined;

package/src/utils/BlockInstanceRunner.ts

@@ -33,13 +33,15 @@ 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 { createInternalConfigProvider, InternalConfigProvider } from './InternalConfigProvider';
 import {
     getConfigFilePath,
     getEnvironmentVariables,
     KAPETA_CONFIG_ENV_VAR,
     KAPETA_ENV_CONFIG_FILE,
     resolveKapetaVariables,
+    Variables,
+    VariableType,
     writeConfigTemplates,
     writeEnvConfigFile,
 } from '@kapeta/config-mapper';
@@ -157,7 +159,12 @@ export class BlockInstanceRunner {
         );
 
         // Resolve the environment variables
-        const variables = await resolveKapetaVariables(realBaseDir, internalConfigProvider);
+        const blockVariables = await resolveKapetaVariables(realBaseDir, internalConfigProvider);
+        const variables = await this.appendConnectedBlockOperatorEnv(
+            internalConfigProvider,
+            blockInstance,
+            blockVariables
+        );
 
         // Write out the config templates if they exist
         await writeConfigTemplates(variables, realBaseDir);
@@ -556,6 +563,7 @@ export class BlockInstanceRunner {
                         PortBindings,
                         Mounts,
                     },
+                    Cmd: local.cmd,
                     Labels: {
                         ...labels,
                         instance: operatorId,
@@ -645,4 +653,52 @@ export class BlockInstanceRunner {
         //Creating the hash in the required format
         return data.digest('hex');
     }
+
+    private async appendConnectedBlockOperatorEnv(
+        internalConfigProvider: InternalConfigProvider,
+        blockInstance: BlockProcessParams,
+        variables: Variables
+    ): Promise<Variables> {
+        const plan = await internalConfigProvider.getPlan();
+
+        const connectedBlockIds = [
+            ...new Set(
+                plan.spec.connections
+                    .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);
+            if (!connectedBlockInstance) {
+                continue;
+            }
+
+            const connectedBlockDefinition = await internalConfigProvider.getBlock(connectedBlockInstance?.block.ref);
+            const connectedBlockDefinitionInfo = await getProvider(parseKapetaUri(connectedBlockDefinition.kind));
+
+            const local = connectedBlockDefinitionInfo?.definition.spec.local;
+
+            if (!local || !local.addEnv) {
+                continue;
+            }
+
+            const connectedBlockInstanceOperator = await internalConfigProvider.getInstanceOperator(connectedBlockId);
+
+            for (const addEnv of local.addEnv) {
+                var result: string;
+                try {
+                    result = eval(addEnv)(connectedBlockInstanceOperator) as string;
+                } catch (error) {
+                    result = addEnv;
+                }
+                const parts = result.split('=');
+                variables[parts[0]] = { type: VariableType.ENV, value: parts[1], json: false };
+            }
+        }
+
+        return variables;
+    }
 }