@kapeta/local-cluster-service 0.12.0 → 0.13.0

package/dist/cjs/src/instanceManager.js

@@ -19,6 +19,7 @@ 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 taskManager_1 = require("./taskManager");
 const CHECK_INTERVAL = 5000;
 const DEFAULT_HEALTH_PORT_TYPE = 'rest';
 const EVENT_STATUS_CHANGED = 'status-changed';
@@ -55,7 +56,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);
@@ -211,27 +218,37 @@ class InstanceManager {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const plan = await assetManager_1.assetManager.getPlan(systemId, true);
         if (!plan) {
-            throw new Error('Plan not found: ' + systemId);
+            throw new Error(`Plan not found: ${systemId}`);
         }
         if (!plan.spec.blocks) {
-            console.warn('No blocks found in plan', systemId);
-            return [];
+            throw new Error(`No blocks found in plan: ${systemId}`);
         }
-        let promises = [];
-        let errors = [];
-        for (let blockInstance of Object.values(plan.spec.blocks)) {
-            try {
-                promises.push(this.start(systemId, blockInstance.id));
+        return taskManager_1.taskManager.add(`plan:start:${systemId}`, async () => {
+            let promises = [];
+            let errors = [];
+            for (let blockInstance of Object.values(plan.spec.blocks)) {
+                try {
+                    promises.push(this.start(systemId, blockInstance.id).then((taskOrInstance) => {
+                        if (taskOrInstance instanceof taskManager_1.Task) {
+                            return taskOrInstance.wait();
+                        }
+                        return taskOrInstance;
+                    }));
+                }
+                catch (e) {
+                    errors.push(e);
+                }
             }
-            catch (e) {
-                errors.push(e);
+            const settled = await Promise.allSettled(promises);
+            if (errors.length > 0) {
+                throw errors[0];
             }
-        }
-        const settled = await Promise.allSettled(promises);
-        if (errors.length > 0) {
-            throw errors[0];
-        }
-        return settled.map((p) => (p.status === 'fulfilled' ? p.value : null)).filter((p) => !!p);
+            return settled
+                .map((p) => (p.status === 'fulfilled' ? p.value : null))
+                .filter((p) => !!p);
+        }, {
+            name: `Starting plan ${systemId}`,
+        });
     }
     async stop(systemId, instanceId) {
         return this.stopInner(systemId, instanceId, true);
@@ -288,10 +305,14 @@ class InstanceManager {
             }
         });
     }
