@kapeta/local-cluster-service 0.37.0 → 0.39.0

package/src/instanceManager.ts

@@ -28,17 +28,20 @@ import {
     KIND_BLOCK_TYPE_EXECUTABLE,
     KIND_BLOCK_TYPE_OPERATOR,
     KIND_RESOURCE_OPERATOR,
-    LocalImageOptions,
     LogEntry,
-    OperatorInstanceInfo,
-    OperatorInstancePort,
 } from './types';
-import { BlockDefinitionSpec, BlockInstance, Plan } from '@kapeta/schemas';
-import { getBlockInstanceContainerName, getResolvedConfiguration } from './utils/utils';
+import { BlockDefinitionSpec, LocalInstance, Plan } from '@kapeta/schemas';
+import {
+    getBlockInstanceContainerName,
+    getOperatorInstancePorts,
+    getRemoteHostForEnvironment,
+    getResolvedConfiguration,
+} from './utils/utils';
 import { operatorManager } from './operatorManager';
 import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
+import { InstanceOperator, InstanceOperatorPort } from '@kapeta/sdk-config';
 
 const CHECK_INTERVAL = 5000;
 const DEFAULT_HEALTH_PORT_TYPE = 'http';
@@ -118,6 +121,10 @@ export class InstanceManager {
         return result;
     }
 
