@kapeta/local-cluster-service 0.34.2 → 0.36.0

package/dist/esm/src/instanceManager.js

@@ -256,10 +256,79 @@ class InstanceManager {
             name: `Starting plan ${systemId}`,
         });
     }
+    stopAllForPlan(systemId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const instancesForPlan = this._instances.filter((instance) => instance.systemId === systemId);
+        return taskManager_1.taskManager.add(`plan:stop:${systemId}`, async () => {
+            return this.stopInstances(instancesForPlan);
+        }, {
+            name: `Stopping plan ${systemId}`,
+        });
+    }
+    async getInstanceOperator(systemId, instanceId, environment) {
+        const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        if (!blockInstance) {
+            throw new Error(`Instance not found: ${systemId}/${instanceId}`);
+        }
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockInstance.block.ref);
+        const block = await assetManager_1.assetManager.getAsset(blockRef, true);
+        if (!block) {
+            throw new Error(`Block not found: ${blockRef}`);
+        }
+        const operatorDefinition = await definitionsManager_1.definitionsManager.getDefinition(block.kind);
+        if (!operatorDefinition?.definition.spec.local) {
+            throw new Error(`Operator block has no local definition: ${blockRef}`);
+        }
+        const localConfig = operatorDefinition.definition.spec.local;
+        let instance = await this.start(systemId, instanceId);
+        if (instance instanceof taskManager_1.Task) {
+            instance = await instance.wait();
+        }
+        const container = await containerManager_1.containerManager.get(instance.pid);
+        if (!container) {
+            throw new Error(`Container not found: ${instance.pid}`);
+        }
+        const portInfo = await container.getPorts();
+        if (!portInfo) {
+            throw new Error(`No ports found for instance: ${instanceId}`);
+        }
+        const hostname = serviceManager_1.serviceManager.getLocalHost(environment);
+        const ports = {};
+        Object.entries(portInfo).forEach(([key, value]) => {
+            ports[key] = {
+                protocol: value.protocol,
+                port: parseInt(value.hostPort),
+            };
+        });
+        return {
+            hostname,
+            ports,
+            credentials: localConfig.credentials,
+            options: localConfig.options,
+        };
+    }
     async stop(systemId, instanceId) {
         return this.stopInner(systemId, instanceId, true);
     }
