@kapeta/local-cluster-service 0.19.6 → 0.20.0

package/src/instanceManager.ts

@@ -6,11 +6,16 @@ import { storageService } from './storageService';
 import { EVENT_INSTANCE_CREATED, EVENT_INSTANCE_EXITED, EVENT_STATUS_CHANGED, socketManager } from './socketManager';
 import { serviceManager } from './serviceManager';
 import { assetManager } from './assetManager';
-import { containerManager, HEALTH_CHECK_TIMEOUT } from './containerManager';
+import {
+    containerManager,
+    DockerContainerHealth,
+    DockerContainerStatus,
+    HEALTH_CHECK_TIMEOUT,
+} from './containerManager';
 import { configManager } from './configManager';
 import { DesiredInstanceStatus, InstanceInfo, InstanceOwner, InstanceStatus, InstanceType, LogEntry } from './types';
 import { BlockDefinitionSpec, BlockInstance, Plan } from '@kapeta/schemas';
-import { getBlockInstanceContainerName, normalizeKapetaUri } from './utils/utils';
+import { getBlockInstanceContainerName, getResolvedConfiguration, normalizeKapetaUri } from './utils/utils';
 import { KIND_OPERATOR, operatorManager } from './operatorManager';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { definitionsManager } from './definitionsManager';
@@ -336,6 +341,10 @@ export class InstanceManager {
                 return;
             }
 
+            if (instance.status === InstanceStatus.STOPPING) {
+                return;
+            }
+
             if (changeDesired && instance.desiredStatus !== DesiredInstanceStatus.EXTERNAL) {
                 instance.desiredStatus = DesiredInstanceStatus.STOP;
             }
@@ -488,15 +497,20 @@ export class InstanceManager {
             }
 
             const instanceConfig = await configManager.getConfigForSection(systemId, instanceId);