+    private isLocked(systemId: string, instanceId: string) {
+        return this.instanceLocks.isBusy(`${systemId}/${instanceId}`);
+    }
+
     public async getLogs(systemId: string, instanceId: string): Promise<LogEntry[]> {
         const instance = this.getInstance(systemId, instanceId);
         if (!instance) {
@@ -293,7 +300,9 @@ export class InstanceManager {
             systemId = normalizeKapetaUri(systemId);
             const instance = _.find(this._instances, { systemId, instanceId });
             if (instance && instance.owner === InstanceOwner.EXTERNAL && instance.status !== InstanceStatus.STOPPED) {
-                instance.status = InstanceStatus.STOPPED;
+                if (instance.status != InstanceStatus.FAILED) {
+                    instance.status = InstanceStatus.STOPPED;
+                }
                 instance.pid = null;
                 instance.health = null;
                 socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
@@ -367,8 +376,9 @@ export class InstanceManager {
     public async getInstanceOperator(
         systemId: string,
         instanceId: string,
-        environment?: EnvironmentType
-    ): Promise<OperatorInstanceInfo> {
+        environment?: EnvironmentType,
+        ensureContainer: boolean = true
+    ): Promise<InstanceOperator<any, any>> {
         const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
         if (!blockInstance) {
             throw new Error(`Instance not found: ${systemId}/${instanceId}`);
@@ -381,36 +391,55 @@ export class InstanceManager {
 
         const operatorDefinition = await definitionsManager.getDefinition(block.kind);
 
-        if (!operatorDefinition?.definition.spec.local) {
-            throw new Error(`Operator block has no local definition: ${blockRef}`);
+        if (!operatorDefinition) {
+            throw new Error(`Operator not found: ${block.kind}`);
         }
 
-        const localConfig = operatorDefinition.definition.spec.local as LocalImageOptions;
-
-        let instance = await this.start(systemId, instanceId);
-        if (instance instanceof Task) {
-            instance = await instance.wait();
+        if (operatorDefinition.definition.kind !== KIND_BLOCK_TYPE_OPERATOR) {
+            throw new Error(`Block is not an operator: ${blockRef}`);
         }
 
-        const container = await containerManager.get(instance.pid as string);
-        if (!container) {
-            throw new Error(`Container not found: ${instance.pid}`);
+        if (!operatorDefinition.definition.spec.local) {
+            throw new Error(`Operator block has no local definition: ${blockRef}`);
         }
 
-        const portInfo = await container.getPorts();
-        if (!portInfo) {
-            throw new Error(`No ports found for instance: ${instanceId}`);
-        }
+        const localConfig = operatorDefinition.definition.spec.local as LocalInstance;
+        const ports: { [key: string]: InstanceOperatorPort } = {};
 
-        const hostname = serviceManager.getLocalHost(environment);
-        const ports: { [key: string]: OperatorInstancePort } = {};
+        if (ensureContainer) {
+            let instance = await this.start(systemId, instanceId);
+            if (instance instanceof Task) {
+                instance = await instance.wait();
+            }
 
-        Object.entries(portInfo).forEach(([key, value]) => {
-            ports[key] = {
-                protocol: value.protocol,
-                port: parseInt(value.hostPort),
-            };
-        });
+            const container = await containerManager.get(instance.pid as string);
+            if (!container) {
+                throw new Error(`Container not found: ${instance.pid}`);
+            }
+
+            const portInfo = await container.getPorts();
+            if (!portInfo) {
+                throw new Error(`No ports found for instance: ${instanceId}`);
+            }
+
+            Object.entries(portInfo).forEach(([key, value]) => {
+                ports[key] = {
+                    protocol: value.protocol as 'udp' | 'tcp',
+                    port: parseInt(value.hostPort),
+                };
+            });
+        } else {
+            // If we're not ensuring the container is running we just get the ports from the local config
+            const instancePorts = await getOperatorInstancePorts(systemId, instanceId, localConfig);
+            instancePorts.forEach((port) => {
+                ports[port.portType] = {
+                    protocol: port.protocol as 'udp' | 'tcp',
+                    port: port.hostPort,
+                };
+            });
+        }
+
+        const hostname = getRemoteHostForEnvironment(environment);
 
         return {
             hostname,
@@ -471,6 +500,8 @@ export class InstanceManager {
                 instance.desiredStatus = DesiredInstanceStatus.STOP;
             }
 
+            const wasFailed = instance.status === InstanceStatus.FAILED;
+
             instance.status = InstanceStatus.STOPPING;
 
             socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
@@ -489,7 +520,11 @@ export class InstanceManager {
                     const container = await containerManager.getContainerByName(containerName);
                     if (container) {
                         try {
-                            await container.stop();
+                            if (wasFailed) {
+                                await container.remove();
+                            } else {
+                                await container.stop();
+                            }
                             instance.status = InstanceStatus.STOPPED;
                             socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                             this.save();
@@ -555,7 +590,7 @@ export class InstanceManager {
                 }
             }
 
-            if (existingInstance?.pid) {
+            if (existingInstance && existingInstance.pid) {
                 if (existingInstance.status === InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -623,18 +658,15 @@ export class InstanceManager {
             if (existingInstance) {
                 // Check if the instance is already running - but after we've commmuicated the desired status
                 const currentStatus = await this.requestInstanceStatus(existingInstance);
+
                 if (currentStatus === InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
                 }
             }
 
-            const instanceConfig = await configManager.getConfigForSection(systemId, instanceId);
-            const resolvedConfig = getResolvedConfiguration(
-                blockSpec.configuration,
-                instanceConfig,
-                blockInstance.defaultConfiguration
-            );
+            const resolvedConfig = await configManager.getConfigForBlockInstance(systemId, instanceId);
+
             const task = taskManager.add(
                 `instance:start:${systemId}:${instanceId}`,
                 async () => {
@@ -666,8 +698,7 @@ export class InstanceManager {
 
                         const out = await this.saveInternalInstance({
                             ...instance,
-                            type: InstanceType.UNKNOWN,
-                            pid: null,
+                            type: InstanceType.DOCKER,
                             health: null,
                             portType: DEFAULT_HEALTH_PORT_TYPE,
                             status: InstanceStatus.FAILED,
@@ -811,7 +842,6 @@ export class InstanceManager {
                 if (instance.status !== newStatus) {
                     const oldStatus = instance.status;
                     const skipUpdate =
-                        (newStatus === InstanceStatus.STOPPED && instance.status === InstanceStatus.FAILED) ||
                         ([InstanceStatus.READY, InstanceStatus.UNHEALTHY].includes(newStatus) &&
                             instance.status === InstanceStatus.STOPPING) ||
                         (newStatus === InstanceStatus.STOPPED &&
@@ -835,7 +865,7 @@ export class InstanceManager {
 
                 if (
                     instance.desiredStatus === DesiredInstanceStatus.RUN &&
-                    [InstanceStatus.STOPPED, InstanceStatus.FAILED, InstanceStatus.STOPPING].includes(newStatus)
+                    [InstanceStatus.STOPPED, InstanceStatus.STOPPING].includes(newStatus)
                 ) {
                     //If the instance is stopped but we want it to run, start it
                     try {
@@ -928,11 +958,23 @@ export class InstanceManager {
             }
 
             if (statusType === 'created') {
+                if (state.ExitCode !== undefined && state.ExitCode !== 0) {
+                    // Failed during creation. Exit code is not always reliable though
+                    if (state.Error) {
+                        return InstanceStatus.FAILED;
+                    } else {
+                        return InstanceStatus.STOPPED;
+                    }
+                }
                 return InstanceStatus.STARTING;
             }
 
             if (statusType === 'exited' || statusType === 'dead') {
-                return InstanceStatus.STOPPED;
+                if (!state.Error) {
+                    // Exit code is not always reliable - if there is no error we assume it's stopped
+                    return InstanceStatus.STOPPED;
+                }
+                return InstanceStatus.FAILED;
             }
 
             if (statusType === 'removing') {
@@ -1013,7 +1055,7 @@ export class InstanceManager {
         }
 
         if (parseKapetaUri(provider.kind).fullName === KIND_BLOCK_TYPE_OPERATOR) {
-            const localConfig = provider.data.spec.local as LocalImageOptions;
+            const localConfig = provider.data.spec.local as LocalInstance;
             return localConfig.singleton ?? false;
         }
 

package/src/operatorManager.ts

@@ -16,22 +16,15 @@ import {
     containerManager,
 } from './containerManager';
 import FSExtra from 'fs-extra';
-import {
-    AnyMap,
-    EnvironmentType,
-    KIND_BLOCK_TYPE_OPERATOR,
-    KIND_RESOURCE_OPERATOR,
-    LocalImageOptions,
-    OperatorInfo,
-    StringMap,
-} from './types';
-import { BlockInstance, Resource } from '@kapeta/schemas';
+import { AnyMap, EnvironmentType, KIND_BLOCK_TYPE_OPERATOR, KIND_RESOURCE_OPERATOR, StringMap } from './types';
+import { BlockInstance, LocalInstance, Resource } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
-import { getBindHost, toPortInfo } from './utils/utils';
+import { getDockerHostIp, getRemoteHostForEnvironment, toPortInfo } from './utils/utils';
 import { parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import _ from 'lodash';
 import AsyncLock from 'async-lock';
 import { taskManager } from './taskManager';
+import { ResourceInfo } from '@kapeta/sdk-config';
 
 const KIND_PLAN = 'core/plan';
 
@@ -42,7 +35,7 @@ class Operator {
         this._data = data;
     }
 
-    getLocalData(): LocalImageOptions {
+    getLocalData(): LocalInstance {
         return this._data.definition.spec.local;
     }
 
@@ -105,8 +98,9 @@ class OperatorManager {
         resourceType: string,
         portType: string,
         name: string,
-        environment?: EnvironmentType
-    ): Promise<OperatorInfo> {
+        environment?: EnvironmentType,
+        ensureContainer: boolean = true
+    ): Promise<ResourceInfo<any, any>> {
         systemId = normalizeKapetaUri(systemId);
         const plans = await definitionsManager.getDefinitions(KIND_PLAN);
 
@@ -145,10 +139,13 @@ class OperatorManager {
         const kindUri = parseKapetaUri(blockResource.kind);
         const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
-        const container = await this.ensureOperator(systemId, resourceType, kindUri.version);
-        const portInfo = await container.getPort(portType);
+        if (ensureContainer) {
+            await this.ensureOperator(systemId, resourceType, kindUri.version);
+        }
+
+        const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
 
-        if (!portInfo) {
+        if (!hostPort) {
             throw new Error('Unknown resource port type : ' + resourceType + '#' + portType);
         }
 
@@ -156,10 +153,10 @@ class OperatorManager {
         const safeName = dbName.replace('_', '-');
 
         return {
-            host: environment === 'docker' ? 'host.docker.internal' : '127.0.0.1',
-            port: portInfo.hostPort,
+            host: getRemoteHostForEnvironment(environment),
+            port: hostPort,
             type: portType,
-            protocol: portInfo.protocol,
+            protocol: 'tcp',
             options: {
                 // expose as fullName since that is not operator specific, but unique
                 fullName: safeName,
@@ -169,6 +166,34 @@ class OperatorManager {
         };
     }
 
+    async getOperatorPorts(systemId: string, kind: string, version: string) {
+        const operator = await this.getOperator(kind, version);
+
+        const operatorData = operator.getLocalData();
+
+        const portTypes = Object.keys(operatorData.ports);
+
+        portTypes.sort();
+
+        const ports: AnyMap = {};
+
+        for (let i = 0; i < portTypes.length; i++) {
+            const portType = portTypes[i];
+            let containerPortInfo = operatorData.ports[portType];
+            const hostPort = await serviceManager.ensureServicePort(systemId, kind, portType);
+            const portInfo = toPortInfo(containerPortInfo);
+            const portId = portInfo.port + '/' + portInfo.type;
+
+            ports[portId] = {
+                type: portType,
+                hostPort,
+                protocol: portInfo.type,
+            };
+        }
+
+        return ports;
+    }
+
     /**
      * Ensure we have a running operator of given type
      *
@@ -186,24 +211,7 @@ class OperatorManager {
 
             const operatorData = operator.getLocalData();
 
-            const portTypes = Object.keys(operatorData.ports);
-
-            portTypes.sort();
-
-            const ports: AnyMap = {};
-
-            for (let i = 0; i < portTypes.length; i++) {
-                const portType = portTypes[i];
-                let containerPortInfo = operatorData.ports[portType];
-                const hostPort = await serviceManager.ensureServicePort(systemId, kind, portType);
-                const portInfo = toPortInfo(containerPortInfo);
-                const portId = portInfo.port + '/' + portInfo.type;
-
-                ports[portId] = {
-                    type: portType,
-                    hostPort,
-                };
-            }
+            const ports = await this.getOperatorPorts(systemId, kind, version);
 
             const nameParts = [systemId, kind.toLowerCase(), version];
 
@@ -222,7 +230,7 @@ class OperatorManager {
 
             const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
 
-            const bindHost = getBindHost();
+            const hostIp = getDockerHostIp();
 
             const ExposedPorts: { [key: string]: any } = {};
 
@@ -231,7 +239,7 @@ class OperatorManager {
                 PortBindings['' + containerPort] = [
                     {
                         HostPort: '' + portInfo.hostPort,
-                        HostIp: bindHost,
+                        HostIp: hostIp,
                     },
                 ];
 

package/src/progressListener.ts

@@ -7,6 +7,7 @@ import { spawn } from '@kapeta/nodejs-process';
 import { socketManager } from './socketManager';
 import { LogEntry } from './types';
 import { format } from 'node:util';
+import { Task } from './taskManager';
 
 export class ProgressListener {
     private readonly systemId: string | undefined;
@@ -17,7 +18,7 @@ export class ProgressListener {
         this.instanceId = instanceId;
     }
 
-    private emitLog(payload: Omit<LogEntry, 'time' | 'source'>) {
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>) {
         const logEntry: LogEntry = {
             ...payload,
             source: 'stdout',
@@ -135,3 +136,16 @@ export class ProgressListener {
         });
     }
 }
+
+export class TaskProgressListener extends ProgressListener {
+    private readonly task: Task;
+
+    constructor(task: Task) {
+        super();
+        this.task = task;
+    }
+
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>) {
+        this.task.addLog(payload.message, payload.level);
+    }
+}

package/src/repositoryManager.ts

@@ -10,7 +10,7 @@ import { Actions, AssetVersion, Config, RegistryService } from '@kapeta/nodejs-r
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
 import { normalizeKapetaUri, parseKapetaUri, parseVersion } from '@kapeta/nodejs-utils';
-import { ProgressListener } from './progressListener';
+import { TaskProgressListener } from './progressListener';
 import { RepositoryWatcher } from './RepositoryWatcher';
 import { SourceOfChange } from './types';
 import { cacheManager } from './cacheManager';
@@ -191,16 +191,18 @@ class RepositoryManager extends EventEmitter {
     private async scheduleInstallation(refs: string[]): Promise<Task[]> {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref: string) => {
-            return async () => {
+            return async (task: Task) => {
                 if (await definitionsManager.exists(ref)) {
                     return;
                 }
+
+                const progressListener = new TaskProgressListener(task);
                 //console.log(`Installing asset: ${ref}`);
                 //Auto-install missing asset
                 try {
                     //We change to a temp dir to avoid issues with the current working directory
                     process.chdir(os.tmpdir());
-                    await Actions.install(new ProgressListener(), [ref], {});
+                    await Actions.install(progressListener, [ref], {});
                 } catch (e) {
                     console.error(`Failed to install asset: ${ref}`, e);
                     throw e;

package/src/serviceManager.ts

@@ -6,9 +6,10 @@
 import _ from 'lodash';
 import { clusterService } from './clusterService';
 import { storageService } from './storageService';
-import { EnvironmentType } from './types';
+import { DOCKER_HOST_INTERNAL, EnvironmentType } from './types';
 import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { resolvePortType } from './utils/BlockInstanceRunner';
+import { getRemoteHostForEnvironment } from './utils/utils';
 
 export const HTTP_PORT_TYPE = 'http';
 
@@ -34,20 +35,11 @@ class ServiceManager {
         });
     }
 
-    public getLocalHost(environmentType?: EnvironmentType) {
-        if (environmentType === 'docker') {
-            //We're inside a docker container, so we can use this special host name to access the host machine
-            return 'host.docker.internal';
-        }
-
-        return clusterService.getClusterServiceHost();
-    }
-
     _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType) {
         if (!path) {
             path = '';
         }
-        const hostname = this.getLocalHost(environmentType);
+        const hostname = getRemoteHostForEnvironment(environmentType);
 
         if (path.startsWith('/')) {
             path = path.substring(1);

package/src/taskManager.ts

@@ -7,10 +7,12 @@
  * Class that handles processing background tasks.
  */
 import { socketManager } from './socketManager';
+import { LogLevel } from './types';
 
 const EVENT_TASK_UPDATED = 'task-updated';
 const EVENT_TASK_ADDED = 'task-added';
 const EVENT_TASK_REMOVED = 'task-removed';
+const EVENT_TASK_LOG = 'task-log';
 
 export type TaskRunner<T> = (task: Task<T>) => Promise<T>;
 
@@ -94,6 +96,15 @@ export class Task<T = void> implements TaskData<T> {
         socketManager.emitGlobal(EVENT_TASK_UPDATED, this.toData());
     }
 
+    public addLog(log: string, level: LogLevel = 'INFO') {
+        socketManager.emitGlobal(EVENT_TASK_LOG, {
+            id: this.id,
+            message: log,
+            level,
+            time: Date.now(),
+        });
+    }
+
     async wait(): Promise<T> {
         return this.future.promise;
     }

package/src/types.ts

@@ -21,6 +21,8 @@ export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE' | 'FATAL';
 export type LogSource = 'stdout' | 'stderr';
 export type EnvironmentType = 'docker' | 'process';
 
+export const DOCKER_HOST_INTERNAL = 'host.docker.internal';
+
 export interface LogEntry {
     source: LogSource;
     level: LogLevel;
@@ -66,27 +68,6 @@ export type ProcessInfo = {
     portType?: string;
 };
 
-export interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
-
-export type PortInfo = { port: number; type: 'tcp' | 'udp' } | number | string;
-
-export type LocalImageOptions<Credentials = AnyMap, Options = AnyMap> = {
-    image: string;
-    ports: { [key: string]: PortInfo };
-    credentials?: Credentials;
-    options?: Options;
-    cmd?: string;
-    env?: AnyMap;
-    health?: Health;
-    singleton?: boolean;
-    mounts?: { [key: string]: string };
-};
-
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -105,37 +86,8 @@ export type InstanceInfo = {
     portType?: string;
 };
 
-interface ResourceRef {
-    blockId: string;
-    resourceName: string;
-}
-
 export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
 
-export interface OperatorInstancePort {
-    protocol: string;
-    port: number;
-}
-
-export interface OperatorInstanceInfo {
-    hostname: string;
-    ports: { [portType: string]: OperatorInstancePort };
-    path?: string;
-    query?: string;
-    hash?: string;
-    options?: AnyMap;
-    credentials?: AnyMap;
-}
-
-export interface OperatorInfo {
-    host: string;
-    port: string;
-    type: string;
-    protocol: string;
-    options: AnyMap;
-    credentials: AnyMap;
-}
-
 export interface ProxyRequestInfo {
     address: string;
     connection: Connection;