@kapeta/local-cluster-service 0.16.6 → 0.16.8

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.16.8](https://github.com/kapetacom/local-cluster-service/compare/v0.16.7...v0.16.8) (2023-08-30)
+
+
+### Bug Fixes
+
+* Gracefully handled instances that have been deleted ([#64](https://github.com/kapetacom/local-cluster-service/issues/64)) ([e26ed35](https://github.com/kapetacom/local-cluster-service/commit/e26ed353e474b7417939008fb1eadec891d5ead9))
+
+## [0.16.7](https://github.com/kapetacom/local-cluster-service/compare/v0.16.6...v0.16.7) (2023-08-24)
+
+
+### Bug Fixes
+
+* Load JS from provider endpoints if not available locally ([#63](https://github.com/kapetacom/local-cluster-service/issues/63)) ([83c7cb4](https://github.com/kapetacom/local-cluster-service/commit/83c7cb4a176a2b23ee5bf5e8a312e8a64abd9ea6))
+
 ## [0.16.6](https://github.com/kapetacom/local-cluster-service/compare/v0.16.5...v0.16.6) (2023-08-21)
 
 

package/dist/cjs/src/instanceManager.js

@@ -480,6 +480,36 @@ class InstanceManager {
                 if (instance.ref) {
                     instance.ref = (0, utils_1.normalizeKapetaUri)(instance.ref);
                 }
+                if (instance.desiredStatus === types_1.DesiredInstanceStatus.RUN) {
+                    // Check if the plan still exists and the instance is still in the plan
+                    // - and that the block definition exists
+                    try {
+                        const plan = await assetManager_1.assetManager.getAsset(instance.systemId, true, false);
+                        if (!plan) {
+                            instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                        const planData = plan.data;
+                        const planInstance = planData?.spec?.blocks?.find((b) => b.id === instance.instanceId);
+                        if (!planInstance || !planInstance?.block?.ref) {
+                            instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                        const blockDef = await assetManager_1.assetManager.getAsset(instance.ref, true, false);
+                        if (!blockDef) {
+                            instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to check assets', instance.systemId, e);
+                        instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                        return;
+                    }
+                }
                 const newStatus = await this.requestInstanceStatus(instance);
                 /*
                 console.log('Check instance %s %s: [current: %s, new: %s, desired: %s]',

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

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 declare class ProviderManager {
     getWebProviders(): import("@kapeta/local-cluster-config").DefinitionInfo[];
-    getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<string | Buffer | null>;
+    getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<unknown>;
 }
 export declare const providerManager: ProviderManager;
 export {};

package/dist/cjs/src/providerManager.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.providerManager = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const repositoryManager_1 = require("./repositoryManager");
 const definitionsManager_1 = require("./definitionsManager");
 const cacheManager_1 = require("./cacheManager");
+const request_1 = __importDefault(require("request"));
+const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
 class ProviderManager {
     getWebProviders() {
         return definitionsManager_1.definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
@@ -21,7 +22,6 @@ class ProviderManager {
         if (file && (await fs_extra_1.default.pathExists(file))) {
             return fs_extra_1.default.readFile(file, 'utf8');
         }
-        await repositoryManager_1.repositoryManager.ensureAsset(handle, name, version, true);
         const installedProvider = this.getWebProviders().find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });
@@ -33,7 +33,28 @@ class ProviderManager {
                 return fs_extra_1.default.readFile(path);
             }
         }
-        return null;
+        if (version === 'local') {
+            return null;
+        }
+        const url = `${PROVIDER_FILE_BASE}/${id}`;
+        return new Promise((resolve, reject) => {
+            console.log('Loading provider from %s', url);
+            request_1.default.get(url, (error, response, body) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (response.statusCode === 404) {
+                    resolve(null);
+                    return;
+                }
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Failed to load provider from ${url}: ${body}`));
+                    return;
+                }
+                resolve(body);
+            });
+        });
     }
 }
 const providerDefinitions = definitionsManager_1.definitionsManager.getProviderDefinitions();

package/dist/esm/src/instanceManager.js

@@ -3,7 +3,7 @@ import request from 'request';
 import AsyncLock from 'async-lock';
 import { BlockInstanceRunner } from './utils/BlockInstanceRunner';
 import { storageService } from './storageService';
-import { EVENT_INSTANCE_CREATED, EVENT_INSTANCE_EXITED, EVENT_STATUS_CHANGED, socketManager, } from './socketManager';
+import { EVENT_INSTANCE_CREATED, EVENT_INSTANCE_EXITED, EVENT_STATUS_CHANGED, socketManager } from './socketManager';
 import { serviceManager } from './serviceManager';
 import { assetManager } from './assetManager';
 import { containerManager, HEALTH_CHECK_TIMEOUT } from './containerManager';
@@ -474,6 +474,36 @@ export class InstanceManager {
                 if (instance.ref) {
                     instance.ref = normalizeKapetaUri(instance.ref);
                 }
+                if (instance.desiredStatus === DesiredInstanceStatus.RUN) {
+                    // Check if the plan still exists and the instance is still in the plan
+                    // - and that the block definition exists
+                    try {
+                        const plan = await assetManager.getAsset(instance.systemId, true, false);
+                        if (!plan) {
+                            instance.desiredStatus = DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                        const planData = plan.data;
+                        const planInstance = planData?.spec?.blocks?.find((b) => b.id === instance.instanceId);
+                        if (!planInstance || !planInstance?.block?.ref) {
+                            instance.desiredStatus = DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                        const blockDef = await assetManager.getAsset(instance.ref, true, false);
+                        if (!blockDef) {
+                            instance.desiredStatus = DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to check assets', instance.systemId, e);
+                        instance.desiredStatus = DesiredInstanceStatus.STOP;
+                        return;
+                    }
+                }
                 const newStatus = await this.requestInstanceStatus(instance);
                 /*
                 console.log('Check instance %s %s: [current: %s, new: %s, desired: %s]',

package/dist/esm/src/providerManager.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 declare class ProviderManager {
     getWebProviders(): import("@kapeta/local-cluster-config").DefinitionInfo[];
-    getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<string | Buffer | null>;
+    getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<unknown>;
 }
 export declare const providerManager: ProviderManager;
 export {};

package/dist/esm/src/providerManager.js

@@ -1,8 +1,9 @@
 import Path from 'path';
 import FSExtra from 'fs-extra';
-import { repositoryManager } from './repositoryManager';
 import { definitionsManager } from './definitionsManager';
 import { cacheManager } from './cacheManager';
+import request from 'request';
+const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
 class ProviderManager {
     getWebProviders() {
         return definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
@@ -15,7 +16,6 @@ class ProviderManager {
         if (file && (await FSExtra.pathExists(file))) {
             return FSExtra.readFile(file, 'utf8');
         }
-        await repositoryManager.ensureAsset(handle, name, version, true);
         const installedProvider = this.getWebProviders().find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });
@@ -27,7 +27,28 @@ class ProviderManager {
                 return FSExtra.readFile(path);
             }
         }
-        return null;
+        if (version === 'local') {
+            return null;
+        }
+        const url = `${PROVIDER_FILE_BASE}/${id}`;
+        return new Promise((resolve, reject) => {
+            console.log('Loading provider from %s', url);
+            request.get(url, (error, response, body) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (response.statusCode === 404) {
+                    resolve(null);
+                    return;
+                }
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Failed to load provider from ${url}: ${body}`));
+                    return;
+                }
+                resolve(body);
+            });
+        });
     }
 }
 const providerDefinitions = definitionsManager.getProviderDefinitions();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.16.6",
+    "version": "0.16.8",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/instanceManager.ts

@@ -3,13 +3,7 @@ import request from 'request';
 import AsyncLock from 'async-lock';
 import { BlockInstanceRunner } from './utils/BlockInstanceRunner';
 import { storageService } from './storageService';
-import {
-    EVENT_INSTANCE_CREATED,
-    EVENT_INSTANCE_EXITED,
-    EVENT_INSTANCE_LOG,
-    EVENT_STATUS_CHANGED,
-    socketManager,
-} from './socketManager';
+import { EVENT_INSTANCE_CREATED, EVENT_INSTANCE_EXITED, EVENT_STATUS_CHANGED, socketManager } from './socketManager';
 import { serviceManager } from './serviceManager';
 import { assetManager } from './assetManager';
 import { containerManager, HEALTH_CHECK_TIMEOUT } from './containerManager';
@@ -606,6 +600,38 @@ export class InstanceManager {
                     instance.ref = normalizeKapetaUri(instance.ref);
                 }
 
+                if (instance.desiredStatus === DesiredInstanceStatus.RUN) {
+                    // Check if the plan still exists and the instance is still in the plan
+                    // - and that the block definition exists
+                    try {
+                        const plan = await assetManager.getAsset(instance.systemId, true, false);
+                        if (!plan) {
+                            instance.desiredStatus = DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+
+                        const planData = plan.data as Plan;
+                        const planInstance = planData?.spec?.blocks?.find((b) => b.id === instance.instanceId);
+                        if (!planInstance || !planInstance?.block?.ref) {
+                            instance.desiredStatus = DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+
+                        const blockDef = await assetManager.getAsset(instance.ref, true, false);
+                        if (!blockDef) {
+                            instance.desiredStatus = DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                    } catch (e) {
+                        console.warn('Failed to check assets', instance.systemId, e);
+                        instance.desiredStatus = DesiredInstanceStatus.STOP;
+                        return;
+                    }
+                }
+
                 const newStatus = await this.requestInstanceStatus(instance);
                 /*
                 console.log('Check instance %s %s: [current: %s, new: %s, desired: %s]',

package/src/providerManager.ts

@@ -1,10 +1,10 @@
 import Path from 'path';
 import FSExtra from 'fs-extra';
-import { repositoryManager } from './repositoryManager';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
-import { StringMap } from './types';
 import { definitionsManager } from './definitionsManager';
 import { cacheManager } from './cacheManager';
+import request from 'request';
+
+const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
 
 class ProviderManager {
     getWebProviders() {
@@ -22,8 +22,6 @@ class ProviderManager {
             return FSExtra.readFile(file, 'utf8');
         }
 
-        await repositoryManager.ensureAsset(handle, name, version, true);
-
         const installedProvider = this.getWebProviders().find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });
@@ -37,7 +35,31 @@ class ProviderManager {
             }
         }
 
-        return null;
+        if (version === 'local') {
+            return null;
+        }
+
+        const url = `${PROVIDER_FILE_BASE}/${id}`;
+        return new Promise((resolve, reject) => {
+            console.log('Loading provider from %s', url);
+            request.get(url, (error, response, body) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (response.statusCode === 404) {
+                    resolve(null);
+                    return;
+                }
+
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Failed to load provider from ${url}: ${body}`));
+                    return;
+                }
+
+                resolve(body);
+            });
+        });
     }
 }