@kapeta/local-cluster-service 0.34.2 → 0.36.0

package/src/instanceManager.ts

@@ -10,7 +10,7 @@ import { BlockInstanceRunner } from './utils/BlockInstanceRunner';
 import { storageService } from './storageService';
 import { EVENT_INSTANCE_CREATED, EVENT_STATUS_CHANGED, socketManager } from './socketManager';
 import { serviceManager } from './serviceManager';
-import { assetManager } from './assetManager';
+import { assetManager, EnrichedAsset } from './assetManager';
 import {
     containerManager,
     DockerContainerHealth,
@@ -18,10 +18,21 @@ import {
     HEALTH_CHECK_TIMEOUT,
 } from './containerManager';
 import { configManager } from './configManager';
-import { DesiredInstanceStatus, InstanceInfo, InstanceOwner, InstanceStatus, InstanceType, LogEntry } from './types';
+import {
+    DesiredInstanceStatus,
+    EnvironmentType,
+    InstanceInfo,
+    InstanceOwner,
+    InstanceStatus,
+    InstanceType,
+    LocalImageOptions,
+    LogEntry,
+    OperatorInstanceInfo,
+    OperatorInstancePort,
+} from './types';
 import { BlockDefinitionSpec, BlockInstance, Plan } from '@kapeta/schemas';
 import { getBlockInstanceContainerName, getResolvedConfiguration } from './utils/utils';
-import { KIND_OPERATOR, operatorManager } from './operatorManager';
+import { KIND_BLOCK_OPERATOR, KIND_RESOURCE_OPERATOR, operatorManager } from './operatorManager';
 import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
@@ -335,11 +346,108 @@ export class InstanceManager {
         );
     }
 
+    public stopAllForPlan(systemId: string) {
+        systemId = normalizeKapetaUri(systemId);
+        const instancesForPlan = this._instances.filter((instance) => instance.systemId === systemId);
+        return taskManager.add(
+            `plan:stop:${systemId}`,
+            async () => {
+                return this.stopInstances(instancesForPlan);
+            },
+            {
+                name: `Stopping plan ${systemId}`,
+            }
+        );
+    }
+
+    public async getInstanceOperator(
+        systemId: string,
+        instanceId: string,
+        environment?: EnvironmentType
+    ): Promise<OperatorInstanceInfo> {
+        const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
+        if (!blockInstance) {
+            throw new Error(`Instance not found: ${systemId}/${instanceId}`);
+        }
+        const blockRef = normalizeKapetaUri(blockInstance.block.ref);
+        const block = await assetManager.getAsset(blockRef, true);
+        if (!block) {
+            throw new Error(`Block not found: ${blockRef}`);
+        }
+
+        const operatorDefinition = await 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 as LocalImageOptions;
+
+        let instance = await this.start(systemId, instanceId);
+        if (instance instanceof Task) {
+            instance = await instance.wait();
+        }
+
+        const container = await containerManager.get(instance.pid as string);
+        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.getLocalHost(environment);
+        const ports: { [key: string]: OperatorInstancePort } = {};
+
+        Object.entries(portInfo).forEach(([key, value]) => {
+            ports[key] = {
+                protocol: value.protocol,
+                port: parseInt(value.hostPort),
+            };
+        });
+
+        return {
+            hostname,
+            ports,
+            credentials: localConfig.credentials,
+            options: localConfig.options,
+        };
+    }
+
     public async stop(systemId: string, instanceId: string) {
         return this.stopInner(systemId, instanceId, true);
     }
 
