@kapeta/local-cluster-service 0.8.3 → 0.9.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.9.0](https://github.com/kapetacom/local-cluster-service/compare/v0.8.3...v0.9.0) (2023-07-24)
+
+
+### Features
+
+* Improves stability and consistency when starting blocks ([#48](https://github.com/kapetacom/local-cluster-service/issues/48)) ([87afeba](https://github.com/kapetacom/local-cluster-service/commit/87afebaa87f054865519186df61c6f51f1c2c5f0))
+
 ## [0.8.3](https://github.com/kapetacom/local-cluster-service/compare/v0.8.2...v0.8.3) (2023-07-23)
 
 

package/dist/cjs/src/assetManager.js

@@ -9,12 +9,13 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const yaml_1 = __importDefault(require("yaml"));
 const node_cache_1 = __importDefault(require("node-cache"));
-const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const codeGeneratorManager_1 = require("./codeGeneratorManager");
 const progressListener_1 = require("./progressListener");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const repositoryManager_1 = require("./repositoryManager");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const definitionsManager_1 = require("./definitionsManager");
+const utils_1 = require("./utils/utils");
 function enrichAsset(asset) {
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
@@ -53,7 +54,7 @@ class AssetManager {
      */
     getAssets(assetKinds) {
         if (!assetKinds) {
-            const blockTypeProviders = local_cluster_config_1.default.getDefinitions([
+            const blockTypeProviders = definitionsManager_1.definitionsManager.getDefinitions([
                 'core/block-type',
                 'core/block-type-operator',
             ]);
@@ -62,7 +63,7 @@ class AssetManager {
             });
             assetKinds.push('core/plan');
         }
-        const assets = local_cluster_config_1.default.getDefinitions(assetKinds);
+        const assets = definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
         return assets.map(enrichAsset);
     }
     getPlans() {
@@ -76,13 +77,15 @@ class AssetManager {
         return asset.data;
     }
     async getAsset(ref, noCache = false) {
+        ref = (0, utils_1.normalizeKapetaUri)(ref);
         const cacheKey = `getAsset:${ref}`;
         if (!noCache && this.cache.has(cacheKey)) {
             return this.cache.get(cacheKey);
         }
         const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
         await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version);
-        let asset = local_cluster_config_1.default.getDefinitions()
+        let asset = definitionsManager_1.definitionsManager
+            .getDefinitions()
             .map(enrichAsset)
             .find((a) => (0, nodejs_utils_1.parseKapetaUri)(a.ref).equals(uri));
         if (!asset) {

package/dist/cjs/src/clusterService.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clusterService = void 0;
+const utils_1 = require("./utils/utils");
 const net = require('net');
 const DEFAULT_SERVER_PORT = 35100;
 const DEFAULT_START_PORT = 40000;
@@ -108,6 +109,7 @@ class ClusterService {
      * @return {string}
      */
     getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         return `/proxy/${encodeURIComponent(systemId)}/${encodeURIComponent(consumerInstanceId)}/${encodeURIComponent(consumerResourceName)}/${encodeURIComponent(portType)}/`;
     }
 }

package/dist/cjs/src/codeGeneratorManager.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.codeGeneratorManager = void 0;
 const path_1 = __importDefault(require("path"));
 const codegen_1 = require("@kapeta/codegen");
-const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const definitionsManager_1 = require("./definitionsManager");
 const TARGET_KIND = 'core/language-target';
 const BLOCK_TYPE_KIND = 'core/block-type';
 class CodeGeneratorManager {
     async reload() {
         codegen_1.registry.reset();
-        const languageTargets = local_cluster_config_1.default.getDefinitions(TARGET_KIND);
+        const languageTargets = definitionsManager_1.definitionsManager.getDefinitions(TARGET_KIND);
         for (const languageTarget of languageTargets) {
             const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
             try {
@@ -34,7 +34,7 @@ class CodeGeneratorManager {
             //Not all block types have targets
             return false;
         }
-        const blockTypes = local_cluster_config_1.default.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypes = definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
         const blockTypeKinds = blockTypes.map((blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
         return !!(yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1);
     }

package/dist/cjs/src/config/routes.js

@@ -37,7 +37,7 @@ router.put('/instance', async (req, res) => {
         if (req.kapeta.instanceId) {
             configManager_1.configManager.setConfigForSection(req.kapeta.systemId, req.kapeta.instanceId, config);
             //Restart the instance if it is running after config change
-            await instanceManager_1.instanceManager.restartIfRunning(req.kapeta.systemId, req.kapeta.instanceId);
+            await instanceManager_1.instanceManager.restart(req.kapeta.systemId, req.kapeta.instanceId);
         }
         else {
             configManager_1.configManager.setConfigForSystem(req.kapeta.systemId, config);

package/dist/cjs/src/configManager.js

@@ -4,30 +4,36 @@ exports.configManager = void 0;
 const storageService_1 = require("./storageService");
 const assetManager_1 = require("./assetManager");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const utils_1 = require("./utils/utils");
 class ConfigManager {
     _config;
     constructor() {
         this._config = storageService_1.storageService.section('config');
     }
     _forSystem(systemId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!this._config[systemId]) {
             this._config[systemId] = {};
         }
         return this._config[systemId];
     }
     setConfigForSystem(systemId, config) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const systemConfig = config || {};
         storageService_1.storageService.put('config', systemId, systemConfig);
     }
     getConfigForSystem(systemId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         return this._forSystem(systemId);
     }
     setConfigForSection(systemId, sectionId, config) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         let systemConfig = this._forSystem(systemId);
         systemConfig[sectionId] = config || {};
         storageService_1.storageService.put('config', systemId, systemConfig);
     }
     getConfigForSection(systemId, sectionId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const systemConfig = this._forSystem(systemId);
         if (!systemConfig[sectionId]) {
             systemConfig[sectionId] = {};
@@ -51,6 +57,10 @@ class ConfigManager {
      * @returns {Promise<{systemId:string,instanceId:string}>}
      */
     async resolveIdentity(blockRef, systemId) {
+        blockRef = (0, utils_1.normalizeKapetaUri)(blockRef);
+        if (systemId) {
+            systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        }
         const planAssets = assetManager_1.assetManager.getPlans();
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
         let matchingIdentities = [];
@@ -66,7 +76,7 @@ class ConfigManager {
                 const refUri = (0, nodejs_utils_1.parseKapetaUri)(blockInstance.block.ref);
                 if (refUri.equals(blockUri)) {
                     matchingIdentities.push({
-                        systemId: planAsset.ref,
+                        systemId: (0, utils_1.normalizeKapetaUri)(planAsset.ref),
                         instanceId: blockInstance.id,
                     });
                 }
@@ -87,6 +97,8 @@ class ConfigManager {
         return matchingIdentities[0];
     }
     async verifyIdentity(blockRef, systemId, instanceId) {
+        blockRef = (0, utils_1.normalizeKapetaUri)(blockRef);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const planAssets = assetManager_1.assetManager.getPlans();
         const systemUri = systemId ? (0, nodejs_utils_1.parseKapetaUri)(systemId) : null;
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);

package/dist/cjs/src/containerManager.d.ts

@@ -17,12 +17,31 @@ export interface DockerMounts {
     ReadOnly: boolean;
     Consistency: string;
 }
+interface DockerState {
+    Status: 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
+    Running: boolean;
+    Paused: boolean;
+    Restarting: boolean;
+    OOMKilled: boolean;
+    Dead: boolean;
+    Pid: number;
+    ExitCode: number;
+    Error: string;
+    StartedAt: string;
+    FinishedAt: string;
+    Health?: {
+        Status: 'starting' | 'healthy' | 'unhealthy' | 'none';
+        FailingStreak: number;
+        Log: any[] | null;
+    };
+}
 interface Health {
     cmd: string;
     interval?: number;
     timeout?: number;
     retries?: number;
 }
+export declare const HEALTH_CHECK_TIMEOUT: number;
 declare class ContainerManager {
     private _docker;
     private _alive;
@@ -36,7 +55,7 @@ declare class ContainerManager {
     createMounts(kind: string, mountOpts: StringMap): StringMap;
     ping(): Promise<void>;
     docker(): Docker;
-    getContainerByName(containerName: string): Promise<Container | undefined>;
+    getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;
     pull(image: string, cacheForMS?: number): Promise<void>;
     toDockerMounts(mounts: StringMap): DockerMounts[];
     toDockerHealth(health: Health): {
@@ -84,7 +103,8 @@ export declare class ContainerInfo {
         protocol: string;
         hostPort: string;
     } | null>;
-    getStatus(): Promise<any>;
+    inspect(): Promise<any>;
+    status(): Promise<DockerState>;
     getPorts(): Promise<PortMap | false>;
 }
 export declare function getExtraHosts(dockerVersion: string): string[] | undefined;

package/dist/cjs/src/containerManager.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.containerManager = exports.toLocalBindVolume = exports.getExtraHosts = exports.ContainerInfo = void 0;
+exports.containerManager = exports.toLocalBindVolume = exports.getExtraHosts = exports.ContainerInfo = exports.HEALTH_CHECK_TIMEOUT = void 0;
 const path_1 = __importDefault(require("path"));
 const storageService_1 = require("./storageService");
 const os_1 = __importDefault(require("os"));
@@ -15,10 +15,11 @@ const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-co
 const utils_1 = require("./utils/utils");
 const LABEL_PORT_PREFIX = 'kapeta_port-';
 const NANO_SECOND = 1000000;
-const HEALTH_CHECK_INTERVAL = 2000;
-const HEALTH_CHECK_MAX = 30;
+const HEALTH_CHECK_INTERVAL = 3000;
+const HEALTH_CHECK_MAX = 20;
 const IMAGE_PULL_CACHE_TTL = 30 * 60 * 1000;
 const IMAGE_PULL_CACHE = {};
+exports.HEALTH_CHECK_TIMEOUT = HEALTH_CHECK_INTERVAL * HEALTH_CHECK_MAX * 2;
 const promisifyStream = (stream) => new Promise((resolve, reject) => {
     stream.on('data', (d) => console.log(d.toString()));
     stream.on('end', resolve);
@@ -131,9 +132,14 @@ class ContainerManager {
     }
     async getContainerByName(containerName) {
         const containers = await this.docker().container.list({ all: true });
-        return containers.find((container) => {
-            return container.data.Names.indexOf(`/${containerName}`) > -1;
+        const out = containers.find((container) => {
+            const containerData = container.data;
+            return containerData.Names.indexOf(`/${containerName}`) > -1;
         });
+        if (out) {
+            return new ContainerInfo(out);
+        }
+        return undefined;
     }
     async pull(image, cacheForMS = IMAGE_PULL_CACHE_TTL) {
         let [imageName, tag] = image.split(/:/);
@@ -294,17 +300,29 @@ class ContainerManager {
         });
     }
     async _isReady(container) {
-        const info = await container.status();
+        let info;
+        try {
+            info = await container.status();
+        }
+        catch (err) {
+            return false;
+        }
         const infoData = info?.data;
-        if (infoData?.State?.Status === 'exited') {
+        const state = infoData?.State;
+        if (state?.Status === 'exited' || state?.Status === 'removing' || state?.Status === 'dead') {
             throw new Error('Container exited unexpectedly');
         }
         return infoData?.State?.Running ?? false;
     }
     async _isHealthy(container) {
-        const info = await container.status();
-        const infoData = info?.data;
-        return infoData?.State?.Health?.Status === 'healthy';
+        try {
+            const info = await container.status();
+            const infoData = info?.data;
+            return infoData?.State?.Health?.Status === 'healthy';
+        }
+        catch (err) {
+            return false;
+        }
     }
     /**
      *
@@ -345,7 +363,7 @@ class ContainerInfo {
         return this._container;
     }
     async isRunning() {
-        const inspectResult = await this.getStatus();
+        const inspectResult = await this.inspect();
         if (!inspectResult || !inspectResult.State) {
             return false;
         }
@@ -370,12 +388,21 @@ class ContainerInfo {
         }
         return null;
     }
-    async getStatus() {
-        const result = await this._container.status();
-        return result ? result.data : null;
+    async inspect() {
+        try {
+            const result = await this._container.status();
+            return result ? result.data : null;
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    async status() {
+        const result = await this.inspect();
+        return result.State;
     }
     async getPorts() {
-        const inspectResult = await this.getStatus();
+        const inspectResult = await this.inspect();
         if (!inspectResult || !inspectResult.Config || !inspectResult.Config.Labels) {
             return false;
         }

package/dist/cjs/src/definitionsManager.d.ts

@@ -0,0 +1,11 @@
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
+declare class DefinitionsManager {
+    private cache;
+    private getKey;
+    clearCache(): void;
+    private doCached;
+    getDefinitions(kindFilter?: string | string[]): DefinitionInfo[];
+    getProviderDefinitions(): DefinitionInfo[];
+}
+export declare const definitionsManager: DefinitionsManager;
+export {};

package/dist/cjs/src/definitionsManager.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitionsManager = void 0;
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const CACHE_TTL = 60 * 1000; // 1 min
+class DefinitionsManager {
+    cache = {};
+    getKey(kindFilter) {
+        if (kindFilter) {
+            if (Array.isArray(kindFilter)) {
+                return kindFilter.join(',');
+            }
+            return kindFilter;
+        }
+        return 'none';
+    }
+    clearCache() {
+        this.cache = {};
+    }
+    doCached(key, getter) {
+        if (this.cache[key]) {
+            if (this.cache[key].expires > Date.now()) {
+                return this.cache[key].definitions;
+            }
+            delete this.cache[key];
+        }
+        this.cache[key] = {
+            expires: Date.now() + CACHE_TTL,
+            definitions: getter(),
+        };
+        return this.cache[key].definitions;
+    }
+    getDefinitions(kindFilter) {
+        const key = this.getKey(kindFilter);
+        return this.doCached(key, () => local_cluster_config_1.default.getDefinitions(kindFilter));
+    }
+    getProviderDefinitions() {
+        return this.doCached('providers', () => local_cluster_config_1.default.getProviderDefinitions());
+    }
+}
+exports.definitionsManager = new DefinitionsManager();

package/dist/cjs/src/filesystemManager.js

@@ -21,9 +21,7 @@ function isFile(path) {
 class FilesystemManager {
     async writeFile(path, data) {
         const dirName = path_1.default.dirname(path);
-        console.log('Dir name', dirName, path);
         if (!fs_1.default.existsSync(dirName)) {
-            console.log('Making folder', dirName);
             fs_extra_1.default.mkdirpSync(dirName, {});
         }
         fs_1.default.writeFileSync(path, data);

package/dist/cjs/src/instanceManager.d.ts

@@ -1,56 +1,32 @@
-import { InstanceInfo, ProcessInfo } from './types';
-declare class InstanceManager {
+import { InstanceInfo } from './types';
+export declare class InstanceManager {
     private _interval;
-    /**
-     * Contains an array of running instances that have self-registered with this
-     * cluster service. This is done by the Kapeta SDKs
-     */
-    private _instances;
-    /**
-     * Contains the process info for the instances started by this manager. In memory only
-     * so can't be relied on for knowing everything that's running.
-     *
-     */
-    private _processes;
+    private readonly _instances;
     constructor();
-    _save(): void;
-    _checkInstances(): Promise<void>;
-    _isRunning(instance: InstanceInfo): Promise<any>;
-    _getInstanceStatus(instance: InstanceInfo): Promise<string>;
+    private checkInstancesLater;
     getInstances(): InstanceInfo[];
     getInstancesForPlan(systemId: string): InstanceInfo[];
-    /**
-     * Get instance information
-     *
-     * @param {string} systemId
-     * @param {string} instanceId
-     * @return {*}
-     */
     getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
+    saveInternalInstance(instance: InstanceInfo): Promise<InstanceInfo>;
     /**
-     *
-     * @param {string} systemId
-     * @param {string} instanceId
-     * @param {InstanceInfo} info
-     * @return {Promise<void>}
-     */
-    registerInstance(systemId: string, instanceId: string, info: Omit<InstanceInfo, 'systemId' | 'instanceId'>): Promise<void>;
-    setInstanceAsStopped(systemId: string, instanceId: string): void;
-    _emit(systemId: string, type: string, payload: any): void;
-    createProcessesForPlan(planRef: string): Promise<ProcessInfo[]>;
-    _stopInstance(instance: InstanceInfo): Promise<void>;
-    stopAllForPlan(planRef: string): Promise<void>;
-    createProcess(planRef: string, instanceId: string): Promise<ProcessInfo>;
-    /**
-     *
-     * @param {string} planRef
-     * @param {string} instanceId
-     * @return {ProcessInfo|null}
+     * Method is called when instance is started from the Kapeta SDKs (e.g. NodeJS SDK)
+     * which self-registers with the cluster service locally on startup.
      */
-    getProcessForInstance(planRef: string, instanceId: string): ProcessInfo | null;
-    restartIfRunning(planRef: string, instanceId: string): Promise<ProcessInfo | undefined>;
-    stopProcess(planRef: string, instanceId: string): Promise<void>;
-    stopAllProcesses(): Promise<void>;
+    registerInstanceFromSDK(systemId: string, instanceId: string, info: Omit<InstanceInfo, 'systemId' | 'instanceId'>): Promise<InstanceInfo | undefined>;
+    private getHealthUrl;
+    markAsStopped(systemId: string, instanceId: string): void;
+    startAllForPlan(systemId: string): Promise<InstanceInfo[]>;
+    stop(systemId: string, instanceId: string): Promise<void>;
+    stopAllForPlan(systemId: string): Promise<void>;
+    start(systemId: string, instanceId: string): Promise<InstanceInfo>;
+    restart(systemId: string, instanceId: string): Promise<InstanceInfo>;
+    stopAll(): Promise<void>;
+    private stopInstances;
+    private save;
+    private checkInstances;
+    private getExternalStatus;
+    private requestInstanceStatus;
+    private emitSystemEvent;
+    private emitInstanceEvent;
 }
 export declare const instanceManager: InstanceManager;
-export {};