@kapeta/local-cluster-service 0.35.0 → 0.36.1

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

@@ -19,6 +19,7 @@ const clusterService_1 = require("../clusterService");
 const types_1 = require("../types");
 const definitionsManager_1 = require("../definitionsManager");
 const node_os_1 = __importDefault(require("node:os"));
+const taskManager_1 = require("../taskManager");
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -40,16 +41,23 @@ async function getProvider(uri) {
     });
 }
 function resolvePortType(portType) {
-    if (serviceManager_1.HTTP_PORTS.includes(portType)) {
+    if (portType && serviceManager_1.HTTP_PORTS.includes(portType.toLowerCase())) {
         return serviceManager_1.HTTP_PORT_TYPE;
     }
     return portType;
 }
 exports.resolvePortType = resolvePortType;
-function getProviderPorts(assetVersion, providerVersion) {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion, providerVersion) {
     const out = assetVersion.definition?.spec?.providers
+        ?.filter((provider) => {
+        // We only support HTTP provider ports for now. Need to figure out how to handle other types
+        return serviceManager_1.HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+    })
         ?.map((provider) => {
-        return resolvePortType(provider.spec?.port?.type);
+        return resolvePortType(provider.spec?.port?.type?.toLowerCase());
     })
         .filter((t) => !!t) ?? [];
     if (out.length === 0) {
@@ -112,7 +120,7 @@ class BlockInstanceRunner {
         }
         else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
@@ -155,7 +163,7 @@ class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, targetKindUri.id);
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
@@ -168,7 +176,7 @@ class BlockInstanceRunner {
         delete localContainer.HostConfig;
         delete localContainer.Labels;
         delete localContainer.Env;
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -240,8 +248,8 @@ class BlockInstanceRunner {
         if (!providerVersion) {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, kindUri.id);
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
         const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
@@ -268,15 +276,6 @@ class BlockInstanceRunner {
             },
         });
     }
-    /**
-     *
-     * @param blockInstance
-     * @param blockUri
-     * @param providerDefinition
-     * @param {{[key:string]:string}} env
-     * @return {Promise<ProcessDetails>}
-     * @private
-     */
     async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
         const { assetFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
         const kapetaYmlPath = assetFile;
@@ -290,88 +289,107 @@ class BlockInstanceRunner {
         }
         const local = spec.local;
         const dockerImage = local.image;
-        //We only want 1 operator per operator type - across all local systems
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
-        const logs = new LogData_1.LogData();
-        const bindHost = (0, utils_1.getBindHost)();
-        const ExposedPorts = {};
-        const addonEnv = {};
-        const PortBindings = {};
-        let HealthCheck = undefined;
-        let Mounts = [];
-        const localPorts = local.ports ?? {};
-        const labels = {};
-        const promises = Object.entries(localPorts).map(async ([portType, value]) => {
-            const portInfo = (0, utils_1.toPortInfo)(value);
-            const dockerPort = `${portInfo.port}/${portInfo.type}`;
-            ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
-            const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
-            PortBindings[dockerPort] = [
-                {
-                    HostIp: bindHost,
-                    HostPort: `${publicPort}`,
-                },
-            ];
-            labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
-        });
-        await Promise.all(promises);
-        if (local.env) {
-            Object.entries(local.env).forEach(([key, value]) => {
-                addonEnv[key] = value;
-            });
-        }
-        if (local.mounts) {
-            Mounts = await containerManager_1.containerManager.createVolumes(this._systemId, blockUri.id, local.mounts);
+        const operatorUri = local.singleton ? (0, nodejs_utils_1.parseKapetaUri)(providerRef) : blockUri;
+        const operatorId = local.singleton ? providerRef : blockInstance.id;
+        const operatorRef = local.singleton ? providerRef : blockInstance.ref;
+        if (local.singleton && env) {
+            env[KAPETA_BLOCK_REF] = operatorRef;
+            env[KAPETA_INSTANCE_ID] = operatorId;
         }
-        if (local.health) {
-            HealthCheck = containerManager_1.containerManager.toDockerHealth(local.health);
-        }
-        // For windows we need to default to root
-        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
-        const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
-        logs.addLog(`Creating new container for block: ${containerName}`);
-        const out = await this.ensureContainer({
-            Image: dockerImage,
-            name: containerName,
-            ExposedPorts,
-            HealthCheck,
-            HostConfig: {
-                Binds: [
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, providerRef);
+        const task = taskManager_1.taskManager.add(`container:start:${containerName}`, async () => {
+            const logs = new LogData_1.LogData();
+            const bindHost = (0, utils_1.getBindHost)();
+            const ExposedPorts = {};
+            const addonEnv = {};
+            const PortBindings = {};
+            let HealthCheck = undefined;
+            let Mounts = [];
+            const localPorts = local.ports ?? {};
+            const labels = {};
+            const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+                const portInfo = (0, utils_1.toPortInfo)(value);
+                const dockerPort = `${portInfo.port}/${portInfo.type}`;
+                ExposedPorts[dockerPort] = {};
+                addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
+                const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, operatorId, portType);
+                PortBindings[dockerPort] = [
+                    {
+                        HostIp: bindHost,
+                        HostPort: `${publicPort}`,
+                    },
+                ];
+                labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
+            });
+            await Promise.all(promises);
+            if (local.env) {
+                Object.entries(local.env).forEach(([key, value]) => {
+                    addonEnv[key] = value;
+                });
+            }
+            if (local.mounts) {
+                Mounts = await containerManager_1.containerManager.createVolumes(this._systemId, operatorUri.id, local.mounts);
+            }
+            if (local.health) {
+                HealthCheck = containerManager_1.containerManager.toDockerHealth(local.health);
+            }
+            // For windows we need to default to root
+            const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
+            const Binds = local.singleton
+                ? [`${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`]
+                : [
                     `${(0, containerManager_1.toLocalBindVolume)(kapetaYmlPath)}:/kapeta.yml:ro`,
                     `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`,
+                ];
+            const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
+            console.log(`Ensuring container for operator block: ${containerName} [singleton: ${!!local.singleton}]`);
+            logs.addLog(`Ensuring container for operator block: ${containerName}`);
+            const out = await this.ensureContainer({
+                Image: dockerImage,
+                name: containerName,
+                ExposedPorts,
+                HealthCheck,
+                HostConfig: {
+                    Binds,
+                    PortBindings,
+                    Mounts,
+                },
+                Labels: {
+                    ...labels,
+                    instance: operatorId,
+                    [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                    [containerManager_1.COMPOSE_LABEL_SERVICE]: operatorUri.id.replace(/[^a-z0-9]/gi, '_'),
+                },
+                Env: [
+                    `KAPETA_INSTANCE_NAME=${operatorRef}`,
+                    `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                    ...DOCKER_ENV_VARS,
+                    ...Object.entries({
+                        ...env,
+                        ...addonEnv,
+                    }).map(([key, value]) => `${key}=${value}`),
                 ],
-                PortBindings,
-                Mounts,
-            },
-            Labels: {
-                ...labels,
-                instance: blockInstance.id,
-                [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
-                [containerManager_1.COMPOSE_LABEL_SERVICE]: blockUri.id.replace(/[^a-z0-9]/gi, '_'),
-            },
-            Env: [
-                `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
-                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
-                ...DOCKER_ENV_VARS,
-                ...Object.entries({
-                    ...env,
-                    ...addonEnv,
-                }).map(([key, value]) => `${key}=${value}`),
-            ],
+            });
+            const portTypes = local.ports ? Object.keys(local.ports) : [];
+            if (portTypes.length > 0) {
+                out.portType = portTypes[0];
+            }
+            return out;
+        }, {
+            name: `Starting container for ${providerRef}`,
+            systemId: this._systemId,
         });
-        const portTypes = local.ports ? Object.keys(local.ports) : [];
-        if (portTypes.length > 0) {
-            out.portType = portTypes[0];
-        }
-        return out;
+        return task.wait();
     }
-    async getDockerPortBindings(blockInstance, assetVersion, providerVersion) {
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    async getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion) {
         const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

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

@@ -4,7 +4,7 @@
  */
 import { EntityList } from '@kapeta/schemas';
 import { AnyMap, PortInfo } from '../types';
-export declare function getBlockInstanceContainerName(systemId: string, instanceId: string): string;
+export declare function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string): Promise<string>;
 export declare function toPortInfo(port: PortInfo): {
     port: number;
     type: string;

package/dist/cjs/src/utils/utils.js

@@ -13,8 +13,31 @@ const yaml_1 = __importDefault(require("yaml"));
 const md5_1 = __importDefault(require("md5"));
 const lodash_1 = __importDefault(require("lodash"));
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
-function getBlockInstanceContainerName(systemId, instanceId) {
-    return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
+const definitionsManager_1 = require("../definitionsManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const operatorManager_1 = require("../operatorManager");
+const assetManager_1 = require("../assetManager");
+async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
+    if (!blockType) {
+        const instance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        if (!instance) {
+            throw new Error(`Instance ${instanceId} not found in plan ${systemId}`);
+        }
+        const block = await assetManager_1.assetManager.getAsset(instance.block.ref);
+        if (!block) {
+            throw new Error(`Block ${instance.block.ref} not found`);
+        }
+        blockType = block.data.kind;
+    }
+    const typeDefinition = await definitionsManager_1.definitionsManager.getDefinition(blockType);
+    if (!typeDefinition) {
+        throw new Error(`Block type ${blockType} not found`);
+    }
+    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR &&
+        typeDefinition.definition.spec?.local?.singleton) {
+        return `kapeta-instance-operator-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + (0, nodejs_utils_1.normalizeKapetaUri)(blockType))}`;
+    }
+    return `kapeta-block-instance-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
 function toPortInfo(port) {

package/dist/esm/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/esm/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/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,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();