@kapeta/local-cluster-service 0.19.5 → 0.19.7

package/src/instanceManager.ts

@@ -6,7 +6,12 @@ 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';
@@ -336,6 +341,10 @@ export class InstanceManager {
                 return;
             }
 
+            if (instance.status === InstanceStatus.STOPPING) {
+                return;
+            }
+
             if (changeDesired && instance.desiredStatus !== DesiredInstanceStatus.EXTERNAL) {
                 instance.desiredStatus = DesiredInstanceStatus.STOP;
             }
@@ -496,7 +505,7 @@ export class InstanceManager {
                     try {
                         const processInfo = await runner.start(blockRef, instanceId, instanceConfig);
 
-                        instance.status = InstanceStatus.READY;
+                        instance.status = InstanceStatus.STARTING;
 
                         return this.saveInternalInstance({
                             ...instance,
@@ -504,10 +513,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 +695,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 +752,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';
@@ -171,6 +177,13 @@ export class BlockInstanceRunner {
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
         const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
 
+        const customHostConfigs = localContainer.HostConfig ?? {};
+        const customLabels = localContainer.Labels ?? {};
+        const customEnvs = localContainer.Env ?? [];
+        delete localContainer.HostConfig;
+        delete localContainer.Labels;
+        delete localContainer.Env;
+
         const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
 
         let HealthCheck = undefined;
@@ -178,17 +191,24 @@ export class BlockInstanceRunner {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
 
+        const systemUri = parseKapetaUri(this._systemId);
+
         return this.ensureContainer({
+            ...dockerOpts,
             Image: dockerImage,
             name: containerName,
             WorkingDir: workingDir,
             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,
             Cmd: startCmd ? startCmd.split(/\s+/g) : [],
             Env: [
+                ...customEnvs,
                 ...DOCKER_ENV_VARS,
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
                 ...Object.entries({
@@ -197,13 +217,13 @@ export class BlockInstanceRunner {
                 }).map(([key, value]) => `${key}=${value}`),
             ],
             HostConfig: {
+                ...customHostConfigs,
                 Binds: [
                     `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${homeDir}/.kapeta`,
                     `${toLocalBindVolume(baseDir)}:${workingDir}`,
                 ],
                 PortBindings,
             },
-            ...dockerOpts,
         });
     }
 
@@ -240,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,
@@ -247,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,
@@ -344,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,
@@ -360,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}`,
@@ -414,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,