-    private async stopInner(systemId: string, instanceId: string, changeDesired: boolean = false) {
+    private async stopInner(
+        systemId: string,
+        instanceId: string,
+        changeDesired: boolean = false,
+        checkForSingleton: boolean = true
+    ) {
+        if (checkForSingleton) {
+            const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
+            const blockRef = normalizeKapetaUri(blockInstance.block.ref);
+
+            const blockAsset = await 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 = normalizeKapetaUri(systemId);
             const instance = this.getInstance(systemId, instanceId);
@@ -362,12 +470,18 @@ export class InstanceManager {
             instance.status = InstanceStatus.STOPPING;
 
             socketManager.emitSystemEvent(systemId, 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 = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
+                    const containerName = await getBlockInstanceContainerName(instance.systemId, instance.instanceId);
                     const container = await containerManager.getContainerByName(containerName);
                     if (container) {
                         try {
@@ -400,34 +514,44 @@ export class InstanceManager {
         });
     }
 
-    public stopAllForPlan(systemId: string) {
+    public async start(
+        systemId: string,
+        instanceId: string,
+        checkForSingleton: boolean = true
+    ): Promise<InstanceInfo | Task<InstanceInfo>> {
         systemId = normalizeKapetaUri(systemId);
-        const instancesForPlan = this._instances.filter((instance) => instance.systemId === systemId);
-        return taskManager.add(
-            `plan:stop:${systemId}`,
-            async () => {
-                return this.stopInstances(instancesForPlan);
-            },
-            {
-                name: `Stopping plan ${systemId}`,
+        const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
+        const blockRef = normalizeKapetaUri(blockInstance.block.ref);
+
+        const blockAsset = await 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];
             }
-        );
-    }
+        }
 
-    public async start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>> {
         return this.exclusive(systemId, instanceId, async () => {
-            systemId = normalizeKapetaUri(systemId);
-            const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
-            const blockRef = normalizeKapetaUri(blockInstance.block.ref);
+            let existingInstance = this.getInstance(systemId, instanceId);
 
-            const blockAsset = await assetManager.getAsset(blockRef, true);
-            if (!blockAsset) {
-                throw new Error('Block not found: ' + blockRef);
+            if (existingInstance && existingInstance.pid) {
+                const container = await containerManager.get(existingInstance.pid as string);
+                if (!container) {
+                    // The container is not running
+                    existingInstance = undefined;
+                }
             }
 
-            const existingInstance = this.getInstance(systemId, instanceId);
-
-            if (existingInstance) {
+            if (existingInstance?.pid) {
                 if (existingInstance.status === InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -476,17 +600,17 @@ export class InstanceManager {
                         return Promise.resolve();
                     }
 
-                    if (KIND_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
+                    if (KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
                         // Not an operator
                         return Promise.resolve();
                     }
                     // Check if the operator has a local definition, if not we skip it since we can't start it
-                    if(!asset.definition.spec.local) {
-                        console.log('Skipping operator since it as no local definition: %s', consumer.kind)
+                    if (!asset.definition.spec.local) {
+                        console.log('Skipping operator since it as no local definition: %s', consumer.kind);
                         return Promise.resolve();
                     }
                     console.log('Ensuring resource: %s in %s', consumerUri.id, systemId);
-                    return operatorManager.ensureResource(systemId, consumerUri.fullName, consumerUri.version);
+                    return operatorManager.ensureOperator(systemId, consumerUri.fullName, consumerUri.version);
                 });
 
                 await Promise.all(promises);
@@ -570,6 +694,8 @@ export class InstanceManager {
      */
     public async prepareForRestart(systemId: string, instanceId: string) {
         systemId = normalizeKapetaUri(systemId);
+
+        console.log('Stopping instance during restart...', systemId, instanceId);
         await this.stopInner(systemId, instanceId);
     }
 
@@ -603,8 +729,14 @@ export 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;
                 }
 
@@ -721,6 +853,11 @@ export class InstanceManager {
                 ) {
                     //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) {
                         console.warn('Failed to stop instance', instance.systemId, instance.instanceId, e);
@@ -755,7 +892,7 @@ export class InstanceManager {
 
     private async getExternalStatus(instance: InstanceInfo): Promise<InstanceStatus> {
         if (instance.type === InstanceType.DOCKER) {
-            const containerName = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
+            const containerName = await getBlockInstanceContainerName(instance.systemId, instance.instanceId);
             const container = await containerManager.getContainerByName(containerName);
             if (!container) {
                 // If the container doesn't exist, we consider the instance stopped
@@ -864,6 +1001,53 @@ export class InstanceManager {
             });
         });
     }
+
+    private async isSingletonOperator(blockAsset: EnrichedAsset): Promise<boolean> {
+        const provider = await assetManager.getAsset(blockAsset.data.kind);
+        if (!provider) {
+            return false;
+        }
+
+        if (parseKapetaUri(provider.kind).fullName === KIND_BLOCK_OPERATOR) {
+            const localConfig = provider.data.spec.local as LocalImageOptions;
+            return localConfig.singleton ?? false;
+        }
+
+        return false;
+    }
+
+    private async getKindForAssetRef(assetRef: string): Promise<string | null> {
+        const block = await assetManager.getAsset(assetRef);
+        if (!block) {
+            return null;
+        }
+
+        return block.data.kind;
+    }
+
+    private async isUsingKind(ref: string, kind: string): Promise<boolean> {
+        const assetKind = await this.getKindForAssetRef(ref);
+        if (!assetKind) {
+            return false;
+        }
+
+        return parseKapetaUri(assetKind).fullName === parseKapetaUri(kind).fullName;
+    }
+
+    private async getAllInstancesForKind(systemId: string, kind: string): Promise<string[]> {
+        const plan = await assetManager.getPlan(systemId);
+        if (!plan?.spec?.blocks) {
+            return [];
+        }
+        const out: string[] = [];
+        for (const block of plan.spec.blocks) {
+            if (await this.isUsingKind(block.block.ref, kind)) {
+                out.push(block.id);
+            }
+        }
+
+        return out;
+    }
 }
 
 export const instanceManager = new InstanceManager();

package/src/operatorManager.ts

@@ -16,25 +16,27 @@ import {
     containerManager,
 } from './containerManager';
 import FSExtra from 'fs-extra';
-import { AnyMap, EnvironmentType, OperatorInfo, StringMap } from './types';
+import { AnyMap, EnvironmentType, LocalImageOptions, OperatorInfo, StringMap } from './types';
 import { BlockInstance, Resource } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
-import { getBindHost } from './utils/utils';
+import { getBindHost, toPortInfo } from './utils/utils';
 import { parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import _ from 'lodash';
 import AsyncLock from 'async-lock';
 import { taskManager } from './taskManager';
 
-export const KIND_OPERATOR = 'core/resource-type-operator';
+export const KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
+export const KIND_BLOCK_OPERATOR = 'core/block-type-operator';
 const KIND_PLAN = 'core/plan';
 
 class Operator {
     private readonly _data: DefinitionInfo;
+
     constructor(data: DefinitionInfo) {
         this._data = data;
     }
 
-    getLocalData() {
+    getLocalData(): LocalImageOptions {
         return this._data.definition.spec.local;
     }
 
@@ -65,24 +67,24 @@ class OperatorManager {
     /**
      * Get operator definition for resource type
      */
-    async getOperator(resourceType: string, version: string) {
-        const operators = await definitionsManager.getDefinitions(KIND_OPERATOR);
+    async getOperator(fullName: string, version: string) {
+        const operators = await definitionsManager.getDefinitions([KIND_RESOURCE_OPERATOR, KIND_BLOCK_OPERATOR]);
 
         const operator: DefinitionInfo | undefined = 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);
@@ -137,7 +139,7 @@ class OperatorManager {
         const kindUri = 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) {
@@ -164,16 +166,17 @@ 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: string, resourceType: string, version: string): Promise<ContainerInfo> {
+    async ensureOperator(systemId: string, kind: string, version: string): Promise<ContainerInfo> {
         systemId = 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();
 
@@ -186,17 +189,9 @@ class OperatorManager {
             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;
+                const hostPort = await serviceManager.ensureServicePort(systemId, kind, portType);
+                const portInfo = toPortInfo(containerPortInfo);
+                const portId = portInfo.port + '/' + portInfo.type;
 
                 ports[portId] = {
                     type: portType,
@@ -204,7 +199,7 @@ class OperatorManager {
                 };
             }
 
-            const nameParts = [systemId, resourceType.toLowerCase(), version];
+            const nameParts = [systemId, kind.toLowerCase(), version];
 
             const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
 
@@ -216,7 +211,7 @@ class OperatorManager {
             const Labels: StringMap = {
                 kapeta: 'true',
                 [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
-                [COMPOSE_LABEL_SERVICE]: [resourceType, version].join('_').replace(/[^a-z0-9]/gi, '_'),
+                [COMPOSE_LABEL_SERVICE]: [kind, version].join('_').replace(/[^a-z0-9]/gi, '_'),
             };
 
             const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
@@ -237,7 +232,7 @@ class OperatorManager {
                 Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
             });
 
-            const Mounts = await containerManager.createVolumes(systemId, resourceType, operatorData.mounts);
+            const Mounts = await containerManager.createVolumes(systemId, kind, operatorData.mounts);
 
             _.forEach(operatorData.env, (value, name) => {
                 Env.push(name + '=' + value);

package/src/serviceManager.ts

@@ -34,22 +34,25 @@ class ServiceManager {
         });
     }
 
+    public getLocalHost(environmentType?: EnvironmentType) {
+        if (environmentType === 'docker') {
+            //We're inside a docker container, so we can use this special host name to access the host machine
+            return 'host.docker.internal';
+        }
+
+        return clusterService.getClusterServiceHost();
+    }
+
     _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType) {
         if (!path) {
             path = '';
         }
-        let host;
-        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';
-        } else {
-            host = clusterService.getClusterServiceHost();
-        }
+        const hostname = this.getLocalHost(environmentType);
 
         if (path.startsWith('/')) {
             path = path.substring(1);
         }
-        return `http://${host}:${port}/${path}`;
+        return `http://${hostname}:${port}/${path}`;
     }
 
     _ensureSystem(systemId: string) {

package/src/types.ts

@@ -61,6 +61,27 @@ export type ProcessInfo = {
     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;
@@ -86,6 +107,21 @@ interface ResourceRef {
 
 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;