@kapeta/local-cluster-service 0.11.1 → 0.12.1

package/dist/esm/src/instanceManager.js

@@ -10,6 +10,9 @@ import { containerManager, HEALTH_CHECK_TIMEOUT } from './containerManager';
 import { configManager } from './configManager';
 import { DesiredInstanceStatus, InstanceOwner, InstanceStatus, InstanceType } from './types';
 import { getBlockInstanceContainerName, normalizeKapetaUri } from './utils/utils';
+import { KIND_OPERATOR, operatorManager } from './operatorManager';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { definitionsManager } from './definitionsManager';
 const CHECK_INTERVAL = 5000;
 const DEFAULT_HEALTH_PORT_TYPE = 'rest';
 const EVENT_STATUS_CHANGED = 'status-changed';
@@ -46,7 +49,13 @@ export class InstanceManager {
             return [];
         }
         systemId = normalizeKapetaUri(systemId);
-        return this._instances.filter((instance) => instance.systemId === systemId);
+        const planInfo = 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 = normalizeKapetaUri(systemId);
@@ -55,7 +64,10 @@ export class InstanceManager {
     async exclusive(systemId, instanceId, fn) {
         systemId = 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);
@@ -66,19 +78,23 @@ export class InstanceManager {
             case InstanceType.DOCKER:
                 return await containerManager.getLogs(instance);
             case InstanceType.UNKNOWN:
-                return [{
+                return [
+                    {
                         level: 'INFO',
                         message: 'Instance is starting...',
                         time: Date.now(),
                         source: 'stdout',
-                    }];
+                    },
+                ];
             case InstanceType.LOCAL:
-                return [{
+                return [
+                    {
                         level: 'INFO',
                         message: 'Instance started outside Kapeta - logs not available...',
                         time: Date.now(),
                         source: 'stdout',
-                    }];
+                    },
+                ];
         }
         return [];
     }
