@kapeta/local-cluster-service 0.34.2 → 0.36.0

package/.github/workflows/check-license.yml

@@ -15,4 +15,3 @@ jobs:
           holder: 'Kapeta Inc.'
           license: 'BUSL-1.1'
           sources: 'src/**/* test/*'
-

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.36.0](https://github.com/kapetacom/local-cluster-service/compare/v0.35.0...v0.36.0) (2024-02-06)
+
+
+### Features
+
+* Ensure instance operators only start 1 instance ([#123](https://github.com/kapetacom/local-cluster-service/issues/123)) ([10d8614](https://github.com/kapetacom/local-cluster-service/commit/10d86143ae6d9b41bae8e8dee345628b6d2cbe0a))
+
+# [0.35.0](https://github.com/kapetacom/local-cluster-service/compare/v0.34.2...v0.35.0) (2024-01-31)
+
+
+### Features
+
+* Adds support for getting instance operator info ([#122](https://github.com/kapetacom/local-cluster-service/issues/122)) ([8fa18ac](https://github.com/kapetacom/local-cluster-service/commit/8fa18ac58226ce9776f79a64d3a99cf56456e834))
+
 ## [0.34.2](https://github.com/kapetacom/local-cluster-service/compare/v0.34.1...v0.34.2) (2024-01-22)
 
 

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

@@ -148,4 +148,13 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res)
 router.get('/consumes/:resourceName/:type', (req, res) => {
     res.send(serviceManager_1.serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
 });
+/**
+ * Used by services to information about a block operator
+ *
+ * If the remote service is not already running it will be started
+ */
+router.get('/operator/:instanceId', async (req, res) => {
+    const operatorInfo = await instanceManager_1.instanceManager.getInstanceOperator(req.kapeta.systemId, req.params.instanceId, req.kapeta.environment);
+    res.send(operatorInfo);
+});
 exports.default = router;

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

@@ -5,7 +5,7 @@
 /// <reference types="node" />
 import FSExtra from 'fs-extra';
 import Docker from 'dockerode';
-import { InstanceInfo, LogEntry } from './types';
+import { Health, InstanceInfo, LogEntry } from './types';
 type StringMap = {
     [key: string]: string;
 };
@@ -26,12 +26,6 @@ export interface DockerMounts {
 }
 export type DockerContainerStatus = 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
 export type DockerContainerHealth = 'starting' | 'healthy' | 'unhealthy' | 'none';
-interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
 export declare const CONTAINER_LABEL_PORT_PREFIX = "kapeta_port-";
 export declare const COMPOSE_LABEL_PROJECT = "com.docker.compose.project";
 export declare const COMPOSE_LABEL_SERVICE = "com.docker.compose.service";
@@ -50,7 +44,7 @@ declare class ContainerManager {
     isAlive(): boolean;
     getMountPoint(systemId: string, ref: string, mountName: string): string;
     createMounts(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<StringMap>;
-    createVolumes(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
+    createVolumes(systemId: string, serviceId: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
     ping(): Promise<void>;
     docker(): Docker;
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;

package/dist/cjs/src/containerManager.js

@@ -168,12 +168,12 @@ class ContainerManager {
         }
         return mounts;
     }
-    async createVolumes(systemId, kind, mountOpts) {
+    async createVolumes(systemId, serviceId, mountOpts) {
         const Mounts = [];
         if (mountOpts) {
             const mountOptList = Object.entries(mountOpts);
             for (const [mountName, containerPath] of mountOptList) {
-                const volumeName = `${systemId}_${kind}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
+                const volumeName = `${systemId}_${serviceId}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
                 Mounts.push({
                     Target: containerPath,
                     Source: volumeName,
@@ -182,7 +182,7 @@ class ContainerManager {
                     Consistency: 'consistent',
                     Labels: {
                         [exports.COMPOSE_LABEL_PROJECT]: systemId.replace(/[^a-z0-9]/gi, '_'),
-                        [exports.COMPOSE_LABEL_SERVICE]: kind.replace(/[^a-z0-9]/gi, '_'),
+                        [exports.COMPOSE_LABEL_SERVICE]: serviceId.replace(/[^a-z0-9]/gi, '_'),
                     },
                 });
             }
@@ -533,7 +533,7 @@ class ContainerManager {
         return new ContainerInfo(dockerContainer);
     }
     async getLogs(instance) {
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
         const containerInfo = await this.getContainerByName(containerName);
         if (!containerInfo) {
             return [
@@ -548,7 +548,7 @@ class ContainerManager {
         return containerInfo.getLogs();
     }
     async stopLogListening(systemId, instanceId) {
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
         if (this.logStreams[containerName]) {
             if (this.logStreams[containerName]?.timer) {
                 clearTimeout(this.logStreams[containerName].timer);
@@ -566,7 +566,7 @@ class ContainerManager {
         }
     }
     async ensureLogListening(systemId, instanceId, handler) {
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
         try {
             if (this.logStreams[containerName]?.stream) {
                 // Already listening - will shut itself down
@@ -791,7 +791,7 @@ class ContainerInfo {
             if (!name.startsWith(exports.CONTAINER_LABEL_PORT_PREFIX)) {
                 return;
             }
-            const hostPort = name.substr(exports.CONTAINER_LABEL_PORT_PREFIX.length);
+            const hostPort = name.substring(exports.CONTAINER_LABEL_PORT_PREFIX.length);
             portTypes[hostPort] = portType;
         });
         lodash_1.default.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {

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

@@ -2,7 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { InstanceInfo, LogEntry } from './types';
+import { EnvironmentType, InstanceInfo, LogEntry, OperatorInstanceInfo } from './types';
 import { Task } from './taskManager';
 export declare class InstanceManager {
     private _interval;
@@ -24,10 +24,11 @@ export declare class InstanceManager {
     private getHealthUrl;
     markAsStopped(systemId: string, instanceId: string): Promise<void>;
     startAllForPlan(systemId: string): Promise<Task<InstanceInfo[]>>;
+    stopAllForPlan(systemId: string): Task<void>;
+    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType): Promise<OperatorInstanceInfo>;
     stop(systemId: string, instanceId: string): Promise<void>;
     private stopInner;
-    stopAllForPlan(systemId: string): Task<void>;
-    start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>>;
+    start(systemId: string, instanceId: string, checkForSingleton?: boolean): Promise<InstanceInfo | Task<InstanceInfo>>;
     /**
      * Stops an instance but does not remove it from the list of active instances
      *
@@ -42,5 +43,9 @@ export declare class InstanceManager {
     private checkInstances;
     private getExternalStatus;
     private requestInstanceStatus;
+    private isSingletonOperator;
+    private getKindForAssetRef;
+    private isUsingKind;
+    private getAllInstancesForKind;
 }
 export declare const instanceManager: InstanceManager;

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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);