@kapeta/local-cluster-service 0.38.0 → 0.39.1

package/index.ts

@@ -24,7 +24,7 @@ import AttachmentRoutes from './src/attachments/routes';
 import TaskRoutes from './src/tasks/routes';
 import APIRoutes from './src/api';
 import AIRoutes from './src/ai/routes';
-import { getBindHost } from './src/utils/utils';
+import { isLinux } from './src/utils/utils';
 import request from 'request';
 import { repositoryManager } from './src/repositoryManager';
 import { taskManager } from './src/taskManager';
@@ -223,7 +223,10 @@ export default {
                 reject(err);
             });
 
-            const bindHost = 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 = isLinux() ? '0.0.0.0' : host;
 
             currentServer.listen(port, bindHost, async () => {
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.38.0",
+    "version": "0.39.1",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -53,12 +53,11 @@
         "@kapeta/local-cluster-config": "^0.4.0",
         "@kapeta/nodejs-api-client": ">=0.2.0 <2",
         "@kapeta/nodejs-process": "^1.2.0",
-        "@kapeta/nodejs-registry-utils": ">=0.10.0 <2",
+        "@kapeta/nodejs-registry-utils": ">=0.11.1 <2",
         "@kapeta/nodejs-utils": "<2",
-        "@kapeta/schemas": "^3.4.0",
-        "@kapeta/sdk-config": "^2.1.0",
+        "@kapeta/schemas": "^3.5.0",
+        "@kapeta/sdk-config": "^2.1.1",
         "@kapeta/ui-web-components": "^3.1.0",
-        "@kapeta/ui-web-plan-editor": "^2.3.1",
         "@kapeta/ui-web-types": "^1.3.1",
         "@kapeta/web-microfrontend": "^1.2.5",
         "@sentry/node": "^7.94.1",
@@ -83,7 +82,8 @@
         "stream-json": "^1.8.0",
         "tar-stream": "^3.1.6",
         "typescript": "^5.1.6",
-        "yaml": "^1.6.0"
+        "yaml": "^1.6.0",
+        "@kapeta/config-mapper": "^1.1.1"
     },
     "devDependencies": {
         "@kapeta/eslint-config": "^0.7.0",

package/src/config/routes.ts

@@ -157,7 +157,8 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req: Kapet
         req.params.resourceType,
         req.params.portType,
         req.params.name,
-        req.kapeta!.environment
+        req.kapeta!.environment,
+        req.query.ensure !== 'false'
     );
 
     res.send(operatorInfo);
@@ -190,7 +191,8 @@ router.get('/operator/:instanceId', async (req: KapetaRequest, res) => {
     const operatorInfo = await instanceManager.getInstanceOperator(
         req.kapeta!.systemId,
         req.params.instanceId,
-        req.kapeta!.environment
+        req.kapeta!.environment,
+        req.query.ensure !== 'false'
     );
 
     res.send(operatorInfo);

package/src/containerManager.ts

@@ -14,7 +14,7 @@ import ClusterConfiguration from '@kapeta/local-cluster-config';
 import uuid from 'node-uuid';
 import md5 from 'md5';
 import { getBlockInstanceContainerName } from './utils/utils';
-import { InstanceInfo, LogEntry, LogSource } from './types';
+import { DOCKER_HOST_INTERNAL, InstanceInfo, LogEntry, LogSource } from './types';
 import { KapetaAPI } from '@kapeta/nodejs-api-client';
 import { taskManager, Task } from './taskManager';
 import { EventEmitter } from 'node:events';
@@ -665,7 +665,9 @@ class ContainerManager {
         const newName = 'deleting-' + uuid.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 });
     }
 
     /**
@@ -1144,11 +1146,11 @@ export function getExtraHosts(dockerVersion: string): string[] | undefined {
         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 [`${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 [`${DOCKER_HOST_INTERNAL}:172.17.0.1`];
     }
 
     return undefined;

package/src/instanceManager.ts

@@ -29,15 +29,19 @@ import {
     KIND_BLOCK_TYPE_OPERATOR,
     KIND_RESOURCE_OPERATOR,
     LogEntry,
-    OperatorInstanceInfo,
-    OperatorInstancePort,
 } from './types';
 import { BlockDefinitionSpec, LocalInstance, Plan } from '@kapeta/schemas';
-import { getBlockInstanceContainerName, getResolvedConfiguration } from './utils/utils';
+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';
@@ -117,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) {
@@ -368,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}`);
@@ -382,36 +391,55 @@ export class InstanceManager {
 
         const operatorDefinition = await definitionsManager.getDefinition(block.kind);
 
-        if (!operatorDefinition?.definition.spec.local) {
+        if (!operatorDefinition) {
+            throw new Error(`Operator not found: ${block.kind}`);
+        }
+
+        if (operatorDefinition.definition.kind !== 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 as LocalInstance;
+        const ports: { [key: string]: InstanceOperatorPort } = {};
 
-        let instance = await this.start(systemId, instanceId);
-        if (instance instanceof Task) {
-            instance = await instance.wait();
-        }
+        if (ensureContainer) {
+            let instance = await this.start(systemId, instanceId);
+            if (instance instanceof Task) {
+                instance = await instance.wait();
+            }
 
-        const container = await containerManager.get(instance.pid as string);
-        if (!container) {
-            throw new Error(`Container not found: ${instance.pid}`);
-        }
+            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}`);
-        }
+            const portInfo = await container.getPorts();
+            if (!portInfo) {
+                throw new Error(`No ports found for instance: ${instanceId}`);
+            }
 
-        const hostname = serviceManager.getLocalHost(environment);
-        const ports: { [key: string]: OperatorInstancePort } = {};
+            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,
+                };
+            });
+        }
 
-        Object.entries(portInfo).forEach(([key, value]) => {
-            ports[key] = {
-                protocol: value.protocol,
-                port: parseInt(value.hostPort),
-            };
-        });
+        const hostname = getRemoteHostForEnvironment(environment);
 
         return {
             hostname,
@@ -472,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);
@@ -490,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();
@@ -556,7 +590,7 @@ export class InstanceManager {
                 }
             }
 
-            if (existingInstance?.pid) {
+            if (existingInstance && existingInstance.pid) {
                 if (existingInstance.status === InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -624,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 () => {
@@ -927,15 +958,20 @@ export class InstanceManager {
             }
 
             if (statusType === 'created') {
-                if (state.ExitCode !== 0) {
-                    // Failed during creation
-                    return InstanceStatus.FAILED;
+                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') {
-                if (state.ExitCode === 0) {
+                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;

package/src/operatorManager.ts

@@ -16,21 +16,15 @@ import {
     containerManager,
 } from './containerManager';
 import FSExtra from 'fs-extra';
-import {
-    AnyMap,
-    EnvironmentType,
-    KIND_BLOCK_TYPE_OPERATOR,
-    KIND_RESOURCE_OPERATOR,
-    OperatorInfo,
-    StringMap,
-} from './types';
+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';
 
@@ -104,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);
 
@@ -144,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);
         }
 
@@ -155,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,
@@ -168,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
      *
@@ -185,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];
 
@@ -221,7 +230,7 @@ class OperatorManager {
 
             const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
 
-            const bindHost = getBindHost();
+            const hostIp = getDockerHostIp();
 
             const ExposedPorts: { [key: string]: any } = {};
 
@@ -230,7 +239,7 @@ class OperatorManager {
                 PortBindings['' + containerPort] = [
                     {
                         HostPort: '' + portInfo.hostPort,
-                        HostIp: bindHost,
+                        HostIp: hostIp,
                     },
                 ];
 

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/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,13 +68,6 @@ export type ProcessInfo = {
     portType?: string;
 };
 
-export interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
-
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -93,30 +88,6 @@ export type InstanceInfo = {
 
 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;