@kapeta/local-cluster-service 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.13.0](https://github.com/kapetacom/local-cluster-service/compare/v0.12.1...v0.13.0) (2023-08-03)
+
+
+### Features
+
+* Adds background task concept ([#55](https://github.com/kapetacom/local-cluster-service/issues/55)) ([71cc63c](https://github.com/kapetacom/local-cluster-service/commit/71cc63c9c3eb8bec1dec8b31d3340694e93bd3e5))
+
+## [0.12.1](https://github.com/kapetacom/local-cluster-service/compare/v0.12.0...v0.12.1) (2023-08-02)
+
+
+### Bug Fixes
+
+* Adjustments to make starting plans locally smoother ([fc353ad](https://github.com/kapetacom/local-cluster-service/commit/fc353adde350b7e9d4c7eb9347c4cfa0c3a6aa58))
+
 # [0.12.0](https://github.com/kapetacom/local-cluster-service/compare/v0.11.1...v0.12.0) (2023-07-31)
 
 

package/dist/cjs/index.js

@@ -20,6 +20,7 @@ const routes_6 = __importDefault(require("./src/filesystem/routes"));
 const routes_7 = __importDefault(require("./src/assets/routes"));
 const routes_8 = __importDefault(require("./src/providers/routes"));
 const routes_9 = __importDefault(require("./src/attachments/routes"));
+const routes_10 = __importDefault(require("./src/tasks/routes"));
 const utils_1 = require("./src/utils/utils");
 const request_1 = __importDefault(require("request"));
 let currentServer = null;
@@ -34,6 +35,7 @@ function createServer() {
     app.use('/assets', routes_7.default);
     app.use('/providers', routes_8.default);
     app.use('/attachments', routes_9.default);
+    app.use('/tasks', routes_10.default);
     app.get('/status', async (req, res) => {
         res.send({
             ok: true,

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

@@ -13,6 +13,7 @@ export interface EnrichedAsset {
 declare class AssetManager {
     private cache;
     constructor();
+    clearCache(): void;
     /**
      *
      * @param {string[]} [assetKinds]
@@ -21,11 +22,12 @@ declare class AssetManager {
     getAssets(assetKinds?: string[]): EnrichedAsset[];
     getPlans(): EnrichedAsset[];
     getPlan(ref: string, noCache?: boolean): Promise<Definition>;
-    getAsset(ref: string, noCache?: boolean): Promise<EnrichedAsset | undefined>;
+    getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
     createAsset(path: string, yaml: BlockDefinition): Promise<EnrichedAsset[]>;
     updateAsset(ref: string, yaml: BlockDefinition): Promise<void>;
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;
+    installAsset(ref: string): Promise<import("./taskManager").Task<void>[] | undefined>;
 }
 export declare const assetManager: AssetManager;
 export {};

package/dist/cjs/src/assetManager.js

@@ -47,6 +47,9 @@ class AssetManager {
             stdTTL: 60 * 60, // 1 hour
         });
     }
+    clearCache() {
+        this.cache.flushAll();
+    }
     /**
      *
      * @param {string[]} [assetKinds]
@@ -76,22 +79,26 @@ class AssetManager {
         }
         return asset.data;
     }
-    async getAsset(ref, noCache = false) {
+    async getAsset(ref, noCache = false, autoFetch = true) {
         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);
+        if (autoFetch) {
+            await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, true);
+        }
         let asset = definitionsManager_1.definitionsManager
             .getDefinitions()
             .map(enrichAsset)
             .find((a) => (0, nodejs_utils_1.parseKapetaUri)(a.ref).equals(uri));
-        if (!asset) {
+        if (autoFetch && !asset) {
             throw new Error('Asset not found: ' + ref);
         }
-        this.cache.set(cacheKey, asset);
+        if (asset) {
+            this.cache.set(cacheKey, asset);
+        }
         return asset;
     }
     async createAsset(path, yaml) {
@@ -152,5 +159,14 @@ class AssetManager {
         this.cache.flushAll();
         await nodejs_registry_utils_1.Actions.uninstall(progressListener_1.progressListener, [asset.ref]);
     }
+    async installAsset(ref) {
+        const asset = await this.getAsset(ref, true, false);
+        if (asset) {
+            throw new Error('Asset already installed: ' + ref);
+        }
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        console.log('Installing %s', ref);
+        return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
+    }
 }
 exports.assetManager = new AssetManager();

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

@@ -39,8 +39,15 @@ router.get('/read', async (req, res) => {
         res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
+    const ensure = req.query.ensure !== 'false';
     try {
-        res.send(await assetManager_1.assetManager.getAsset(req.query.ref, true));
+        const asset = await assetManager_1.assetManager.getAsset(req.query.ref, true, ensure);
+        if (asset) {
+            res.send(asset);
+        }
+        else {
+            res.status(404).send({ error: 'Asset not found' });
+        }
     }
     catch (err) {
         res.status(400).send({ error: err.message });
@@ -114,4 +121,18 @@ router.put('/import', async (req, res) => {
         res.status(400).send({ error: err.message });
     }
 });
+router.put('/install', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    try {
+        const tasks = await assetManager_1.assetManager.installAsset(req.query.ref);
+        const taskIds = tasks?.map((t) => t.id) ?? [];
+        res.status(200).send(taskIds);
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
 exports.default = router;

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

@@ -59,7 +59,7 @@ declare class ContainerManager {
     ping(): Promise<void>;
     docker(): Docker;
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;
-    pull(image: string, cacheForMS?: number): Promise<boolean>;
+    pull(image: string): Promise<boolean>;
     toDockerMounts(mounts: StringMap): DockerMounts[];
     toDockerHealth(health: Health): {
         Test: string[];

package/dist/cjs/src/containerManager.js

@@ -15,15 +15,13 @@ const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-co
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const md5_1 = __importDefault(require("md5"));
 const utils_1 = require("./utils/utils");
-const socketManager_1 = require("./socketManager");
 const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const taskManager_1 = require("./taskManager");
 const EVENT_IMAGE_PULL = 'docker-image-pull';
 exports.CONTAINER_LABEL_PORT_PREFIX = 'kapeta_port-';
 const NANO_SECOND = 1000000;
 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, handler) => new Promise((resolve, reject) => {
     stream.on('data', handler);
@@ -151,17 +149,11 @@ class ContainerManager {
         }
         return undefined;
     }
-    async pull(image, cacheForMS = IMAGE_PULL_CACHE_TTL) {
+    async pull(image) {
         let [imageName, tag] = image.split(/:/);
         if (!tag) {
             tag = 'latest';
         }
-        if (IMAGE_PULL_CACHE[image]) {
-            const timeSince = Date.now() - IMAGE_PULL_CACHE[image];
-            if (timeSince < cacheForMS) {
-                return false;
-            }
-        }
         const imageTagList = (await this.docker().image.list())
             .map((image) => image.data)
             .filter((imageData) => !!imageData.RepoTags)
@@ -170,121 +162,141 @@ class ContainerManager {
             console.log('Image found: %s', image);
             return false;
         }
-        const timeStarted = Date.now();
-        socketManager_1.socketManager.emitGlobal(EVENT_IMAGE_PULL, { image, percent: 0 });
-        const api = new nodejs_api_client_1.KapetaAPI();
-        const accessToken = await api.getAccessToken();
-        const auth = image.startsWith('docker.kapeta.com/')
-            ? {
-                username: 'kapeta',
-                password: accessToken,
-                serveraddress: 'docker.kapeta.com',
-            }
-            : {};
-        const stream = (await this.docker().image.create(auth, {
-            fromImage: imageName,
-            tag: tag,
-        }));
-        const chunks = {};
-        let lastEmitted = Date.now();
-        await promisifyStream(stream, (rawData) => {
-            const lines = rawData.toString().trim().split('\n');
-            lines.forEach((line) => {
-                const data = JSON.parse(line);
-                if (![
-                    'Waiting',
-                    'Downloading',
-                    'Extracting',
-                    'Download complete',
-                    'Pull complete',
-                    'Already exists',
-                ].includes(data.status)) {
-                    return;
-                }
-                if (!chunks[data.id]) {
-                    chunks[data.id] = {
-                        downloading: {
-                            total: 0,
-                            current: 0,
-                        },
-                        extracting: {
-                            total: 0,
-                            current: 0,
-                        },
-                        done: false,
-                    };
-                }
-                const chunk = chunks[data.id];
-                switch (data.status) {
-                    case 'Downloading':
-                        chunk.downloading = data.progressDetail;
-                        break;
-                    case 'Extracting':
-                        chunk.extracting = data.progressDetail;
-                        break;
-                    case 'Download complete':
-                        chunk.downloading.current = chunks[data.id].downloading.total;
-                        break;
-                    case 'Pull complete':
-                        chunk.extracting.current = chunks[data.id].extracting.total;
-                        chunk.done = true;
-                        break;
-                    case 'Already exists':
-                        // Force layer to be done
-                        chunk.downloading.current = 1;
-                        chunk.downloading.total = 1;
-                        chunk.extracting.current = 1;
-                        chunk.extracting.total = 1;
-                        chunk.done = true;
-                        break;
-                }
-            });
-            if (Date.now() - lastEmitted < 1000) {
-                return;
-            }
-            const chunkList = Object.values(chunks);
-            let totals = {
-                downloading: {
-                    total: 0,
-                    current: 0,
-                },
-                extracting: {
-                    total: 0,
-                    current: 0,
-                },
-                total: chunkList.length,
-                done: 0,
-            };
-            chunkList.forEach((chunk) => {
-                if (chunk.downloading.current > 0) {
-                    totals.downloading.current += chunk.downloading.current;
-                }
-                if (chunk.downloading.total > 0) {
-                    totals.downloading.total += chunk.downloading.total;
+        let friendlyImageName = image;
+        const imageParts = imageName.split('/');
+        if (imageParts.length > 2) {
+            //Strip the registry to make the name shorter
+            friendlyImageName = `${imageParts.slice(1).join('/')}:${tag}`;
+        }
+        const taskName = `Pulling image ${friendlyImageName}`;
+        const processor = async (task) => {
+            const timeStarted = Date.now();
+            const api = new nodejs_api_client_1.KapetaAPI();
+            const accessToken = await api.getAccessToken();
+            const auth = image.startsWith('docker.kapeta.com/')
+                ? {
+                    username: 'kapeta',
+                    password: accessToken,
+                    serveraddress: 'docker.kapeta.com',
                 }
-                if (chunk.extracting.current > 0) {
-                    totals.extracting.current += chunk.extracting.current;
-                }
-                if (chunk.extracting.total > 0) {
-                    totals.extracting.total += chunk.extracting.total;
-                }
-                if (chunk.done) {
-                    totals.done++;
+                : {};
+            const stream = (await this.docker().image.create(auth, {
+                fromImage: imageName,
+                tag: tag,
+            }));
+            const chunks = {};
+            let lastEmitted = Date.now();
+            await promisifyStream(stream, (rawData) => {
+                const lines = rawData.toString().trim().split('\n');
+                lines.forEach((line) => {
+                    const data = JSON.parse(line);
+                    if (![
+                        'Waiting',
+                        'Downloading',
+                        'Extracting',
+                        'Download complete',
+                        'Pull complete',
+                        'Already exists',
+                    ].includes(data.status)) {
+                        return;
+                    }
+                    if (!chunks[data.id]) {
+                        chunks[data.id] = {
+                            downloading: {
+                                total: 0,
+                                current: 0,
+                            },
+                            extracting: {
+                                total: 0,
+                                current: 0,
+                            },
+                            done: false,
+                        };
+                    }
+                    const chunk = chunks[data.id];
+                    switch (data.status) {
+                        case 'Downloading':
+                            chunk.downloading = data.progressDetail;
+                            break;
+                        case 'Extracting':
+                            chunk.extracting = data.progressDetail;
+                            break;
+                        case 'Download complete':
+                            chunk.downloading.current = chunks[data.id].downloading.total;
+                            break;
+                        case 'Pull complete':
+                            chunk.extracting.current = chunks[data.id].extracting.total;
+                            chunk.done = true;
+                            break;
+                        case 'Already exists':
+                            // Force layer to be done
+                            chunk.downloading.current = 1;
+                            chunk.downloading.total = 1;
+                            chunk.extracting.current = 1;
+                            chunk.extracting.total = 1;
+                            chunk.done = true;
+                            break;
+                    }
+                });
+                if (Date.now() - lastEmitted < 1000) {
+                    return;
                 }
+                const chunkList = Object.values(chunks);
+                let totals = {
+                    downloading: {
+                        total: 0,
+                        current: 0,
+                    },
+                    extracting: {
+                        total: 0,
+                        current: 0,
+                    },
+                    total: chunkList.length,
+                    done: 0,
+                };
+                chunkList.forEach((chunk) => {
+                    if (chunk.downloading.current > 0) {
+                        totals.downloading.current += chunk.downloading.current;
+                    }
+                    if (chunk.downloading.total > 0) {
+                        totals.downloading.total += chunk.downloading.total;
+                    }
+                    if (chunk.extracting.current > 0) {
+                        totals.extracting.current += chunk.extracting.current;
+                    }
+                    if (chunk.extracting.total > 0) {
+                        totals.extracting.total += chunk.extracting.total;
+                    }
+                    if (chunk.done) {
+                        totals.done++;
+                    }
+                });
+                const progress = totals.total > 0 ? (totals.done / totals.total) * 100 : 0;
+                task.metadata = {
+                    ...task.metadata,
+                    image,
+                    progress,
+                    status: totals,
+                    timeTaken: Date.now() - timeStarted,
+                };
+                task.emitUpdate();
+                lastEmitted = Date.now();
+                //console.log('Pulling image %s: %s % [done: %s, total: %s]', image, Math.round(percent), totals.done, totals.total);
             });
-            const percent = totals.total > 0 ? (totals.done / totals.total) * 100 : 0;
-            //We emit at most every second to not spam the client
-            socketManager_1.socketManager.emitGlobal(EVENT_IMAGE_PULL, {
+            task.metadata = {
+                ...task.metadata,
                 image,
-                percent,
-                status: totals,
+                progress: 100,
                 timeTaken: Date.now() - timeStarted,
-            });
-            lastEmitted = Date.now();
-            //console.log('Pulling image %s: %s % [done: %s, total: %s]', image, Math.round(percent), totals.done, totals.total);
+            };
+            task.emitUpdate();
+        };
+        const task = taskManager_1.taskManager.add(`docker:image:pull:${image}`, processor, {
+            name: taskName,
+            image,
+            progress: -1,
         });
-        IMAGE_PULL_CACHE[image] = Date.now();
-        socketManager_1.socketManager.emitGlobal(EVENT_IMAGE_PULL, { image, percent: 100, timeTaken: Date.now() - timeStarted });
+        await task.wait();
         return true;
     }
     toDockerMounts(mounts) {
@@ -319,9 +331,7 @@ class ContainerManager {
         dockerOpts.Labels.HASH = hash;
     }
     async ensureContainer(opts) {
-        const container = await this.createOrUpdateContainer(opts);
-        await this.waitForReady(container);
-        return container;
+        return await this.createOrUpdateContainer(opts);
     }
     async createOrUpdateContainer(opts) {
         let imagePulled = await this.pull(opts.Image);

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

@@ -1,4 +1,5 @@
 import { InstanceInfo, LogEntry } from './types';
+import { Task } from './taskManager';
 export declare class InstanceManager {
     private _interval;
     private readonly _instances;
@@ -18,11 +19,11 @@ export declare class InstanceManager {
     registerInstanceFromSDK(systemId: string, instanceId: string, info: Omit<InstanceInfo, 'systemId' | 'instanceId'>): Promise<InstanceInfo | undefined>;
     private getHealthUrl;
     markAsStopped(systemId: string, instanceId: string): Promise<void>;
-    startAllForPlan(systemId: string): Promise<InstanceInfo[]>;
+    startAllForPlan(systemId: string): Promise<Task<InstanceInfo[]>>;
     stop(systemId: string, instanceId: string): Promise<void>;
     private stopInner;
-    stopAllForPlan(systemId: string): Promise<void>;
-    start(systemId: string, instanceId: string): Promise<InstanceInfo>;
+    stopAllForPlan(systemId: string): Task<void>;
+    start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>>;
     /**
      * Stops an instance but does not remove it from the list of active instances
      *