@kapeta/local-cluster-service 0.1.2 → 0.2.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.2.1](https://github.com/kapetacom/local-cluster-service/compare/v0.2.0...v0.2.1) (2023-05-07)
+
+
+### Bug Fixes
+
+* Missing semantic ([7173501](https://github.com/kapetacom/local-cluster-service/commit/7173501faf2a15caa373ef2f89c6e718deaa06f1))
+
+# [0.2.0](https://github.com/kapetacom/local-cluster-service/compare/v0.1.2...v0.2.0) (2023-05-07)
+
+
+### Features
+
+* Add support for health checks and mounts ([cac607b](https://github.com/kapetacom/local-cluster-service/commit/cac607bc8b592e27c8b6c2ff09476f90b2e4c3f3))
+
 ## [0.1.2](https://github.com/kapetacom/local-cluster-service/compare/v0.1.1...v0.1.2) (2023-05-06)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
   "main": "index.js",
   "repository": {

package/src/containerManager.js

@@ -3,10 +3,14 @@ const path = require("path");
 const _ = require('lodash');
 const FS = require("node:fs");
 const os = require("os");
+const Path = require("path");
+const storageService = require("./storageService");
+const mkdirp = require("mkdirp");
+const {parseKapetaUri} = require("@kapeta/nodejs-utils");
 const LABEL_PORT_PREFIX = "kapeta_port-";
 
 const NANO_SECOND = 1000000;
-const HEALTH_CHECK_INTERVAL = 1000;
+const HEALTH_CHECK_INTERVAL = 2000;
 const HEALTH_CHECK_MAX = 20;
 
 const promisifyStream = (stream) =>
@@ -20,12 +24,32 @@ class ContainerManager {
     constructor() {
         this._docker = null;
         this._alive = false;
+        this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
+        mkdirp.sync(this._mountDir);
     }
+    
+    
 
     isAlive() {
         return this._alive;
     }
 
+    getMountPoint(kind, mountName) {
+        const kindUri = parseKapetaUri(kind);
+        return Path.join(this._mountDir, kindUri.handle, kindUri.name, mountName);
+    }
+    
+    createMounts(kind, mountOpts) {
+        const mounts = {};
+
+        _.forEach(mountOpts, (containerPath, mountName) => {
+            const hostPath = this.getMountPoint(kind, mountName);
+            mkdirp.sync(hostPath);
+            mounts[containerPath] = hostPath;
+        });
+        return mounts;
+    }
+
     async initialize() {
         // try
         const connectOptions = [
@@ -94,6 +118,34 @@ class ContainerManager {
             )
             .then((stream) => promisifyStream(stream));
     }
+    
+    toDockerMounts(mounts) {
+        const Mounts = []; 
+        _.forEach(mounts, (Source, Target) => {
+            Mounts.push({
+                Target,
+                Source,
+                Type: "bind",
+                ReadOnly: false,
+                Consistency: "consistent",
+            });
+        });
+        
+        return Mounts;
+    }
+    
+    toDockerHealth(health) {
+        return {
+            Test: ["CMD-SHELL", health.cmd],
+            Interval: health.interval
+                ? health.interval * NANO_SECOND
+                : 5000 * NANO_SECOND,
+            Timeout: health.timeout
+                ? health.timeout * NANO_SECOND
+                : 15000 * NANO_SECOND,
+            Retries: health.retries || 10,
+        };
+    }
 
     /**
      *
@@ -103,7 +155,7 @@ class ContainerManager {
      * @return {Promise<ContainerInfo>}
      */
     async run(image, name, opts) {
-        const Mounts = [];
+        
         const PortBindings = {};
         const Env = [];
         const Labels = {
@@ -127,15 +179,7 @@ class ContainerManager {
             Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
         });
 
-        _.forEach(opts.mounts, (Source, Target) => {
-            Mounts.push({
-                Target,
-                Source,
-                Type: "bind",
-                ReadOnly: false,
-                Consistency: "consistent",
-            });
-        });
+        const Mounts = this.toDockerMounts(opts.mounts);
 
         _.forEach(opts.env, (value, name) => {
             Env.push(name + "=" + value);
@@ -144,16 +188,7 @@ class ContainerManager {
         let HealthCheck = undefined;
 
         if (opts.health) {
-            HealthCheck = {
-                Test: ["CMD-SHELL", opts.health.cmd],
-                Interval: opts.health.interval
-                    ? opts.health.interval * NANO_SECOND
-                    : 5000 * NANO_SECOND,
-                Timeout: opts.health.timeout
-                    ? opts.health.timeout * NANO_SECOND
-                    : 15000 * NANO_SECOND,
-                Retries: opts.health.retries || 10,
-            };
+            HealthCheck = this.toDockerHealth(opts.health);
 
             console.log("Adding health check", HealthCheck);
         }
@@ -172,7 +207,7 @@ class ContainerManager {
         });
 
         if (opts.health) {
-            await this._waitForHealthy(dockerContainer);
+            await this.waitForHealthy(dockerContainer);
         }
 
         return new ContainerInfo(dockerContainer);
@@ -187,31 +222,33 @@ class ContainerManager {
     }
 
 
-    async _waitForHealthy(container, attempt) {
+    async waitForHealthy(container, attempt) {
         if (!attempt) {
             attempt = 0;
         }
 
         if (attempt >= HEALTH_CHECK_MAX) {
-            throw new Error("Operator did not become healthy within the timeout");
+            throw new Error("Container did not become healthy within the timeout");
         }
 
         if (await this._isHealthy(container)) {
-            console.log("Container became healthy");
             return;
         }
 
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             setTimeout(async () => {
-                await this._waitForHealthy(container, attempt + 1);
-                resolve();
+                try {
+                    await this.waitForHealthy(container, attempt + 1);
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
             }, HEALTH_CHECK_INTERVAL);
         });
     }
 
     async _isHealthy(container) {
         const info = await container.status();
-
         return info?.data?.State?.Health?.Status === "healthy";
     }
 

package/src/instanceManager.js

@@ -193,6 +193,7 @@ class InstanceManager {
         if (instance) {
             instance.status = STATUS_STARTING;
             instance.pid = info.pid;
+            instance.address = address;
             if (info.type) {
                 instance.type = info.type;
             }
@@ -207,7 +208,8 @@ class InstanceManager {
                 status: STATUS_STARTING,
                 pid: info.pid,
                 type: info.type,
-                health: healthUrl
+                health: healthUrl,
+                address
             };
 
             this._instances.push(instance);
@@ -385,7 +387,8 @@ class InstanceManager {
             await this.registerInstance(planRef, instanceId, {
                 type: process.type,
                 pid: process.pid,
-                health: null
+                health: null,
+                portType: process.portType,
             });
 
             return this._processes[planRef][instanceId] = process;
@@ -402,7 +405,8 @@ class InstanceManager {
             await this.registerInstance(planRef, instanceId, {
                 type: 'local',
                 pid: null,
-                health: null
+                health: null,
+                portType: DEFAULT_HEALTH_PORT_TYPE,
             });
 
             this._emit(instanceId, EVENT_INSTANCE_LOG, logs[0]);

package/src/operatorManager.js

@@ -144,13 +144,7 @@ class OperatorManager {
             };
         }
 
-        const mounts = {};
-
-        _.forEach(operatorData.mounts, (containerPath, mountName) => {
-            const hostPath = this._getMountPoint(resourceType, mountName);
-            mkdirp.sync(hostPath);
-            mounts[containerPath] = hostPath;
-        });
+        const mounts = containerManager.createMounts(resourceType, operatorData.mounts);
 
         const containerName = containerBaseName + '-' + md5(nameParts.join('_'));
         let container = await containerManager.get(containerName);

package/src/utils/BlockInstanceRunner.js

@@ -9,6 +9,7 @@ const serviceManager = require("../serviceManager");
 const containerManager = require("../containerManager");
 const LogData = require("./LogData");
 const EventEmitter = require("events");
+const md5 = require('md5');
 const {execSync} = require("child_process");
 
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
@@ -25,10 +26,6 @@ const DOCKER_ENV_VARS = [
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ]
 
-function md5(data) {
-    return require('crypto').createHash('md5').update(data).digest("hex");
-}
-
 
 class BlockInstanceRunner {
     /**
@@ -117,11 +114,19 @@ class BlockInstanceRunner {
         if (provider.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
             processDetails = await this._startOperatorProcess(blockInstance, blockUri, provider, env);
         } else {
+            //We need a port type to know how to connect to the block consistently
+            const portTypes = definition.definition?.spec?.providers.map(provider => {
+                return provider.spec?.port?.type
+            }).filter(t => !!t) ?? [];
             if (blockUri.version === 'local') {
                 processDetails = await this._startLocalProcess(blockInstance, blockUri, env);
             } else {
                 processDetails = await this._startDockerProcess(blockInstance, blockUri, env);
             }
+
+            if (portTypes.length > 0) {
+                processDetails.portType = portTypes[0];
+            }
         }
 
         return {
@@ -386,6 +391,8 @@ class BlockInstanceRunner {
             const ExposedPorts = {};
             const addonEnv = {};
             const PortBindings = {};
+            let HealthCheck = undefined;
+            let Mounts = [];
             const promises = Object.entries(spec.local.ports)
                 .map(async ([portType, value]) => {
                     const dockerPort = `${value.port}/${value.type}`;
@@ -402,17 +409,34 @@ class BlockInstanceRunner {
 
             await Promise.all(promises);
 
+            if (spec.local?.env) {
+                Object.entries(spec.local.env).forEach(([key, value]) => {
+                    addonEnv[key] = value;
+                });
+            }
+
+            if (spec.local?.mounts) {
+                const mounts = containerManager.createMounts(blockUri.id, spec.local.mounts);
+                Mounts = containerManager.toDockerMounts(mounts);
+            }
+
+            if (spec.local?.health) {
+                HealthCheck = containerManager.toDockerHealth(spec.local?.health);
+            }
+
             logs.addLog(`Creating new container for block: ${containerName}`);
             container = await containerManager.startContainer({
                 Image: dockerImage,
                 name: containerName,
                 ExposedPorts,
+                HealthCheck,
                 HostConfig: {
                     Binds: [
                         `${kapetaYmlPath}:/kapeta.yml:ro`,
                         `${ClusterConfig.getKapetaBasedir()}:${ClusterConfig.getKapetaBasedir()}`
                     ],
-                    PortBindings
+                    PortBindings,
+                    Mounts
                 },
                 Labels: {
                     'instance': blockInstance.id
@@ -426,9 +450,19 @@ class BlockInstanceRunner {
                     }).map(([key, value]) => `${key}=${value}`)
                 ]
             });
+
+            if (HealthCheck) {
+                await containerManager.waitForHealthy(container);
+            }
+        }
+
+        const out = await this._handleContainer(container, logs, true);
+        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
+        if (portTypes.length > 0) {
+            out.portType = portTypes[0];
         }
 
-        return this._handleContainer(container, logs, true);
+        return out;
     }
 }