@kapeta/local-cluster-service 0.8.3 → 0.9.0

package/dist/esm/src/assetManager.js

@@ -3,12 +3,13 @@ import FS from 'node:fs';
 import FSExtra from 'fs-extra';
 import YAML from 'yaml';
 import NodeCache from 'node-cache';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { codeGeneratorManager } from './codeGeneratorManager';
 import { progressListener } from './progressListener';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { repositoryManager } from './repositoryManager';
 import { Actions } from '@kapeta/nodejs-registry-utils';
+import { definitionsManager } from './definitionsManager';
+import { normalizeKapetaUri } from './utils/utils';
 function enrichAsset(asset) {
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
@@ -47,7 +48,7 @@ class AssetManager {
      */
     getAssets(assetKinds) {
         if (!assetKinds) {
-            const blockTypeProviders = ClusterConfiguration.getDefinitions([
+            const blockTypeProviders = definitionsManager.getDefinitions([
                 'core/block-type',
                 'core/block-type-operator',
             ]);
@@ -56,7 +57,7 @@ class AssetManager {
             });
             assetKinds.push('core/plan');
         }
-        const assets = ClusterConfiguration.getDefinitions(assetKinds);
+        const assets = definitionsManager.getDefinitions(assetKinds);
         return assets.map(enrichAsset);
     }
     getPlans() {
@@ -70,13 +71,15 @@ class AssetManager {
         return asset.data;
     }
     async getAsset(ref, noCache = false) {
+        ref = normalizeKapetaUri(ref);
         const cacheKey = `getAsset:${ref}`;
         if (!noCache && this.cache.has(cacheKey)) {
             return this.cache.get(cacheKey);
         }
         const uri = parseKapetaUri(ref);
         await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version);
-        let asset = ClusterConfiguration.getDefinitions()
+        let asset = definitionsManager
+            .getDefinitions()
             .map(enrichAsset)
             .find((a) => parseKapetaUri(a.ref).equals(uri));
         if (!asset) {

package/dist/esm/src/clusterService.js

@@ -1,3 +1,4 @@
+import { normalizeKapetaUri } from './utils/utils';
 const net = require('net');
 const DEFAULT_SERVER_PORT = 35100;
 const DEFAULT_START_PORT = 40000;
@@ -105,6 +106,7 @@ class ClusterService {
      * @return {string}
      */
     getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType) {
+        systemId = normalizeKapetaUri(systemId);
         return `/proxy/${encodeURIComponent(systemId)}/${encodeURIComponent(consumerInstanceId)}/${encodeURIComponent(consumerResourceName)}/${encodeURIComponent(portType)}/`;
     }
 }

package/dist/esm/src/codeGeneratorManager.js

@@ -1,12 +1,12 @@
 import Path from 'path';
 import { registry as Targets, BlockCodeGenerator, CodeWriter } from '@kapeta/codegen';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { definitionsManager } from './definitionsManager';
 const TARGET_KIND = 'core/language-target';
 const BLOCK_TYPE_KIND = 'core/block-type';
 class CodeGeneratorManager {
     async reload() {
         Targets.reset();
-        const languageTargets = ClusterConfiguration.getDefinitions(TARGET_KIND);
+        const languageTargets = definitionsManager.getDefinitions(TARGET_KIND);
         for (const languageTarget of languageTargets) {
             const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
             try {
@@ -28,7 +28,7 @@ class CodeGeneratorManager {
             //Not all block types have targets
             return false;
         }
-        const blockTypes = ClusterConfiguration.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypes = 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/esm/src/config/routes.js

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

package/dist/esm/src/configManager.js

@@ -1,30 +1,36 @@
 import { storageService } from './storageService';
 import { assetManager } from './assetManager';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { normalizeKapetaUri } from './utils/utils';
 class ConfigManager {
     _config;
     constructor() {
         this._config = storageService.section('config');
     }
     _forSystem(systemId) {
+        systemId = normalizeKapetaUri(systemId);
         if (!this._config[systemId]) {
             this._config[systemId] = {};
         }
         return this._config[systemId];
     }
     setConfigForSystem(systemId, config) {
+        systemId = normalizeKapetaUri(systemId);
         const systemConfig = config || {};
         storageService.put('config', systemId, systemConfig);
     }
     getConfigForSystem(systemId) {
+        systemId = normalizeKapetaUri(systemId);
         return this._forSystem(systemId);
     }
     setConfigForSection(systemId, sectionId, config) {
+        systemId = normalizeKapetaUri(systemId);
         let systemConfig = this._forSystem(systemId);
         systemConfig[sectionId] = config || {};
         storageService.put('config', systemId, systemConfig);
     }
     getConfigForSection(systemId, sectionId) {
+        systemId = normalizeKapetaUri(systemId);
         const systemConfig = this._forSystem(systemId);
         if (!systemConfig[sectionId]) {
             systemConfig[sectionId] = {};
@@ -48,6 +54,10 @@ class ConfigManager {
      * @returns {Promise<{systemId:string,instanceId:string}>}
      */
     async resolveIdentity(blockRef, systemId) {
+        blockRef = normalizeKapetaUri(blockRef);
+        if (systemId) {
+            systemId = normalizeKapetaUri(systemId);
+        }
         const planAssets = assetManager.getPlans();
         const blockUri = parseKapetaUri(blockRef);
         let matchingIdentities = [];
@@ -63,7 +73,7 @@ class ConfigManager {
                 const refUri = parseKapetaUri(blockInstance.block.ref);
                 if (refUri.equals(blockUri)) {
                     matchingIdentities.push({
-                        systemId: planAsset.ref,
+                        systemId: normalizeKapetaUri(planAsset.ref),
                         instanceId: blockInstance.id,
                     });
                 }
@@ -84,6 +94,8 @@ class ConfigManager {
         return matchingIdentities[0];
     }
     async verifyIdentity(blockRef, systemId, instanceId) {
+        blockRef = normalizeKapetaUri(blockRef);
+        systemId = normalizeKapetaUri(systemId);
         const planAssets = assetManager.getPlans();
         const systemUri = systemId ? parseKapetaUri(systemId) : null;
         const blockUri = parseKapetaUri(blockRef);

package/dist/esm/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/esm/src/containerManager.js

@@ -9,10 +9,11 @@ import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { getBindHost } from './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 = {};
+export const 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);
@@ -125,9 +126,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(/:/);
@@ -288,17 +294,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;
+        }
     }
     /**
      *
@@ -339,7 +357,7 @@ export class ContainerInfo {
         return this._container;
     }
     async isRunning() {
-        const inspectResult = await this.getStatus();
+        const inspectResult = await this.inspect();
         if (!inspectResult || !inspectResult.State) {
             return false;
         }
@@ -364,12 +382,21 @@ export 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/esm/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/esm/src/definitionsManager.js

@@ -0,0 +1,38 @@
+import ClusterConfiguration from '@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, () => ClusterConfiguration.getDefinitions(kindFilter));
+    }
+    getProviderDefinitions() {
+        return this.doCached('providers', () => ClusterConfiguration.getProviderDefinitions());
+    }
+}
+export const definitionsManager = new DefinitionsManager();

package/dist/esm/src/filesystemManager.js

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

package/dist/esm/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 {};