-    async stopAllForPlan(systemId) {
+    stopAllForPlan(systemId) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const instancesForPlan = this._instances.filter((instance) => instance.systemId === systemId);
-        return this.stopInstances(instancesForPlan);
+        return taskManager_1.taskManager.add(`plan:stop:${systemId}`, async () => {
+            return this.stopInstances(instancesForPlan);
+        }, {
+            name: `Stopping plan ${systemId}`,
+        });
     }
     async start(systemId, instanceId) {
         return this.exclusive(systemId, instanceId, async () => {
@@ -367,47 +388,53 @@ class InstanceManager {
                 }
             }
             const instanceConfig = await configManager_1.configManager.getConfigForSection(systemId, instanceId);
-            const runner = new BlockInstanceRunner_1.BlockInstanceRunner(systemId);
-            const startTime = Date.now();
-            try {
-                const processInfo = await runner.start(blockRef, instanceId, instanceConfig);
-                instance.status = types_1.InstanceStatus.READY;
-                return this.saveInternalInstance({
-                    ...instance,
-                    type: processInfo.type,
-                    pid: processInfo.pid ?? -1,
-                    health: null,
-                    portType: processInfo.portType,
-                    status: types_1.InstanceStatus.READY,
-                });
-            }
-            catch (e) {
-                console.warn('Failed to start instance: ', systemId, instanceId, blockRef, e.message);
-                const logs = [
-                    {
-                        source: 'stdout',
-                        level: 'ERROR',
-                        message: e.message,
-                        time: Date.now(),
-                    },
-                ];
-                const out = await this.saveInternalInstance({
-                    ...instance,
-                    type: types_1.InstanceType.LOCAL,
-                    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, {
-                    error: `Failed to start instance: ${e.message}`,
-                    status: EVENT_INSTANCE_EXITED,
-                    instanceId: blockInstance.id,
-                });
-                return out;
-            }
+            const task = taskManager_1.taskManager.add(`instance:start:${systemId}:${instanceId}`, async () => {
+                const runner = new BlockInstanceRunner_1.BlockInstanceRunner(systemId);
+                const startTime = Date.now();
+                try {
+                    const processInfo = await runner.start(blockRef, instanceId, instanceConfig);
+                    instance.status = types_1.InstanceStatus.READY;
+                    return this.saveInternalInstance({
+                        ...instance,
+                        type: processInfo.type,
+                        pid: processInfo.pid ?? -1,
+                        health: null,
+                        portType: processInfo.portType,
+                        status: types_1.InstanceStatus.READY,
+                    });
+                }
+                catch (e) {
+                    console.warn('Failed to start instance: ', systemId, instanceId, blockRef, e.message);
+                    const logs = [
+                        {
+                            source: 'stdout',
+                            level: 'ERROR',
+                            message: e.message,
+                            time: Date.now(),
+                        },
+                    ];
+                    const out = await this.saveInternalInstance({
+                        ...instance,
+                        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, {
+                        error: `Failed to start instance: ${e.message}`,
+                        status: EVENT_INSTANCE_EXITED,
+                        instanceId: blockInstance.id,
+                    });
+                    return out;
+                }
+            }, {
+                name: `Starting instance: ${instance.name}`,
+                systemId,
+            });
+            return task;
         });
     }
     /**

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

@@ -10,6 +10,7 @@ const cors_1 = require("../middleware/cors");
 const kapeta_1 = require("../middleware/kapeta");
 const stringBody_1 = require("../middleware/stringBody");
 const types_1 = require("../types");
+const taskManager_1 = require("../taskManager");
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', kapeta_1.kapetaHeaders);
@@ -29,33 +30,40 @@ router.get('/:systemId/instances', (req, res) => {
  * Start all instances in a plan
  */
 router.post('/:systemId/start', async (req, res) => {
-    const instances = await instanceManager_1.instanceManager.startAllForPlan(req.params.systemId);
+    const task = await instanceManager_1.instanceManager.startAllForPlan(req.params.systemId);
     res.status(202).send({
         ok: true,
-        processes: instances.map((p) => {
-            return { pid: p.pid, type: p.type };
-        }),
+        taskId: task.id,
     });
 });
 /**
  * Stop all instances in plan
  */
 router.post('/:systemId/stop', async (req, res) => {
-    await instanceManager_1.instanceManager.stopAllForPlan(req.params.systemId);
+    const task = instanceManager_1.instanceManager.stopAllForPlan(req.params.systemId);
     res.status(202).send({
         ok: true,
+        taskId: task.id,
     });
 });
 /**
  * Start single instance in a plan
  */
 router.post('/:systemId/:instanceId/start', async (req, res) => {
-    const process = await instanceManager_1.instanceManager.start(req.params.systemId, req.params.instanceId);
-    res.status(202).send({
-        ok: true,
-        pid: process.pid,
-        type: process.type,
-    });
+    const result = await instanceManager_1.instanceManager.start(req.params.systemId, req.params.instanceId);
+    if (result instanceof taskManager_1.Task) {
+        res.status(202).send({
+            ok: true,
+            taskId: result.id,
+        });
+    }
+    else {
+        res.status(202).send({
+            ok: true,
+            pid: result.pid,
+            type: result.type,
+        });
+    }
 });
 /**
  * Stop single instance in a plan
@@ -122,8 +130,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,10 +1,12 @@
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 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);
-    getData(): any;
+    private readonly _data;
+    constructor(data: DefinitionInfo);
+    getLocalData(): any;
+    getDefinitionInfo(): DefinitionInfo;
     getCredentials(): any;
 }
 declare class OperatorManager {

package/dist/cjs/src/operatorManager.js

@@ -15,17 +15,21 @@ const definitionsManager_1 = require("./definitionsManager");
 const utils_1 = require("./utils/utils");
 const lodash_1 = __importDefault(require("lodash"));
 const async_lock_1 = __importDefault(require("async-lock"));
+const taskManager_1 = require("./taskManager");
 exports.KIND_OPERATOR = 'core/resource-type-operator';
 class Operator {
     _data;
     constructor(data) {
         this._data = data;
     }
-    getData() {
+    getLocalData() {
+        return this._data.definition.spec.local;
+    }
+    getDefinitionInfo() {
         return this._data;
     }
     getCredentials() {
-        return this._data.credentials;
+        return this._data.definition.spec.local.credentials;
     }
 }
 class OperatorManager {
@@ -58,7 +62,7 @@ class OperatorManager {
         if (!operator.definition.spec || !operator.definition.spec.local) {
             throw new Error(`Operator missing local definition: ${resourceType}:${version}`);
         }
-        return new Operator(operator.definition.spec.local);
+        return new Operator(operator);
     }
     /**
      * Get information about a specific consumed resource
@@ -119,7 +123,7 @@ class OperatorManager {
         const key = `${systemId}#${resourceType}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
             const operator = this.getOperator(resourceType, version);
-            const operatorData = operator.getData();
+            const operatorData = operator.getLocalData();
             const portTypes = Object.keys(operatorData.ports);
             portTypes.sort();
             const ports = {};
@@ -147,6 +151,7 @@ class OperatorManager {
             const Labels = {
                 kapeta: 'true',
             };
+            const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
             const bindHost = (0, utils_1.getBindHost)();
             const ExposedPorts = {};
             lodash_1.default.forEach(ports, (portInfo, containerPort) => {
@@ -163,25 +168,32 @@ class OperatorManager {
             lodash_1.default.forEach(operatorData.env, (value, name) => {
                 Env.push(name + '=' + value);
             });
-            let HealthCheck = undefined;
-            if (operatorData.health) {
-                HealthCheck = containerManager_1.containerManager.toDockerHealth(operatorData.health);
-            }
-            const container = await containerManager_1.containerManager.ensureContainer({
-                name: containerName,
-                Image: operatorData.image,
-                Hostname: containerName + '.kapeta',
-                Labels,
-                Cmd: operatorData.cmd,
-                ExposedPorts,
-                Env,
-                HealthCheck,
-                HostConfig: {
-                    PortBindings,
-                    Mounts,
-                },
+            const task = taskManager_1.taskManager.add(`operator:ensure:${key}`, async () => {
+                let HealthCheck = undefined;
+                if (operatorData.health) {
+                    HealthCheck = containerManager_1.containerManager.toDockerHealth(operatorData.health);
+                }
+                const container = await containerManager_1.containerManager.ensureContainer({
+                    name: containerName,
+                    Image: operatorData.image,
+                    Hostname: containerName + '.kapeta',
+                    Labels,
+                    Cmd: operatorData.cmd,
+                    ExposedPorts,
+                    Env,
+                    HealthCheck,
+                    HostConfig: {
+                        PortBindings,
+                        Mounts,
+                    },
+                });
+                await containerManager_1.containerManager.waitForReady(container);
+                return new containerManager_1.ContainerInfo(container);
+            }, {
+                name: `Ensuring ${operatorMetadata.title ?? operatorMetadata.name}`,
+                systemId,
             });
-            return new containerManager_1.ContainerInfo(container);
+            return task.wait();
         });
     }
 }

package/dist/cjs/src/providerManager.js

@@ -22,7 +22,7 @@ class ProviderManager {
         if (this._webAssetCache[id] && (await fs_extra_1.default.pathExists(this._webAssetCache[id]))) {
             return fs_extra_1.default.readFile(this._webAssetCache[id], 'utf8');
         }
-        await repositoryManager_1.repositoryManager.ensureAsset(handle, name, version);
+        await repositoryManager_1.repositoryManager.ensureAsset(handle, name, version, true);
         const installedProvider = this.getWebProviders().find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });

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

@@ -1,17 +1,15 @@
+import { Task } from './taskManager';
 declare class RepositoryManager {
     private changeEventsEnabled;
     private _registryService;
     private _cache;
     private watcher?;
-    private _installQueue;
-    private _processing;
     constructor();
     setChangeEventsEnabled(enabled: boolean): void;
     listenForChanges(): void;
     stopListening(): void;
     private _install;
-    _processNext(): Promise<void>;
-    ensureAsset(handle: string, name: string, version: string): Promise<void>;
+    ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;
 }
 export declare const repositoryManager: RepositoryManager;
 export {};

package/dist/cjs/src/repositoryManager.js

@@ -15,20 +15,20 @@ const socketManager_1 = require("./socketManager");
 const progressListener_1 = require("./progressListener");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const definitionsManager_1 = require("./definitionsManager");
+const taskManager_1 = require("./taskManager");
+const utils_1 = require("./utils/utils");
+const assetManager_1 = require("./assetManager");
 const INSTALL_ATTEMPTED = {};
 class RepositoryManager {
     changeEventsEnabled;
     _registryService;
     _cache;
     watcher;
-    _installQueue;
-    _processing = false;
     constructor() {
         this.changeEventsEnabled = true;
         this.listenForChanges();
         this._registryService = new nodejs_registry_utils_1.RegistryService(nodejs_registry_utils_1.Config.data.registry.url);
         this._cache = {};
-        this._installQueue = [];
     }
     setChangeEventsEnabled(enabled) {
         this.changeEventsEnabled = enabled;
@@ -109,74 +109,54 @@ class RepositoryManager {
     }
     async _install(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
-        const out = new Promise((resolve, reject) => {
-            this._installQueue.push(async () => {
-                try {
-                    const normalizedRefs = refs.map((ref) => (0, nodejs_utils_1.parseKapetaUri)(ref).id);
-                    const filteredRefs = normalizedRefs
-                        .filter((ref) => !INSTALL_ATTEMPTED[ref])
-                        .filter((ref) => !definitionsManager_1.definitionsManager.exists(ref));
-                    if (filteredRefs.length > 0) {
-                        console.log(`Auto-installing dependencies: ${filteredRefs.join(', ')}`);
-                        filteredRefs.forEach((ref) => (INSTALL_ATTEMPTED[ref] = true));
-                        //Auto-install missing asset
-                        try {
-                            //We change to a temp dir to avoid issues with the current working directory
-                            process.chdir(node_os_1.default.tmpdir());
-                            //Disable change events while installing
-                            this.setChangeEventsEnabled(false);
-                            socketManager_1.socketManager.emit(`install`, 'install:action', {
-                                type: 'start',
-                                refs,
-                            });
-                            await nodejs_registry_utils_1.Actions.install(progressListener_1.progressListener, normalizedRefs, {});
-                            socketManager_1.socketManager.emit(`install`, 'install:action', {
-                                type: 'done',
-                                refs,
-                            });
-                        }
-                        catch (e) {
-                            socketManager_1.socketManager.emit(`install`, 'install:action', {
-                                type: 'failed',
-                                refs,
-                                error: e.message,
-                            });
-                        }
-                        finally {
-                            this.setChangeEventsEnabled(true);
-                        }
-                    }
-                    resolve();
+        const createInstaller = (ref) => {
+            return async () => {
+                if (INSTALL_ATTEMPTED[ref]) {
+                    return;
                 }
-                catch (e) {
-                    reject(e);
+                if (definitionsManager_1.definitionsManager.exists(ref)) {
+                    return;
                 }
-                finally {
-                    this._processNext().catch((e) => console.error(e));
+                console.log(`Installing asset: ${ref}`);
+                INSTALL_ATTEMPTED[ref] = true;
+                //Auto-install missing asset
+                try {
+                    //We change to a temp dir to avoid issues with the current working directory
+                    process.chdir(node_os_1.default.tmpdir());
+                    //Disable change events while installing
+                    this.setChangeEventsEnabled(false);
+                    await nodejs_registry_utils_1.Actions.install(progressListener_1.progressListener, [ref], {});
                 }
-            });
-        });
-        this._processNext().catch((e) => console.error(e));
-        return out;
-    }
-    async _processNext() {
-        if (this._processing) {
-            return;
-        }
-        this._processing = true;
-        try {
-            while (this._installQueue.length > 0) {
-                const item = this._installQueue.shift();
-                if (item) {
-                    await item();
+                finally {
+                    this.setChangeEventsEnabled(true);
                 }
+                definitionsManager_1.definitionsManager.clearCache();
+                assetManager_1.assetManager.clearCache();
+                console.log(`Asset installed: ${ref}`);
+            };
+        };
+        const tasks = [];
+        while (refs.length > 0) {
+            let ref = refs.shift();
+            if (!ref) {
+                continue;
             }
+            ref = (0, utils_1.normalizeKapetaUri)(ref);
+            if (INSTALL_ATTEMPTED[ref]) {
+                continue;
+            }
+            if (definitionsManager_1.definitionsManager.exists(ref)) {
+                continue;
+            }
+            const task = taskManager_1.taskManager.add(`asset:install:${ref}`, createInstaller(ref), {
+                name: `Installing ${ref}`,
+                group: 'asset:install:',
+            });
+            tasks.push(task);
         }
-        finally {
-            this._processing = false;
-        }
+        return tasks;
     }
-    async ensureAsset(handle, name, version) {
+    async ensureAsset(handle, name, version, wait = true) {
         const fullName = `${handle}/${name}`;
         const ref = `${fullName}:${version}`;
         if (version === 'local') {
@@ -207,16 +187,21 @@ class RepositoryManager {
             throw e;
         }
         this._cache[ref] = true;
+        let tasks = undefined;
         if (!installedAsset) {
-            await this._install([ref]);
+            tasks = await this._install([ref]);
         }
         else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep) => dep.name);
             if (refs.length > 0) {
-                await this._install(refs);
+                tasks = await this._install(refs);
             }
         }
+        if (tasks && wait) {
+            await Promise.all(tasks.map((t) => t.future.promise));
+        }
+        return tasks;
     }
 }
 exports.repositoryManager = new RepositoryManager();

package/dist/cjs/src/socketManager.js

@@ -30,7 +30,7 @@ class SocketManager {
         this.io.to(context).emit(type, { context, payload });
     }
     emitGlobal(type, payload) {
-        this.io.emit(type, { payload });
+        this.io.emit(type, payload);
     }
     _bindIO() {
         this.io.on('connection', (socket) => this._handleSocketCreated(socket));

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

@@ -0,0 +1,64 @@
+export type TaskRunner<T> = (task: Task<T>) => Promise<T>;
+export declare enum TaskStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED"
+}
+interface Future<T = void> {
+    promise: Promise<T>;
+    resolve: (result: T) => void;
+    reject: (e: any) => void;
+}
+interface TaskMetadata {
+    name: string;
+    /**
+     * A unique prefix for the task. If defined only 1 task with this ID prefix will be executed at a time
+     */
+    group?: string;
+    progress?: number;
+    [key: string]: any;
+}
+interface TaskData<T = void> {
+    id: string;
+    status: TaskStatus;
+    errorMessage?: string;
+    metadata: TaskMetadata;
+    future: Future<T>;
+    run: TaskRunner<T>;
+}
+export declare class Task<T = void> implements TaskData<T> {
+    private data;
+    constructor(task: TaskData<T>);
+    get id(): string;
+    get status(): TaskStatus;
+    get errorMessage(): string | undefined;
+    get metadata(): TaskMetadata;
+    get future(): Future<T>;
+    get run(): TaskRunner<T>;
+    set status(status: TaskStatus);
+    set errorMessage(errorMessage: string | undefined);
+    set metadata(metadata: TaskMetadata);
+    emitUpdate(): void;
+    wait(): Promise<T>;
+    toData(): {
+        id: string;
+        status: TaskStatus;
+        errorMessage?: string | undefined;
+        metadata: TaskMetadata;
+        future: Future<T>;
+        run: TaskRunner<T>;
+    };
+}
+declare class TaskManager {
+    private _tasks;
+    add<T>(id: string, runner: TaskRunner<T>, metadata: TaskMetadata): Task<T>;
+    waitFor(filter: (task: Task<any>) => boolean): Promise<void>;
+    get(taskId: string): Task<any> | undefined;
+    exists(taskId: string): boolean;
+    remove(taskId: string): void;
+    list(): TaskData[];
+    private invokeTask;
+}
+export declare const taskManager: TaskManager;
+export {};