+            const resolvedConfig = getResolvedConfiguration(
+                blockSpec.configuration,
+                instanceConfig,
+                blockInstance.defaultConfiguration
+            );
             const task = taskManager.add(
                 `instance:start:${systemId}:${instanceId}`,
                 async () => {
                     const runner = new BlockInstanceRunner(systemId);
                     const startTime = Date.now();
                     try {
-                        const processInfo = await runner.start(blockRef, instanceId, instanceConfig);
+                        const processInfo = await runner.start(blockRef, instanceId, resolvedConfig);
 
-                        instance.status = InstanceStatus.READY;
+                        instance.status = InstanceStatus.STARTING;
 
                         return this.saveInternalInstance({
                             ...instance,
@@ -504,10 +518,10 @@ export class InstanceManager {
                             pid: processInfo.pid ?? -1,
                             health: null,
                             portType: processInfo.portType,
-                            status: InstanceStatus.READY,
+                            status: InstanceStatus.STARTING,
                         });
                     } catch (e: any) {
-                        console.warn('Failed to start instance: ', systemId, instanceId, blockRef, e.message);
+                        console.warn('Failed to start instance: ', systemId, instanceId, blockRef, e);
                         const logs: LogEntry[] = [
                             {
                                 source: 'stdout',
@@ -686,7 +700,12 @@ export class InstanceManager {
                     try {
                         await this.start(instance.systemId, instance.instanceId);
                     } catch (e: any) {
-                        console.warn('Failed to start instance', instance.systemId, instance.instanceId, e);
+                        console.warn(
+                            'Failed to start previously stopped instance',
+                            instance.systemId,
+                            instance.instanceId,
+                            e
+                        );
                     }
                     return;
                 }
@@ -738,37 +757,47 @@ export class InstanceManager {
                 return InstanceStatus.STOPPED;
             }
             const state = await container.status();
+            if (!state) {
+                return InstanceStatus.STOPPED;
+            }
 
-            if (state.Status === 'running') {
-                if (state.Health?.Status === 'healthy') {
-                    return InstanceStatus.READY;
-                }
-                if (state.Health?.Status === 'starting') {
-                    return InstanceStatus.STARTING;
-                }
-                if (state.Health?.Status === 'unhealthy') {
-                    return InstanceStatus.UNHEALTHY;
-                }
+            const statusType = state.Status as DockerContainerStatus;
 
+            if (statusType === 'running') {
+                if (state.Health?.Status) {
+                    const healthStatusType = state.Health.Status as DockerContainerHealth;
+                    if (healthStatusType === 'healthy' || healthStatusType === 'none') {
+                        return InstanceStatus.READY;
+                    }
+
+                    if (healthStatusType === 'starting') {
+                        return InstanceStatus.STARTING;
+                    }
+
+                    if (healthStatusType === 'unhealthy') {
+                        return InstanceStatus.UNHEALTHY;
+                    }
+                }
                 return InstanceStatus.READY;
             }
-            if (state.Status === 'created') {
+
+            if (statusType === 'created') {
                 return InstanceStatus.STARTING;
             }
 
-            if (state.Status === 'exited' || state.Status === 'dead') {
+            if (statusType === 'exited' || statusType === 'dead') {
                 return InstanceStatus.STOPPED;
             }
 
-            if (state.Status === 'removing') {
+            if (statusType === 'removing') {
                 return InstanceStatus.BUSY;
             }
 
-            if (state.Status === 'restarting') {
+            if (statusType === 'restarting') {
                 return InstanceStatus.BUSY;
             }
 
-            if (state.Status === 'paused') {
+            if (statusType === 'paused') {
                 return InstanceStatus.BUSY;
             }
 

package/src/operatorManager.ts

@@ -4,7 +4,13 @@ import md5 from 'md5';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from './serviceManager';
 import { storageService } from './storageService';
-import { CONTAINER_LABEL_PORT_PREFIX, ContainerInfo, containerManager } from './containerManager';
+import {
+    COMPOSE_LABEL_PROJECT,
+    COMPOSE_LABEL_SERVICE,
+    CONTAINER_LABEL_PORT_PREFIX,
+    ContainerInfo,
+    containerManager,
+} from './containerManager';
 import FSExtra from 'fs-extra';
 import { AnyMap, EnvironmentType, OperatorInfo, StringMap } from './types';
 import { BlockInstance, Resource } from '@kapeta/schemas';
@@ -199,8 +205,12 @@ class OperatorManager {
             const PortBindings: { [key: string]: any } = {};
             const Env: string[] = [];
 
+            const systemUri = parseKapetaUri(systemId);
+
             const Labels: StringMap = {
                 kapeta: 'true',
+                [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                [COMPOSE_LABEL_SERVICE]: [resourceType, version].join('_').replace(/[^a-z0-9]/gi, '_'),
             };
 
             const operatorMetadata = operator.getDefinitionInfo().definition.metadata;

package/src/taskManager.ts

@@ -139,7 +139,9 @@ class TaskManager {
 
         socketManager.emitGlobal(EVENT_TASK_ADDED, task.toData());
 
-        this.invokeTask(task).catch(() => {});
+        this.invokeTask(task).catch((err) => {
+            console.warn(`Task ${task.id} failed`, err);
+        });
 
         return task;
     }
@@ -205,6 +207,7 @@ class TaskManager {
             task.future.resolve(result);
             task.emitUpdate();
         } catch (e: any) {
+            console.warn(`Task ${task.id} failed while waiting for it to resolve`, e);
             task.errorMessage = e.message;
             task.status = TaskStatus.FAILED;
             task.future.reject(e);

package/src/utils/BlockInstanceRunner.ts

@@ -3,12 +3,18 @@ import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { getBindHost, getBlockInstanceContainerName, normalizeKapetaUri, readYML } from './utils';
 import { KapetaURI, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from '../serviceManager';
-import { containerManager, DockerMounts, toLocalBindVolume } from '../containerManager';
+import {
+    COMPOSE_LABEL_PROJECT,
+    COMPOSE_LABEL_SERVICE,
+    containerManager,
+    DockerMounts,
+    toLocalBindVolume,
+} from '../containerManager';
 import { LogData } from './LogData';
 import { clusterService } from '../clusterService';
 import { AnyMap, BlockProcessParams, InstanceType, ProcessInfo, StringMap } from '../types';
-import { Container } from 'node-docker-api/lib/container';
 import { definitionsManager } from '../definitionsManager';
+import Docker from 'dockerode';
 
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
@@ -185,6 +191,8 @@ export class BlockInstanceRunner {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
 
+        const systemUri = parseKapetaUri(this._systemId);
+
         return this.ensureContainer({
             ...dockerOpts,
             Image: dockerImage,
@@ -193,6 +201,8 @@ export class BlockInstanceRunner {
             Labels: {
                 ...customLabels,
                 instance: blockInstance.id,
+                [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                [COMPOSE_LABEL_SERVICE]: blockInfo.id.replace(/[^a-z0-9]/gi, '_'),
             },
             HealthCheck,
             ExposedPorts,
@@ -250,6 +260,7 @@ export class BlockInstanceRunner {
 
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
+        const systemUri = parseKapetaUri(this._systemId);
 
         return this.ensureContainer({
             Image: dockerImage,
@@ -257,6 +268,8 @@ export class BlockInstanceRunner {
             ExposedPorts,
             Labels: {
                 instance: blockInstance.id,
+                [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                [COMPOSE_LABEL_SERVICE]: blockInfo.id.replace(/[^a-z0-9]/gi, '_'),
             },
             Env: [
                 ...DOCKER_ENV_VARS,
@@ -354,6 +367,7 @@ export class BlockInstanceRunner {
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
 
+        const systemUri = parseKapetaUri(this._systemId);
         logs.addLog(`Creating new container for block: ${containerName}`);
         const out = await this.ensureContainer({
             Image: dockerImage,
@@ -370,6 +384,8 @@ export class BlockInstanceRunner {
             },
             Labels: {
                 instance: blockInstance.id,
+                [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                [COMPOSE_LABEL_SERVICE]: blockUri.id.replace(/[^a-z0-9]/gi, '_'),
             },
             Env: [
                 `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
@@ -424,7 +440,7 @@ export class BlockInstanceRunner {
         return this._handleContainer(container);
     }
 
-    private async _handleContainer(container: Container): Promise<ProcessInfo> {
+    private async _handleContainer(container: Docker.Container): Promise<ProcessInfo> {
         return {
             type: InstanceType.DOCKER,
             pid: container.id,

package/src/utils/utils.ts

@@ -2,6 +2,9 @@ import FS from 'node:fs';
 import YAML from 'yaml';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import md5 from 'md5';
+import { EntityList } from '@kapeta/schemas';
+import _ from 'lodash';
+import { AnyMap } from '../types';
 
 export function getBlockInstanceContainerName(systemId: string, instanceId: string) {
     return `kapeta-block-instance-${md5(systemId + instanceId)}`;
@@ -47,3 +50,29 @@ export function getBindHost(preferredHost = '127.0.0.1') {
     // 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;
 }
+
+export function getResolvedConfiguration(entities?: EntityList, config?: AnyMap, globalConfiguration?: AnyMap): AnyMap {
+    if (!entities || !globalConfiguration) {
+        return config || {};
+    }
+
+    const mergedConfig = config ? _.cloneDeep(config) : {};
+    entities.types?.forEach((type) => {
+        if (!type.properties) {
+            return;
+        }
+        Object.entries(type.properties).forEach(([propertyName, property]) => {
+            if (!property.global) {
+                return;
+            }
+
+            const configPath = type.name + '.' + propertyName;
+            const defaultValue = globalConfiguration ? _.get(globalConfiguration, configPath) : undefined;
+            if (!_.has(mergedConfig, configPath)) {
+                _.set(mergedConfig, configPath, defaultValue);
+            }
+        });
+    });
+
+    return mergedConfig;
+}