@kapeta/local-cluster-service 0.35.0 → 0.36.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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)
 
 

package/dist/cjs/src/containerManager.js

@@ -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

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

@@ -24,11 +24,11 @@ export declare class InstanceManager {
     private getHealthUrl;
     markAsStopped(systemId: string, instanceId: string): Promise<void>;
     startAllForPlan(systemId: string): Promise<Task<InstanceInfo[]>>;
-    stop(systemId: string, instanceId: string): Promise<void>;
-    private stopInner;
     stopAllForPlan(systemId: string): Task<void>;
     getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType): Promise<OperatorInstanceInfo>;
-    start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>>;
+    stop(systemId: string, instanceId: string): Promise<void>;
+    private stopInner;
+    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
      *
@@ -43,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,68 +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 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 blockAsset = await assetManager_1.assetManager.getAsset(blockRef, true);
+        if (!blockAsset) {
+            throw new Error('Block not found: ' + blockRef);
         }
-        const portInfo = await container.getPorts();
-        if (!portInfo) {
-            throw new Error(`No ports found for instance: ${instanceId}`);
+        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];
+            }
         }
-        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 start(systemId, instanceId) {
         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);
-            }
-            const existingInstance = this.getInstance(systemId, instanceId);
+            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;
+                }
+            }
+            if (existingInstance?.pid) {
                 if (existingInstance.status === types_1.InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -414,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();
                     }
@@ -424,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);
             }
@@ -491,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() {
@@ -518,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);
@@ -609,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) {
@@ -638,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
@@ -729,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

@@ -5,7 +5,8 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
 import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
-export declare const KIND_OPERATOR = "core/resource-type-operator";
+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);
@@ -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,7 +136,7 @@ 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);
+                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] = {
@@ -144,7 +144,7 @@ class OperatorManager {
                     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 = [];
@@ -152,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)();
@@ -167,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/types.d.ts

@@ -76,6 +76,7 @@ export type LocalImageOptions<Credentials = AnyMap, Options = AnyMap> = {
     cmd?: string;
     env?: AnyMap;
     health?: Health;
+    singleton?: boolean;
     mounts?: {
         [key: string]: string;
     };

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