@@ -119,7 +135,8 @@ export class InstanceManager {
             const address = await serviceManager.getProviderAddress(systemId, instanceId, info.portType ?? DEFAULT_HEALTH_PORT_TYPE);
             const healthUrl = this.getHealthUrl(info, address);
             if (instance) {
-                if (instance.status === InstanceStatus.STOPPING && instance.desiredStatus === DesiredInstanceStatus.STOP) {
+                if (instance.status === InstanceStatus.STOPPING &&
+                    instance.desiredStatus === DesiredInstanceStatus.STOP) {
                     //If instance is stopping do not interfere
                     return;
                 }
@@ -229,8 +246,7 @@ export class InstanceManager {
             if (instance.status === InstanceStatus.STOPPED) {
                 return;
             }
-            if (changeDesired &&
-                instance.desiredStatus !== DesiredInstanceStatus.EXTERNAL) {
+            if (changeDesired && instance.desiredStatus !== DesiredInstanceStatus.EXTERNAL) {
                 instance.desiredStatus = DesiredInstanceStatus.STOP;
             }
             instance.status = InstanceStatus.STOPPING;
@@ -324,6 +340,24 @@ export 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 = parseKapetaUri(consumer.kind);
+                    const asset = definitionsManager.getDefinition(consumer.kind);
+                    if (!asset) {
+                        // Definition not found
+                        return Promise.resolve();
+                    }
+                    if (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.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);
@@ -348,7 +382,7 @@ export 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',
@@ -359,11 +393,12 @@ export class InstanceManager {
                 ];
                 const out = await this.saveInternalInstance({
                     ...instance,
-                    type: InstanceType.LOCAL,
+                    type: InstanceType.UNKNOWN,
                     pid: null,
                     health: null,
                     portType: DEFAULT_HEALTH_PORT_TYPE,
                     status: 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, {
@@ -375,15 +410,16 @@ export 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 = normalizeKapetaUri(systemId);
         await this.stopInner(systemId, instanceId);
-        const existingInstance = this.getInstance(systemId, instanceId);
-        if (existingInstance?.desiredStatus === DesiredInstanceStatus.STOP) {
-            // Internal instance was marked as stopped - abort restart
-            return existingInstance;
-        }
-        return this.start(systemId, instanceId);
     }
     async stopAll() {
         return this.stopInstances(this._instances);
@@ -441,8 +477,7 @@ export class InstanceManager {
                     const oldStatus = instance.status;
                     const skipUpdate = (newStatus === InstanceStatus.STOPPED && instance.status === InstanceStatus.FAILED) ||
                         ([InstanceStatus.READY, InstanceStatus.UNHEALTHY].includes(newStatus) &&
-                            instance.status === InstanceStatus.STOPPING &&
-                            instance.desiredStatus === DesiredInstanceStatus.STOP) ||
+                            instance.status === InstanceStatus.STOPPING) ||
                         (newStatus === InstanceStatus.STOPPED &&
                             instance.status === InstanceStatus.STARTING &&
                             instance.desiredStatus === DesiredInstanceStatus.RUN);
@@ -482,7 +517,7 @@ export 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/esm/src/instances/routes.js

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

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

package/dist/esm/src/operatorManager.js

@@ -8,7 +8,8 @@ import FSExtra from 'fs-extra';
 import { definitionsManager } from './definitionsManager';
 import { getBindHost, normalizeKapetaUri } from './utils/utils';
 import _ from 'lodash';
-const KIND_OPERATOR = 'core/resource-type-operator';
+import AsyncLock from 'async-lock';
+export const KIND_OPERATOR = 'core/resource-type-operator';
 class Operator {
     _data;
     constructor(data) {
@@ -23,6 +24,7 @@ class Operator {
 }
 class OperatorManager {
     _mountDir;
+    operatorLock = new AsyncLock();
     constructor() {
         this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
         FSExtra.mkdirpSync(this._mountDir);
@@ -107,74 +109,75 @@ class OperatorManager {
      * @return {Promise<ContainerInfo>}
      */
     async ensureResource(systemId, resourceType, version) {
-        const operator = this.getOperator(resourceType, version);
-        const operatorData = operator.getData();
-        const portTypes = Object.keys(operatorData.ports);
-        portTypes.sort();
-        const ports = {};
-        for (let i = 0; i < portTypes.length; i++) {
-            const portType = portTypes[i];
-            let containerPortInfo = operatorData.ports[portType];
-            const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
-            if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
-                containerPortInfo = { port: containerPortInfo, type: 'tcp' };
-            }
-            if (!containerPortInfo.type) {
-                containerPortInfo.type = 'tcp';
+        systemId = normalizeKapetaUri(systemId);
+        const key = `${systemId}#${resourceType}:${version}`;
+        return await this.operatorLock.acquire(key, async () => {
+            const operator = this.getOperator(resourceType, version);
+            const operatorData = operator.getData();
+            const portTypes = Object.keys(operatorData.ports);
+            portTypes.sort();
+            const ports = {};
+            for (let i = 0; i < portTypes.length; i++) {
+                const portType = portTypes[i];
+                let containerPortInfo = operatorData.ports[portType];
+                const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
+                if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
+                    containerPortInfo = { port: containerPortInfo, type: 'tcp' };
+                }
+                if (!containerPortInfo.type) {
+                    containerPortInfo.type = 'tcp';
+                }
+                const portId = containerPortInfo.port + '/' + containerPortInfo.type;
+                ports[portId] = {
+                    type: portType,
+                    hostPort,
+                };
             }
-            const portId = containerPortInfo.port + '/' + containerPortInfo.type;
-            ports[portId] = {
-                type: portType,
-                hostPort,
+            const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
+            const nameParts = [systemId, resourceType.toLowerCase(), version];
+            const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
+            const PortBindings = {};
+            const Env = [];
+            const Labels = {
+                kapeta: 'true',
             };
-        }
-        const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
-        const nameParts = [
-            systemId,
-            resourceType.toLowerCase(),
-            version
-        ];
-        const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
-        const PortBindings = {};
-        const Env = [];
-        const Labels = {
-            kapeta: 'true',
-        };
-        const bindHost = getBindHost();
-        const ExposedPorts = {};
-        _.forEach(ports, (portInfo, containerPort) => {
-            ExposedPorts['' + containerPort] = {};
-            PortBindings['' + containerPort] = [
-                {
-                    HostPort: '' + portInfo.hostPort,
-                    HostIp: bindHost,
+            const bindHost = getBindHost();
+            const ExposedPorts = {};
+            _.forEach(ports, (portInfo, containerPort) => {
+                ExposedPorts['' + containerPort] = {};
+                PortBindings['' + containerPort] = [
+                    {
+                        HostPort: '' + portInfo.hostPort,
+                        HostIp: bindHost,
+                    },
+                ];
+                Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+            });
+            const Mounts = containerManager.toDockerMounts(mounts);
+            _.forEach(operatorData.env, (value, name) => {
+                Env.push(name + '=' + value);
+            });
+            let HealthCheck = undefined;
+            if (operatorData.health) {
+                HealthCheck = containerManager.toDockerHealth(operatorData.health);
+            }
+            const container = await containerManager.ensureContainer({
+                name: containerName,
+                Image: operatorData.image,
+                Hostname: containerName + '.kapeta',
+                Labels,
+                Cmd: operatorData.cmd,
+                ExposedPorts,
+                Env,
+                HealthCheck,
+                HostConfig: {
+                    PortBindings,
+                    Mounts,
                 },
-            ];
-            Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
-        });
-        const Mounts = containerManager.toDockerMounts(mounts);
-        _.forEach(operatorData.env, (value, name) => {
-            Env.push(name + '=' + value);
-        });
-        let HealthCheck = undefined;
-        if (operatorData.health) {
-            HealthCheck = containerManager.toDockerHealth(operatorData.health);
-        }
-        const container = await containerManager.ensureContainer({
-            name: containerName,
-            Image: operatorData.image,
-            Hostname: containerName + '.kapeta',
-            Labels,
-            Cmd: operatorData.cmd,
-            ExposedPorts,
-            Env,
-            HealthCheck,
-            HostConfig: {
-                PortBindings,
-                Mounts,
-            },
+            });
+            await containerManager.waitForReady(container);
+            return new ContainerInfo(container);
         });
-        return new ContainerInfo(container);
     }
 }
 export const operatorManager = new OperatorManager();

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

@@ -7,6 +7,7 @@ export declare class SocketManager {
     isAlive(): boolean;
     private get io();
     emit(context: string, type: string, payload: any): void;
+    emitGlobal(type: string, payload: any): void;
     _bindIO(): void;
     _handleSocketCreated(socket: Socket): void;
     _bindSocket(socket: Socket): void;

package/dist/esm/src/socketManager.js

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

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

@@ -58,6 +58,7 @@ export type InstanceInfo = {
     type: InstanceType;
     owner: InstanceOwner;
     status: InstanceStatus;
+    errorMessage?: string;
     desiredStatus: DesiredInstanceStatus;
     address?: string;
     startedAt?: number;

package/dist/esm/src/utils/BlockInstanceRunner.js

@@ -194,7 +194,7 @@ export class BlockInstanceRunner {
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
                 ...Object.entries({
                     ...env,
-                    ...addonEnv
+                    ...addonEnv,
                 }).map(([key, value]) => `${key}=${value}`),
             ],
             HostConfig: {
@@ -318,13 +318,12 @@ export class BlockInstanceRunner {
     }
     async ensureContainer(opts) {
         const container = await containerManager.ensureContainer(opts);
-        await containerManager.waitForReady(container);
         return this._handleContainer(container);
     }
     async _handleContainer(container) {
         return {
             type: InstanceType.DOCKER,
-            pid: container.id
+            pid: container.id,
         };
     }
 }

package/dist/esm/src/utils/utils.js

@@ -1,7 +1,7 @@
 import FS from 'node:fs';
 import YAML from 'yaml';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import md5 from "md5";
+import md5 from 'md5';
 export function getBlockInstanceContainerName(systemId, instanceId) {
     return `kapeta-block-instance-${md5(systemId + instanceId)}`;
 }

package/package.json

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

package/src/config/routes.ts

@@ -41,7 +41,7 @@ router.put('/instance', async (req: KapetaBodyRequest, 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.restart(req.kapeta!.systemId, req.kapeta!.instanceId);
+            await instanceManager.prepareForRestart(req.kapeta!.systemId, req.kapeta!.instanceId);
         } else {
             configManager.setConfigForSystem(req.kapeta!.systemId, config);
         }