@kapeta/local-cluster-service 0.37.0 → 0.39.0

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

@@ -7,16 +7,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
+exports.getResolvedConfiguration = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.getDockerHostIp = exports.getBindAddressForEnvironment = exports.getRemoteHostForEnvironment = exports.getOperatorInstancePorts = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const md5_1 = __importDefault(require("md5"));
+const schemas_1 = require("@kapeta/schemas");
 const lodash_1 = __importDefault(require("lodash"));
 const types_1 = require("../types");
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const definitionsManager_1 = require("../definitionsManager");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const assetManager_1 = require("../assetManager");
+const serviceManager_1 = require("../serviceManager");
+const clusterService_1 = require("../clusterService");
 async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!blockType) {
         const instance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
@@ -45,11 +48,54 @@ function toPortInfo(port) {
         return { port: parseInt(`${port}`), type: 'tcp' };
     }
     if (!port.type) {
-        port.type = 'tcp';
+        port.type = schemas_1.LocalInstancePortType.TCP;
     }
     return port;
 }
 exports.toPortInfo = toPortInfo;
+async function getOperatorInstancePorts(systemId, operatorId, local) {
+    const localPorts = local.ports ?? {};
+    const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+        const portInfo = toPortInfo(value);
+        const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, operatorId, portType);
+        return {
+            portType,
+            port: portInfo.port,
+            hostPort,
+            protocol: portInfo.type,
+        };
+    });
+    return await Promise.all(promises);
+}
+exports.getOperatorInstancePorts = getOperatorInstancePorts;
+/**
+ * Gets the hostname where all services are available - including the cluster service.
+ *
+ * For docker this is the internal docker host - otherwise it's the local machine
+ * Assumed to be the same address as the cluster service outside docker.
+ */
+function getRemoteHostForEnvironment(environment) {
+    return environment === 'docker' ? types_1.DOCKER_HOST_INTERNAL : clusterService_1.clusterService.getClusterServiceHost();
+}
+exports.getRemoteHostForEnvironment = getRemoteHostForEnvironment;
+/**
+ * Get the bind address for the given environment.
+ *
+ * Outside of docker we bind to 127.0.0.1 - inside we bind to everything (0.0.0.0)
+ */
+function getBindAddressForEnvironment(environment, preferredHost = '127.0.0.1') {
+    return environment === 'docker' ? '0.0.0.0' : preferredHost;
+}
+exports.getBindAddressForEnvironment = getBindAddressForEnvironment;
+/**
+ * Get the docker host IP address for port binding.
+ */
+function getDockerHostIp(preferredHost = '127.0.0.1') {
+    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
+    // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
+    return isLinux() ? '0.0.0.0' : preferredHost;
+}
+exports.getDockerHostIp = getDockerHostIp;
 function getRemoteUrl(id, defautValue) {
     const remoteConfig = local_cluster_config_1.default.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;
@@ -77,12 +123,6 @@ function isLinux() {
     return !isWindows() && !isMac();
 }
 exports.isLinux = isLinux;
-function getBindHost(preferredHost = '127.0.0.1') {
-    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
-    // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
-    return isLinux() ? '0.0.0.0' : preferredHost;
-}
-exports.getBindHost = getBindHost;
 function getResolvedConfiguration(entities, config, globalConfiguration) {
     if (!entities || !globalConfiguration) {
         return config || {};

package/dist/esm/index.js

@@ -210,7 +210,10 @@ exports.default = {
                 }
                 reject(err);
             });
-            const bindHost = (0, utils_1.getBindHost)(host);
+            // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
+            // TODO: This might pose a security risk - so we should authenticate all requests using a
+            //       shared secret/nonce that we pass around.
+            const bindHost = (0, utils_1.isLinux)() ? '0.0.0.0' : host;
             currentServer.listen(port, bindHost, async () => {
                 try {
                     const ensureCLITask = await (0, commandLineUtils_1.ensureCLI)();

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

@@ -4,6 +4,7 @@
  */
 import { Definition } from '@kapeta/local-cluster-config';
 import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
+import { Task } from './taskManager';
 import { SourceOfChange } from './types';
 export interface EnrichedAsset {
     ref: string;
@@ -31,7 +32,7 @@ declare class AssetManager {
     updateAsset(ref: string, yaml: Definition, sourceOfChange?: SourceOfChange): Promise<void>;
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;
-    installAsset(ref: string, wait?: boolean): Promise<import("./taskManager").Task<void>[] | undefined>;
+    installAsset(ref: string, wait?: boolean): Promise<Task<void>[] | undefined>;
     private cleanupUnusedProviders;
     private upgradeAllProviders;
     private maybeGenerateCode;

package/dist/esm/src/assetManager.js

@@ -233,11 +233,12 @@ class AssetManager {
             return;
         }
         console.log('Installing updates', refs);
-        const updateAll = async () => {
+        const updateAll = async (task) => {
+            const progressListener = new progressListener_1.TaskProgressListener(task);
             try {
                 //We change to a temp dir to avoid issues with the current working directory
                 process.chdir(node_os_1.default.tmpdir());
-                await nodejs_registry_utils_1.Actions.install(new progressListener_1.ProgressListener(), refs, {});
+                await nodejs_registry_utils_1.Actions.install(progressListener, refs, {});
                 await this.cleanupUnusedProviders();
             }
             catch (e) {

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

@@ -136,7 +136,7 @@ router.get('/provides/:type', async (req, res) => {
  * assign port numbers to it etc.
  */
 router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res) => {
-    const operatorInfo = await operatorManager_1.operatorManager.getConsumerResourceInfo(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceType, req.params.portType, req.params.name, req.kapeta.environment);
+    const operatorInfo = await operatorManager_1.operatorManager.getConsumerResourceInfo(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceType, req.params.portType, req.params.name, req.kapeta.environment, req.query.ensure !== 'false');
     res.send(operatorInfo);
 });
 /**
@@ -154,7 +154,7 @@ router.get('/consumes/:resourceName/:type', (req, res) => {
  * 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);
+    const operatorInfo = await instanceManager_1.instanceManager.getInstanceOperator(req.kapeta.systemId, req.params.instanceId, req.kapeta.environment, req.query.ensure !== 'false');
     res.send(operatorInfo);
 });
 exports.default = router;

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

@@ -5,7 +5,9 @@
 /// <reference types="node" />
 import FSExtra from 'fs-extra';
 import Docker from 'dockerode';
-import { Health, InstanceInfo, LogEntry } from './types';
+import { InstanceInfo, LogEntry } from './types';
+import { Task } from './taskManager';
+import { LocalInstanceHealth } from '@kapeta/schemas';
 type StringMap = {
     [key: string]: string;
 };
@@ -50,11 +52,11 @@ declare class ContainerManager {
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;
     pull(image: string): Promise<boolean>;
     toDockerMounts(mounts: StringMap): DockerMounts[];
-    toDockerHealth(health: Health): {
+    toDockerHealth(health: LocalInstanceHealth): {
         Test: string[];
         Interval: number;
         Timeout: number;
-        Retries: number;
+        Retries: any;
     };
     private applyHash;
     ensureContainer(opts: any): Promise<Docker.Container>;
@@ -74,6 +76,7 @@ declare class ContainerManager {
     getLogs(instance: InstanceInfo): Promise<LogEntry[]>;
     stopLogListening(systemId: string, instanceId: string): Promise<void>;
     ensureLogListening(systemId: string, instanceId: string, handler: (log: LogEntry) => void): Promise<void>;
+    buildDockerImage(dockerFile: string, imageName: string): Task<void>;
 }
 declare class ClosableLogStream {
     private readonly stream;

package/dist/esm/src/containerManager.js

@@ -19,6 +19,7 @@ const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-co
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const md5_1 = __importDefault(require("md5"));
 const utils_1 = require("./utils/utils");
+const types_1 = require("./types");
 const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
 const taskManager_1 = require("./taskManager");
 const node_events_1 = require("node:events");
@@ -207,14 +208,8 @@ class ContainerManager {
         return this._docker;
     }
     async getContainerByName(containerName) {
-        const containers = await this.docker().listContainers({ all: true });
-        const out = containers.find((container) => {
-            return container.Names.indexOf(`/${containerName}`) > -1;
-        });
-        if (out) {
-            return this.get(out.Id);
-        }
-        return undefined;
+        // The container can be fetched by name or by id using the same API call
+        return this.get(containerName);
     }
     async pull(image) {
         let [imageName, tag] = image.split(/:/);
@@ -279,6 +274,10 @@ class ContainerManager {
                     };
                 }
                 const chunk = chunks[data.id];
+                if (data.stream) {
+                    // Emit raw output to the task log
+                    task.addLog(data.stream);
+                }
                 switch (data.status) {
                     case DockerPullEventTypes.PreparingPhase:
                     case DockerPullEventTypes.WaitingPhase:
@@ -510,7 +509,8 @@ class ContainerManager {
         const newName = 'deleting-' + node_uuid_1.default.v4();
         // Rename the container first to avoid name conflicts if people start the same container
         await container.rename({ name: newName });
-        await container.remove({ force: !!opts?.force });
+        const newContainer = this.docker().getContainer(newName);
+        await newContainer.remove({ force: !!opts?.force });
     }
     /**
      *
@@ -520,7 +520,7 @@ class ContainerManager {
     async get(name) {
         let dockerContainer = null;
         try {
-            dockerContainer = await this.docker().getContainer(name);
+            dockerContainer = this.docker().getContainer(name);
             await dockerContainer.stats();
         }
         catch (err) {
@@ -545,7 +545,7 @@ class ContainerManager {
                 },
             ];
         }
-        return containerInfo.getLogs();
+        return await containerInfo.getLogs();
     }
     async stopLogListening(systemId, instanceId) {
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
@@ -616,6 +616,28 @@ class ContainerManager {
             // Ignore
         }
     }
+    buildDockerImage(dockerFile, imageName) {
+        const taskName = `Building docker image: ${imageName}`;
+        const processor = async (task) => {
+            const timeStarted = Date.now();
+            const stream = await this.docker().buildImage({
+                context: path_1.default.dirname(dockerFile),
+                src: [path_1.default.basename(dockerFile)],
+            }, {
+                t: imageName,
+                dockerfile: path_1.default.basename(dockerFile),
+            });
+            await processJsonStream(`image:build:${imageName}`, stream, (data) => {
+                if (data.stream) {
+                    // Emit raw output to the task log
+                    task.addLog(data.stream);
+                }
+            });
+        };
+        return taskManager_1.taskManager.add(`docker:image:build:${imageName}`, processor, {
+            name: taskName,
+        });
+    }
 }
 function readLogBuffer(logBuffer) {
     const out = [];
@@ -830,15 +852,73 @@ class ContainerInfo {
             timestamps: true,
         });
         const out = readLogBuffer(logs);
-        if (out.length === 0) {
-            out.push({
-                time: Date.now(),
-                message: 'No logs found for container',
-                level: 'INFO',
-                source: 'stdout',
-            });
+        if (out.length > 0) {
+            return out;
         }
-        return out;
+        const status = await this.status();
+        const healthLogs = status?.Health?.Log
+            ? status?.Health?.Log.map((log) => {
+                return {
+                    source: 'stdout',
+                    level: log.ExitCode === 0 ? 'INFO' : 'ERROR',
+                    time: Date.now(),
+                    message: 'Health check: ' + log.Output,
+                };
+            })
+            : [];
+        if (status?.Running) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is starting...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Restarting) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is restarting...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Paused) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is paused...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Error) {
+            return [
+                {
+                    source: 'stderr',
+                    level: 'ERROR',
+                    time: Date.now(),
+                    message: 'Container failed to start:\n' + status.Error,
+                },
+                ...healthLogs,
+            ];
+        }
+        return [
+            {
+                source: 'stdout',
+                level: 'INFO',
+                time: Date.now(),
+                message: 'Container not running',
+                ...healthLogs,
+            },
+        ];
     }
 }
 exports.ContainerInfo = ContainerInfo;
@@ -847,11 +927,11 @@ function getExtraHosts(dockerVersion) {
         const [major, minor] = dockerVersion.split('.');
         if (parseInt(major) >= 20 && parseInt(minor) >= 10) {
             // Docker 20.10+ on Linux supports adding host.docker.internal to point to host-gateway
-            return ['host.docker.internal:host-gateway'];
+            return [`${types_1.DOCKER_HOST_INTERNAL}:host-gateway`];
         }
         // Docker versions lower than 20.10 needs an actual IP address. We use the default network bridge which
         // is always 172.17.0.1
-        return ['host.docker.internal:172.17.0.1'];
+        return [`${types_1.DOCKER_HOST_INTERNAL}:172.17.0.1`];
     }
     return undefined;
 }

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

@@ -2,8 +2,9 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { EnvironmentType, InstanceInfo, LogEntry, OperatorInstanceInfo } from './types';
+import { EnvironmentType, InstanceInfo, LogEntry } from './types';
 import { Task } from './taskManager';
+import { InstanceOperator } from '@kapeta/sdk-config';
 export declare class InstanceManager {
     private _interval;
     private readonly _instances;
@@ -14,6 +15,7 @@ export declare class InstanceManager {
     getInstancesForPlan(systemId: string): Promise<InstanceInfo[]>;
     getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
     private exclusive;
+    private isLocked;
     getLogs(systemId: string, instanceId: string): Promise<LogEntry[]>;
     saveInternalInstance(instance: InstanceInfo): Promise<InstanceInfo>;
     /**
@@ -25,7 +27,7 @@ export declare class InstanceManager {
     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>;
+    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType, ensureContainer?: boolean): Promise<InstanceOperator<any, any>>;
     stop(systemId: string, instanceId: string): Promise<void>;
     private stopInner;
     start(systemId: string, instanceId: string, checkForSingleton?: boolean): Promise<InstanceInfo | Task<InstanceInfo>>;

package/dist/esm/src/instanceManager.js

@@ -79,6 +79,9 @@ class InstanceManager {
         //console.log(`Releasing lock for ${key}`, this.instanceLocks.isBusy(key));
         return result;
     }
+    isLocked(systemId, instanceId) {
+        return this.instanceLocks.isBusy(`${systemId}/${instanceId}`);
+    }
     async getLogs(systemId, instanceId) {
         const instance = this.getInstance(systemId, instanceId);
         if (!instance) {
@@ -212,7 +215,9 @@ class InstanceManager {
             systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
             const instance = lodash_1.default.find(this._instances, { systemId, instanceId });
             if (instance && instance.owner === types_1.InstanceOwner.EXTERNAL && instance.status !== types_1.InstanceStatus.STOPPED) {
-                instance.status = types_1.InstanceStatus.STOPPED;
+                if (instance.status != types_1.InstanceStatus.FAILED) {
+                    instance.status = types_1.InstanceStatus.STOPPED;
+                }
                 instance.pid = null;
                 instance.health = null;
                 socketManager_1.socketManager.emitSystemEvent(systemId, socketManager_1.EVENT_STATUS_CHANGED, instance);
@@ -266,7 +271,7 @@ class InstanceManager {
             name: `Stopping plan ${systemId}`,
         });
     }
-    async getInstanceOperator(systemId, instanceId, environment) {
+    async getInstanceOperator(systemId, instanceId, environment, ensureContainer = true) {
         const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
         if (!blockInstance) {
             throw new Error(`Instance not found: ${systemId}/${instanceId}`);
@@ -277,30 +282,48 @@ class InstanceManager {
             throw new Error(`Block not found: ${blockRef}`);
         }
         const operatorDefinition = await definitionsManager_1.definitionsManager.getDefinition(block.kind);
-        if (!operatorDefinition?.definition.spec.local) {
+        if (!operatorDefinition) {
+            throw new Error(`Operator not found: ${block.kind}`);
+        }
+        if (operatorDefinition.definition.kind !== types_1.KIND_BLOCK_TYPE_OPERATOR) {
+            throw new Error(`Block is not an operator: ${blockRef}`);
+        }
+        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 ports = {};
+        if (ensureContainer) {
+            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}`);
+            }
+            Object.entries(portInfo).forEach(([key, value]) => {
+                ports[key] = {
+                    protocol: value.protocol,
+                    port: parseInt(value.hostPort),
+                };
+            });
         }
-        const portInfo = await container.getPorts();
-        if (!portInfo) {
-            throw new Error(`No ports found for instance: ${instanceId}`);
+        else {
+            // If we're not ensuring the container is running we just get the ports from the local config
+            const instancePorts = await (0, utils_1.getOperatorInstancePorts)(systemId, instanceId, localConfig);
+            instancePorts.forEach((port) => {
+                ports[port.portType] = {
+                    protocol: port.protocol,
+                    port: port.hostPort,
+                };
+            });
         }
-        const hostname = serviceManager_1.serviceManager.getLocalHost(environment);
-        const ports = {};
-        Object.entries(portInfo).forEach(([key, value]) => {
-            ports[key] = {
-                protocol: value.protocol,
-                port: parseInt(value.hostPort),
-            };
-        });
+        const hostname = (0, utils_1.getRemoteHostForEnvironment)(environment);
         return {
             hostname,
             ports,
@@ -345,6 +368,7 @@ class InstanceManager {
             if (changeDesired && instance.desiredStatus !== types_1.DesiredInstanceStatus.EXTERNAL) {
                 instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
             }
+            const wasFailed = instance.status === types_1.InstanceStatus.FAILED;
             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] [intentional: %s]', systemId, instanceId, instance.desiredStatus, changeDesired);
@@ -355,7 +379,12 @@ class InstanceManager {
                     const container = await containerManager_1.containerManager.getContainerByName(containerName);
                     if (container) {
                         try {
-                            await container.stop();
+                            if (wasFailed) {
+                                await container.remove();
+                            }
+                            else {
+                                await container.stop();
+                            }
                             instance.status = types_1.InstanceStatus.STOPPED;
                             socketManager_1.socketManager.emitSystemEvent(systemId, socketManager_1.EVENT_STATUS_CHANGED, instance);
                             this.save();
@@ -411,7 +440,7 @@ class InstanceManager {
                     existingInstance = undefined;
                 }
             }
-            if (existingInstance?.pid) {
+            if (existingInstance && existingInstance.pid) {
                 if (existingInstance.status === types_1.InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -472,8 +501,7 @@ class InstanceManager {
                     return existingInstance;
                 }
             }
-            const instanceConfig = await configManager_1.configManager.getConfigForSection(systemId, instanceId);
-            const resolvedConfig = (0, utils_1.getResolvedConfiguration)(blockSpec.configuration, instanceConfig, blockInstance.defaultConfiguration);
+            const resolvedConfig = await configManager_1.configManager.getConfigForBlockInstance(systemId, instanceId);
             const task = taskManager_1.taskManager.add(`instance:start:${systemId}:${instanceId}`, async () => {
                 const runner = new BlockInstanceRunner_1.BlockInstanceRunner(systemId);
                 const startTime = Date.now();
@@ -501,8 +529,7 @@ class InstanceManager {
                     ];
                     const out = await this.saveInternalInstance({
                         ...instance,
-                        type: types_1.InstanceType.UNKNOWN,
-                        pid: null,
+                        type: types_1.InstanceType.DOCKER,
                         health: null,
                         portType: DEFAULT_HEALTH_PORT_TYPE,
                         status: types_1.InstanceStatus.FAILED,
@@ -622,9 +649,8 @@ class InstanceManager {
                 }
                 if (instance.status !== newStatus) {
                     const oldStatus = instance.status;
-                    const skipUpdate = (newStatus === types_1.InstanceStatus.STOPPED && instance.status === types_1.InstanceStatus.FAILED) ||
-                        ([types_1.InstanceStatus.READY, types_1.InstanceStatus.UNHEALTHY].includes(newStatus) &&
-                            instance.status === types_1.InstanceStatus.STOPPING) ||
+                    const skipUpdate = ([types_1.InstanceStatus.READY, types_1.InstanceStatus.UNHEALTHY].includes(newStatus) &&
+                        instance.status === types_1.InstanceStatus.STOPPING) ||
                         (newStatus === types_1.InstanceStatus.STOPPED &&
                             instance.status === types_1.InstanceStatus.STARTING &&
                             instance.desiredStatus === types_1.DesiredInstanceStatus.RUN);
@@ -637,7 +663,7 @@ class InstanceManager {
                     }
                 }
                 if (instance.desiredStatus === types_1.DesiredInstanceStatus.RUN &&
-                    [types_1.InstanceStatus.STOPPED, types_1.InstanceStatus.FAILED, types_1.InstanceStatus.STOPPING].includes(newStatus)) {
+                    [types_1.InstanceStatus.STOPPED, types_1.InstanceStatus.STOPPING].includes(newStatus)) {
                     //If the instance is stopped but we want it to run, start it
                     try {
                         await this.start(instance.systemId, instance.instanceId);
@@ -708,10 +734,23 @@ class InstanceManager {
                 return types_1.InstanceStatus.READY;
             }
             if (statusType === 'created') {
+                if (state.ExitCode !== undefined && state.ExitCode !== 0) {
+                    // Failed during creation. Exit code is not always reliable though
+                    if (state.Error) {
+                        return types_1.InstanceStatus.FAILED;
+                    }
+                    else {
+                        return types_1.InstanceStatus.STOPPED;
+                    }
+                }
                 return types_1.InstanceStatus.STARTING;
             }
             if (statusType === 'exited' || statusType === 'dead') {
-                return types_1.InstanceStatus.STOPPED;
+                if (!state.Error) {
+                    // Exit code is not always reliable - if there is no error we assume it's stopped
+                    return types_1.InstanceStatus.STOPPED;
+                }
+                return types_1.InstanceStatus.FAILED;
             }
             if (statusType === 'removing') {
                 return types_1.InstanceStatus.BUSY;

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

@@ -4,11 +4,13 @@
  */
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
-import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
+import { AnyMap, EnvironmentType } from './types';
+import { LocalInstance } from '@kapeta/schemas';
+import { ResourceInfo } from '@kapeta/sdk-config';
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);
-    getLocalData(): LocalImageOptions;
+    getLocalData(): LocalInstance;
     getDefinitionInfo(): DefinitionInfo;
     getCredentials(): any;
 }
@@ -24,7 +26,8 @@ declare class OperatorManager {
     /**
      * Get information about a specific consumed resource
      */
-    getConsumerResourceInfo(systemId: string, fromServiceId: string, resourceType: string, portType: string, name: string, environment?: EnvironmentType): Promise<OperatorInfo>;
+    getConsumerResourceInfo(systemId: string, fromServiceId: string, resourceType: string, portType: string, name: string, environment?: EnvironmentType, ensureContainer?: boolean): Promise<ResourceInfo<any, any>>;
+    getOperatorPorts(systemId: string, kind: string, version: string): Promise<AnyMap>;
     /**
      * Ensure we have a running operator of given type
      *