@kapeta/local-cluster-service 0.11.1 → 0.12.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [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)
+
+
+### Features
+
+* Send status events to client when pulling image ([#54](https://github.com/kapetacom/local-cluster-service/issues/54)) ([6c6f1b0](https://github.com/kapetacom/local-cluster-service/commit/6c6f1b0cf31d4bbd1fccf10f4a66a3ac97ff7171))
+
 ## [0.11.1](https://github.com/kapetacom/local-cluster-service/compare/v0.11.0...v0.11.1) (2023-07-31)
 
 

package/definitions.d.ts

@@ -18,4 +18,11 @@ declare module '@kapeta/nodejs-registry-utils' {
 
     export const Config: any;
     export const Actions: any;
+
+    export const handlers: {
+        DockerHandler: ArtifactHandlerFactory;
+        NPMHandler: ArtifactHandlerFactory;
+        MavenHandler: ArtifactHandlerFactory;
+        YAMLHandler: ArtifactHandlerFactory;
+    };
 }

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.restart(req.kapeta.systemId, req.kapeta.instanceId);
+            await instanceManager_1.instanceManager.prepareForRestart(req.kapeta.systemId, req.kapeta.instanceId);
         }
         else {
             configManager_1.configManager.setConfigForSystem(req.kapeta.systemId, config);

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

@@ -1,6 +1,6 @@
 import { Docker } from 'node-docker-api';
 import { Container } from 'node-docker-api/lib/container';
-import { InstanceInfo, LogEntry } from "./types";
+import { InstanceInfo, LogEntry } from './types';
 type StringMap = {
     [key: string]: string;
 };
@@ -49,6 +49,7 @@ declare class ContainerManager {
     private _alive;
     private _mountDir;
     private _version;
+    private _lastDockerAccessCheck;
     constructor();
     initialize(): Promise<void>;
     checkAlive(): Promise<boolean>;
@@ -58,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,12 +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 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);
@@ -32,6 +33,7 @@ class ContainerManager {
     _alive;
     _mountDir;
     _version;
+    _lastDockerAccessCheck = 0;
     constructor() {
         this._docker = null;
         this._alive = false;
@@ -147,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)
@@ -166,17 +162,120 @@ class ContainerManager {
             console.log('Image found: %s', image);
             return false;
         }
-        console.log('Pulling image: %s', image);
-        const stream = await this.docker()
-            .image.create({}, {
+        const timeStarted = Date.now();
+        socketManager_1.socketManager.emitGlobal(EVENT_IMAGE_PULL, { image, percent: -1 });
+        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;
+                }
+                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 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, {
+                image,
+                percent,
+                status: totals,
+                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);
         });
-        await promisifyStream(stream, (chunk) => {
-            console.log('Data from docker: "%s"', chunk.toString());
-        });
-        IMAGE_PULL_CACHE[image] = Date.now();
-        console.log('Image pulled: %s', image);
+        socketManager_1.socketManager.emitGlobal(EVENT_IMAGE_PULL, { image, percent: 100, timeTaken: Date.now() - timeStarted });
         return true;
     }
     toDockerMounts(mounts) {
@@ -211,18 +310,10 @@ 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 = false;
-        try {
-            imagePulled = await this.pull(opts.Image);
-        }
-        catch (e) {
-            console.warn('Failed to pull image. Continuing...', e);
-        }
+        let imagePulled = await this.pull(opts.Image);
         this.applyHash(opts);
         if (!opts.name) {
             console.log('Starting unnamed container: %s', opts.Image);
@@ -347,12 +438,14 @@ class ContainerManager {
         const containerName = (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
         const containerInfo = await this.getContainerByName(containerName);
         if (!containerInfo) {
-            return [{
-                    source: "stdout",
-                    level: "ERROR",
+            return [
+                {
+                    source: 'stdout',
+                    level: 'ERROR',
                     time: Date.now(),
-                    message: "Container not found"
-                }];
+                    message: 'Container not found',
+                },
+            ];
         }
         return containerInfo.getLogs();
     }
@@ -440,13 +533,13 @@ class ContainerInfo {
         return ports;
     }
     async getLogs() {
-        const logStream = await this.native.logs({
+        const logStream = (await this.native.logs({
             stdout: true,
             stderr: true,
             follow: false,
             tail: 100,
             timestamps: true,
-        });
+        }));
         const out = [];
         await promisifyStream(logStream, (data) => {
             const buf = data;

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

@@ -7,6 +7,7 @@ declare class DefinitionsManager {
     getDefinitions(kindFilter?: string | string[]): DefinitionInfo[];
     exists(ref: string): boolean;
     getProviderDefinitions(): DefinitionInfo[];
+    getDefinition(ref: string): DefinitionInfo | undefined;
 }
 export declare const definitionsManager: DefinitionsManager;
 export {};

package/dist/cjs/src/definitionsManager.js

@@ -39,13 +39,16 @@ class DefinitionsManager {
         return this.doCached(key, () => local_cluster_config_1.default.getDefinitions(kindFilter));
     }
     exists(ref) {
-        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
-        return !!this.getDefinitions().find((d) => {
-            return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
-        });
+        return !!this.getDefinition(ref);
     }
     getProviderDefinitions() {
         return this.doCached('providers', () => local_cluster_config_1.default.getProviderDefinitions());
     }
+    getDefinition(ref) {
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        return this.getDefinitions().find((d) => {
+            return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
+        });
+    }
 }
 exports.definitionsManager = new DefinitionsManager();

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

@@ -23,7 +23,14 @@ export declare class InstanceManager {
     private stopInner;
     stopAllForPlan(systemId: string): Promise<void>;
     start(systemId: string, instanceId: string): Promise<InstanceInfo>;
-    restart(systemId: string, instanceId: string): Promise<InstanceInfo>;
+    /**
+     * Stops an instance but does not remove it from the list of active instances
+     *
+     * It will be started again next time the system checks the status of the instance
+     *
+     * We do it this way to not cause the user to wait for the instance to start again
+     */
+    prepareForRestart(systemId: string, instanceId: string): Promise<void>;
     stopAll(): Promise<void>;
     private stopInstances;
     private save;

package/dist/cjs/src/instanceManager.js

@@ -16,6 +16,9 @@ const containerManager_1 = require("./containerManager");
 const configManager_1 = require("./configManager");
 const types_1 = require("./types");
 const utils_1 = require("./utils/utils");
+const operatorManager_1 = require("./operatorManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const definitionsManager_1 = require("./definitionsManager");
 const CHECK_INTERVAL = 5000;
 const DEFAULT_HEALTH_PORT_TYPE = 'rest';
 const EVENT_STATUS_CHANGED = 'status-changed';
@@ -52,7 +55,13 @@ class InstanceManager {
             return [];
         }
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-        return this._instances.filter((instance) => instance.systemId === systemId);
+        const planInfo = definitionsManager_1.definitionsManager.getDefinition(systemId);
+        if (!planInfo) {
+            return [];
+        }
+        const plan = planInfo.definition;
+        const instanceIds = plan.spec.blocks.map((block) => block.id);
+        return this._instances.filter((instance) => instance.systemId === systemId && instanceIds.includes(instance.instanceId));
     }
     getInstance(systemId, instanceId) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
@@ -61,7 +70,10 @@ class InstanceManager {
     async exclusive(systemId, instanceId, fn) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const key = `${systemId}/${instanceId}`;
-        return this.instanceLocks.acquire(key, fn);
+        //console.log(`Acquiring lock for ${key}`, this.instanceLocks.isBusy(key));
+        const result = await this.instanceLocks.acquire(key, fn);
+        //console.log(`Releasing lock for ${key}`, this.instanceLocks.isBusy(key));
+        return result;
     }
     async getLogs(systemId, instanceId) {
         const instance = this.getInstance(systemId, instanceId);
@@ -72,19 +84,23 @@ class InstanceManager {
             case types_1.InstanceType.DOCKER:
                 return await containerManager_1.containerManager.getLogs(instance);
             case types_1.InstanceType.UNKNOWN:
-                return [{
+                return [
+                    {
                         level: 'INFO',
                         message: 'Instance is starting...',
                         time: Date.now(),
                         source: 'stdout',
-                    }];
+                    },
+                ];
             case types_1.InstanceType.LOCAL:
-                return [{
+                return [
+                    {
                         level: 'INFO',
                         message: 'Instance started outside Kapeta - logs not available...',
                         time: Date.now(),
                         source: 'stdout',
-                    }];
+                    },
+                ];
         }
         return [];
     }
@@ -125,7 +141,8 @@ class InstanceManager {
             const address = await serviceManager_1.serviceManager.getProviderAddress(systemId, instanceId, info.portType ?? DEFAULT_HEALTH_PORT_TYPE);
             const healthUrl = this.getHealthUrl(info, address);
             if (instance) {
-                if (instance.status === types_1.InstanceStatus.STOPPING && instance.desiredStatus === types_1.DesiredInstanceStatus.STOP) {
+                if (instance.status === types_1.InstanceStatus.STOPPING &&
+                    instance.desiredStatus === types_1.DesiredInstanceStatus.STOP) {
                     //If instance is stopping do not interfere
                     return;
                 }
@@ -235,8 +252,7 @@ class InstanceManager {
             if (instance.status === types_1.InstanceStatus.STOPPED) {
                 return;
             }
-            if (changeDesired &&
-                instance.desiredStatus !== types_1.DesiredInstanceStatus.EXTERNAL) {
+            if (changeDesired && instance.desiredStatus !== types_1.DesiredInstanceStatus.EXTERNAL) {
                 instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
             }
             instance.status = types_1.InstanceStatus.STOPPING;
@@ -330,6 +346,24 @@ class InstanceManager {
             console.log('Starting instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
             // Save the instance before starting it, so that we can track the status
             await this.saveInternalInstance(instance);
+            const blockSpec = blockAsset.data.spec;
+            if (blockSpec.consumers) {
+                const promises = blockSpec.consumers.map((consumer) => {
+                    const consumerUri = (0, nodejs_utils_1.parseKapetaUri)(consumer.kind);
+                    const asset = definitionsManager_1.definitionsManager.getDefinition(consumer.kind);
+                    if (!asset) {
+                        // Definition not found
+                        return Promise.resolve();
+                    }
+                    if (operatorManager_1.KIND_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
+                        // Not an operator
+                        return Promise.resolve();
+                    }
+                    console.log('Ensuring resource: %s in %s', consumerUri.id, systemId);
+                    return operatorManager_1.operatorManager.ensureResource(systemId, consumerUri.fullName, consumerUri.version);
+                });
+                await Promise.all(promises);
+            }
             if (existingInstance) {
                 // Check if the instance is already running - but after we've commmuicated the desired status
                 const currentStatus = await this.requestInstanceStatus(existingInstance);
@@ -354,7 +388,7 @@ class InstanceManager {
                 });
             }
             catch (e) {
-                console.warn('Failed to start instance', e);
+                console.warn('Failed to start instance: ', systemId, instanceId, blockRef, e.message);
                 const logs = [
                     {
                         source: 'stdout',
@@ -365,11 +399,12 @@ class InstanceManager {
                 ];
                 const out = await this.saveInternalInstance({
                     ...instance,
-                    type: types_1.InstanceType.LOCAL,
+                    type: types_1.InstanceType.UNKNOWN,
                     pid: null,
                     health: null,
                     portType: DEFAULT_HEALTH_PORT_TYPE,
                     status: types_1.InstanceStatus.FAILED,
+                    errorMessage: e.message ?? 'Failed to start - Check logs for details.',
                 });
                 this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, logs[0]);
                 this.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
@@ -381,15 +416,16 @@ class InstanceManager {
             }
         });
     }
-    async restart(systemId, instanceId) {
+    /**
+     * Stops an instance but does not remove it from the list of active instances
+     *
+     * It will be started again next time the system checks the status of the instance
+     *
+     * We do it this way to not cause the user to wait for the instance to start again
+     */
+    async prepareForRestart(systemId, instanceId) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         await this.stopInner(systemId, instanceId);
-        const existingInstance = this.getInstance(systemId, instanceId);
-        if (existingInstance?.desiredStatus === types_1.DesiredInstanceStatus.STOP) {
-            // Internal instance was marked as stopped - abort restart
-            return existingInstance;
-        }
-        return this.start(systemId, instanceId);
     }
     async stopAll() {
         return this.stopInstances(this._instances);
@@ -447,8 +483,7 @@ class InstanceManager {
                     const oldStatus = instance.status;
                     const skipUpdate = (newStatus === types_1.InstanceStatus.STOPPED && instance.status === types_1.InstanceStatus.FAILED) ||
                         ([types_1.InstanceStatus.READY, types_1.InstanceStatus.UNHEALTHY].includes(newStatus) &&
-                            instance.status === types_1.InstanceStatus.STOPPING &&
-                            instance.desiredStatus === types_1.DesiredInstanceStatus.STOP) ||
+                            instance.status === types_1.InstanceStatus.STOPPING) ||
                         (newStatus === types_1.InstanceStatus.STOPPED &&
                             instance.status === types_1.InstanceStatus.STARTING &&
                             instance.desiredStatus === types_1.DesiredInstanceStatus.RUN);
@@ -488,7 +523,7 @@ class InstanceManager {
                     //If the instance is unhealthy, try to restart it
                     console.log('Restarting unhealthy instance', instance);
                     try {
-                        await this.restart(instance.systemId, instance.instanceId);
+                        await this.prepareForRestart(instance.systemId, instance.instanceId);
                     }
                     catch (e) {
                         console.warn('Failed to restart instance', instance.systemId, instance.instanceId, e);

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

@@ -122,8 +122,10 @@ router.put('/', async (req, res) => {
         const oldInstance = instanceManager_1.instanceManager.getInstance(req.kapeta.systemId, req.kapeta.instanceId);
         if (oldInstance) {
             instance.pid = oldInstance.pid;
+            instance.desiredStatus = oldInstance.desiredStatus;
         }
         instance.type = types_1.InstanceType.DOCKER;
+        instance.owner = types_1.InstanceOwner.INTERNAL;
     }
     else {
         // Coming from user starting the instance outside of kapeta

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

@@ -1,5 +1,6 @@
 import { ContainerInfo } from './containerManager';
 import { EnvironmentType, OperatorInfo } from './types';
+export declare const KIND_OPERATOR = "core/resource-type-operator";
 declare class Operator {
     private _data;
     constructor(data: any);
@@ -8,6 +9,7 @@ declare class Operator {
 }
 declare class OperatorManager {
     private _mountDir;
+    private operatorLock;
     constructor();
     _getMountPoint(operatorType: string, mountName: string): string;
     /**