-    async stopInner(systemId, instanceId, changeDesired = false) {
+    async stopInner(systemId, instanceId, changeDesired = false, checkForSingleton = true) {
+        if (checkForSingleton) {
+            const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+            const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockInstance.block.ref);
+            const blockAsset = await assetManager_1.assetManager.getAsset(blockRef, true);
+            if (!blockAsset) {
+                throw new Error('Block not found: ' + blockRef);
+            }
+            if (await this.isSingletonOperator(blockAsset)) {
+                const instances = await this.getAllInstancesForKind(systemId, blockAsset.data.kind);
+                if (instances.length > 1) {
+                    const promises = instances.map((id) => {
+                        return this.stopInner(systemId, id, changeDesired, false);
+                    });
+                    await Promise.all(promises);
+                    return;
+                }
+            }
+        }
         return this.exclusive(systemId, instanceId, async () => {
             systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
             const instance = this.getInstance(systemId, instanceId);
@@ -277,11 +346,11 @@ class InstanceManager {
             }
             instance.status = types_1.InstanceStatus.STOPPING;
             socketManager_1.socketManager.emitSystemEvent(systemId, socketManager_1.EVENT_STATUS_CHANGED, instance);
-            console.log('Stopping instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
+            console.log('Stopping instance: %s::%s [desired: %s] [intentional: %s]', systemId, instanceId, instance.desiredStatus, changeDesired);
             this.save();
             try {
                 if (instance.type === 'docker') {
-                    const containerName = (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
+                    const containerName = await (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
                     const container = await containerManager_1.containerManager.getContainerByName(containerName);
                     if (container) {
                         try {
@@ -314,26 +383,34 @@ class InstanceManager {
             }
         });
     }
-    stopAllForPlan(systemId) {
+    async start(systemId, instanceId, checkForSingleton = true) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
-        const instancesForPlan = this._instances.filter((instance) => instance.systemId === systemId);
-        return taskManager_1.taskManager.add(`plan:stop:${systemId}`, async () => {
-            return this.stopInstances(instancesForPlan);
-        }, {
-            name: `Stopping plan ${systemId}`,
-        });
-    }
-    async start(systemId, instanceId) {
+        const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockInstance.block.ref);
+        const blockAsset = await assetManager_1.assetManager.getAsset(blockRef, true);
+        if (!blockAsset) {
+            throw new Error('Block not found: ' + blockRef);
+        }
+        if (checkForSingleton && (await this.isSingletonOperator(blockAsset))) {
+            const instances = await this.getAllInstancesForKind(systemId, blockAsset.data.kind);
+            if (instances.length > 1) {
+                const promises = instances.map((id) => {
+                    return this.start(systemId, id, false);
+                });
+                await Promise.all(promises);
+                return promises[0];
+            }
+        }
         return this.exclusive(systemId, instanceId, async () => {
-            systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
-            const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
-            const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockInstance.block.ref);
-            const blockAsset = await assetManager_1.assetManager.getAsset(blockRef, true);
-            if (!blockAsset) {
-                throw new Error('Block not found: ' + blockRef);
+            let existingInstance = this.getInstance(systemId, instanceId);
+            if (existingInstance && existingInstance.pid) {
+                const container = await containerManager_1.containerManager.get(existingInstance.pid);
+                if (!container) {
+                    // The container is not running
+                    existingInstance = undefined;
+                }
             }
-            const existingInstance = this.getInstance(systemId, instanceId);
-            if (existingInstance) {
+            if (existingInstance?.pid) {
                 if (existingInstance.status === types_1.InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -372,7 +449,7 @@ class InstanceManager {
                         // Definition not found
                         return Promise.resolve();
                     }
-                    if (operatorManager_1.KIND_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
+                    if (operatorManager_1.KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
                         // Not an operator
                         return Promise.resolve();
                     }
@@ -382,7 +459,7 @@ class InstanceManager {
                         return Promise.resolve();
                     }
                     console.log('Ensuring resource: %s in %s', consumerUri.id, systemId);
-                    return operatorManager_1.operatorManager.ensureResource(systemId, consumerUri.fullName, consumerUri.version);
+                    return operatorManager_1.operatorManager.ensureOperator(systemId, consumerUri.fullName, consumerUri.version);
                 });
                 await Promise.all(promises);
             }
@@ -449,6 +526,7 @@ class InstanceManager {
      */
     async prepareForRestart(systemId, instanceId) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        console.log('Stopping instance during restart...', systemId, instanceId);
         await this.stopInner(systemId, instanceId);
     }
     async stopAll() {
@@ -476,8 +554,13 @@ class InstanceManager {
         while (all.length > 0) {
             // Check a few instances at a time - docker doesn't like too many concurrent requests
             const chunk = all.splice(0, 30);
-            const promises = chunk.map(async (instance) => {
-                if (!instance.systemId) {
+            const promises = chunk.map(async (oldInstance) => {
+                if (!oldInstance.systemId) {
+                    return;
+                }
+                // Grab the latest here
+                const instance = this.getInstance(oldInstance.systemId, oldInstance.instanceId);
+                if (!instance) {
                     return;
                 }
                 instance.systemId = (0, nodejs_utils_1.normalizeKapetaUri)(instance.systemId);
@@ -567,6 +650,7 @@ class InstanceManager {
                     [types_1.InstanceStatus.READY, types_1.InstanceStatus.STARTING, types_1.InstanceStatus.UNHEALTHY].includes(newStatus)) {
                     //If the instance is running but we want it to stop, stop it
                     try {
+                        console.log('Stopping instance since it is its desired state', instance.systemId, instance.instanceId);
                         await this.stopInner(instance.systemId, instance.instanceId);
                     }
                     catch (e) {
@@ -596,7 +680,7 @@ class InstanceManager {
     }
     async getExternalStatus(instance) {
         if (instance.type === types_1.InstanceType.DOCKER) {
-            const containerName = (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
+            const containerName = await (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
             const container = await containerManager_1.containerManager.getContainerByName(containerName);
             if (!container) {
                 // If the container doesn't exist, we consider the instance stopped
@@ -687,6 +771,44 @@ class InstanceManager {
             });
         });
     }
+    async isSingletonOperator(blockAsset) {
+        const provider = await assetManager_1.assetManager.getAsset(blockAsset.data.kind);
+        if (!provider) {
+            return false;
+        }
+        if ((0, nodejs_utils_1.parseKapetaUri)(provider.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR) {
+            const localConfig = provider.data.spec.local;
+            return localConfig.singleton ?? false;
+        }
+        return false;
+    }
+    async getKindForAssetRef(assetRef) {
+        const block = await assetManager_1.assetManager.getAsset(assetRef);
+        if (!block) {
+            return null;
+        }
+        return block.data.kind;
+    }
+    async isUsingKind(ref, kind) {
+        const assetKind = await this.getKindForAssetRef(ref);
+        if (!assetKind) {
+            return false;
+        }
+        return (0, nodejs_utils_1.parseKapetaUri)(assetKind).fullName === (0, nodejs_utils_1.parseKapetaUri)(kind).fullName;
+    }
+    async getAllInstancesForKind(systemId, kind) {
+        const plan = await assetManager_1.assetManager.getPlan(systemId);
+        if (!plan?.spec?.blocks) {
+            return [];
+        }
+        const out = [];
+        for (const block of plan.spec.blocks) {
+            if (await this.isUsingKind(block.block.ref, kind)) {
+                out.push(block.id);
+            }
+        }
+        return out;
+    }
 }
 exports.InstanceManager = InstanceManager;
 exports.instanceManager = new InstanceManager();

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

@@ -4,12 +4,13 @@
  */
 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";
+import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
+export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
+export declare const KIND_BLOCK_OPERATOR = "core/block-type-operator";
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);
-    getLocalData(): any;
+    getLocalData(): LocalImageOptions;
     getDefinitionInfo(): DefinitionInfo;
     getCredentials(): any;
 }
@@ -21,7 +22,7 @@ declare class OperatorManager {
     /**
      * Get operator definition for resource type
      */
-    getOperator(resourceType: string, version: string): Promise<Operator>;
+    getOperator(fullName: string, version: string): Promise<Operator>;
     /**
      * Get information about a specific consumed resource
      */
@@ -29,12 +30,11 @@ declare class OperatorManager {
     /**
      * Ensure we have a running operator of given type
      *
-     * @param {string} systemId
-     * @param {string} resourceType
-     * @param {string} version
-     * @return {Promise<ContainerInfo>}
+     * @param systemId the plan ref
+     * @param kind the full name - e.g. myhandle/rabbitmq
+     * @param version the version of the operator
      */
-    ensureResource(systemId: string, resourceType: string, version: string): Promise<ContainerInfo>;
+    ensureOperator(systemId: string, kind: string, version: string): Promise<ContainerInfo>;
 }
 export declare const operatorManager: OperatorManager;
 export {};

package/dist/esm/src/operatorManager.js

@@ -7,7 +7,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.operatorManager = exports.KIND_OPERATOR = void 0;
+exports.operatorManager = exports.KIND_BLOCK_OPERATOR = exports.KIND_RESOURCE_OPERATOR = void 0;
 const path_1 = __importDefault(require("path"));
 const md5_1 = __importDefault(require("md5"));
 const serviceManager_1 = require("./serviceManager");
@@ -20,7 +20,8 @@ const nodejs_utils_1 = require("@kapeta/nodejs-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';
+exports.KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
+exports.KIND_BLOCK_OPERATOR = 'core/block-type-operator';
 const KIND_PLAN = 'core/plan';
 class Operator {
     _data;
@@ -50,18 +51,18 @@ class OperatorManager {
     /**
      * Get operator definition for resource type
      */
-    async getOperator(resourceType, version) {
-        const operators = await definitionsManager_1.definitionsManager.getDefinitions(exports.KIND_OPERATOR);
+    async getOperator(fullName, version) {
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions([exports.KIND_RESOURCE_OPERATOR, exports.KIND_BLOCK_OPERATOR]);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
-            operator.definition.metadata.name.toLowerCase() === resourceType.toLowerCase() &&
+            operator.definition.metadata.name.toLowerCase() === fullName.toLowerCase() &&
             operator.version === version);
         if (!operator) {
-            throw new Error(`Unknown resource type: ${resourceType}:${version}`);
+            throw new Error(`Unknown operator type: ${fullName}:${version}`);
         }
         if (!operator.definition.spec || !operator.definition.spec.local) {
-            throw new Error(`Operator missing local definition: ${resourceType}:${version}`);
+            throw new Error(`Operator missing local definition: ${fullName}:${version}`);
         }
         return new Operator(operator);
     }
@@ -96,7 +97,7 @@ class OperatorManager {
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(blockResource.kind);
         const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
-        const container = await this.ensureResource(systemId, resourceType, kindUri.version);
+        const container = await this.ensureOperator(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
         if (!portInfo) {
             throw new Error('Unknown resource port type : ' + resourceType + '#' + portType);
@@ -119,16 +120,15 @@ class OperatorManager {
     /**
      * Ensure we have a running operator of given type
      *
-     * @param {string} systemId
-     * @param {string} resourceType
-     * @param {string} version
-     * @return {Promise<ContainerInfo>}
+     * @param systemId the plan ref
+     * @param kind the full name - e.g. myhandle/rabbitmq
+     * @param version the version of the operator
      */
-    async ensureResource(systemId, resourceType, version) {
+    async ensureOperator(systemId, kind, version) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
-        const key = `${systemId}#${resourceType}:${version}`;
+        const key = `${systemId}#${kind}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
-            const operator = await this.getOperator(resourceType, version);
+            const operator = await this.getOperator(kind, version);
             const operatorData = operator.getLocalData();
             const portTypes = Object.keys(operatorData.ports);
             portTypes.sort();
@@ -136,20 +136,15 @@ class OperatorManager {
             for (let i = 0; i < portTypes.length; i++) {
                 const portType = portTypes[i];
                 let containerPortInfo = operatorData.ports[portType];
-                const hostPort = await serviceManager_1.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;
+                const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, kind, portType);
+                const portInfo = (0, utils_1.toPortInfo)(containerPortInfo);
+                const portId = portInfo.port + '/' + portInfo.type;
                 ports[portId] = {
                     type: portType,
                     hostPort,
                 };
             }
-            const nameParts = [systemId, resourceType.toLowerCase(), version];
+            const nameParts = [systemId, kind.toLowerCase(), version];
             const containerName = `kapeta-resource-${(0, md5_1.default)(nameParts.join('_'))}`;
             const PortBindings = {};
             const Env = [];
@@ -157,7 +152,7 @@ class OperatorManager {
             const Labels = {
                 kapeta: 'true',
                 [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
-                [containerManager_1.COMPOSE_LABEL_SERVICE]: [resourceType, version].join('_').replace(/[^a-z0-9]/gi, '_'),
+                [containerManager_1.COMPOSE_LABEL_SERVICE]: [kind, version].join('_').replace(/[^a-z0-9]/gi, '_'),
             };
             const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
             const bindHost = (0, utils_1.getBindHost)();
@@ -172,7 +167,7 @@ class OperatorManager {
                 ];
                 Labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
             });
-            const Mounts = await containerManager_1.containerManager.createVolumes(systemId, resourceType, operatorData.mounts);
+            const Mounts = await containerManager_1.containerManager.createVolumes(systemId, kind, operatorData.mounts);
             lodash_1.default.forEach(operatorData.env, (value, name) => {
                 Env.push(name + '=' + value);
             });

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

@@ -9,6 +9,7 @@ export declare const HTTP_PORTS: string[];
 declare class ServiceManager {
     private _systems;
     constructor();
+    getLocalHost(environmentType?: EnvironmentType): string;
     _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType): string;
     _ensureSystem(systemId: string): any;
     _ensureService(systemId: string, serviceId: string): any;

package/dist/esm/src/serviceManager.js

@@ -31,22 +31,22 @@ class ServiceManager {
             });
         });
     }
-    _forLocal(port, path, environmentType) {
-        if (!path) {
-            path = '';
-        }
-        let host;
+    getLocalHost(environmentType) {
         if (environmentType === 'docker') {
             //We're inside a docker container, so we can use this special host name to access the host machine
-            host = 'host.docker.internal';
+            return 'host.docker.internal';
         }
-        else {
-            host = clusterService_1.clusterService.getClusterServiceHost();
+        return clusterService_1.clusterService.getClusterServiceHost();
+    }
+    _forLocal(port, path, environmentType) {
+        if (!path) {
+            path = '';
         }
+        const hostname = this.getLocalHost(environmentType);
         if (path.startsWith('/')) {
             path = path.substring(1);
         }
-        return `http://${host}:${port}/${path}`;
+        return `http://${hostname}:${port}/${path}`;
     }
     _ensureSystem(systemId) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);

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

@@ -56,6 +56,31 @@ export type ProcessInfo = {
     pid?: number | string | null;
     portType?: string;
 };
+export interface Health {
+    cmd: string;
+    interval?: number;
+    timeout?: number;
+    retries?: number;
+}
+export type PortInfo = {
+    port: number;
+    type: 'tcp' | 'udp';
+} | number | string;
+export type LocalImageOptions<Credentials = AnyMap, Options = AnyMap> = {
+    image: string;
+    ports: {
+        [key: string]: PortInfo;
+    };
+    credentials?: Credentials;
+    options?: Options;
+    cmd?: string;
+    env?: AnyMap;
+    health?: Health;
+    singleton?: boolean;
+    mounts?: {
+        [key: string]: string;
+    };
+};
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -73,6 +98,21 @@ export type InstanceInfo = {
     portType?: string;
 };
 export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
+export interface OperatorInstancePort {
+    protocol: string;
+    port: number;
+}
+export interface OperatorInstanceInfo {
+    hostname: string;
+    ports: {
+        [portType: string]: OperatorInstancePort;
+    };
+    path?: string;
+    query?: string;
+    hash?: string;
+    options?: AnyMap;
+    credentials?: AnyMap;
+}
 export interface OperatorInfo {
     host: string;
     port: string;

package/dist/esm/src/utils/BlockInstanceRunner.d.ts

@@ -2,9 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { KapetaURI } from '@kapeta/nodejs-utils';
-import { AnyMap, BlockProcessParams, ProcessInfo, StringMap } from '../types';
+import { AnyMap, ProcessInfo } from '../types';
 export declare function resolvePortType(portType: string): string;
 export declare class BlockInstanceRunner {
     private readonly _systemId;
@@ -20,16 +18,7 @@ export declare class BlockInstanceRunner {
      */
     private _startLocalProcess;
     private _startDockerProcess;
-    /**
-     *
-     * @param blockInstance
-     * @param blockUri
-     * @param providerDefinition
-     * @param {{[key:string]:string}} env
-     * @return {Promise<ProcessDetails>}
-     * @private
-     */
-    _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessInfo>;
+    private _startOperatorProcess;
     private getDockerPortBindings;
     private ensureContainer;
     private _handleContainer;