@kapeta/local-cluster-service 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [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)
+
+
+### Bug Fixes
+
+* Moved all docker init things into init - and rely on that ([9a012c3](https://github.com/kapetacom/local-cluster-service/commit/9a012c3a40a6b4e4ef55757a4b8454d48bd3987c))
+
 ## [0.1.1](https://github.com/kapetacom/local-cluster-service/compare/v0.1.0...v0.1.1) (2023-05-06)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "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 = [
@@ -44,6 +68,7 @@ class ContainerManager {
                 const client = new Docker(opts);
                 await client.ping();
                 this._docker = client;
+                this._alive = true;
                 return;
             } catch (err) {
                 // silently ignore bad configs
@@ -52,38 +77,26 @@ class ContainerManager {
         throw new Error("Unable to connect to docker");
     }
 
-    async ping() {
-        await this._docker.ping();
-        this._alive = true;
-    }
-
     async ping() {
 
         try {
-            const pingResult = await this._docker.ping();
+            const pingResult = await this.docker().ping();
             if (pingResult !== 'OK') {
                 throw new Error(`Ping failed: ${pingResult}`);
             }
         } catch (e) {
             throw new Error(`Docker not running. Please start the docker daemon before running this command. Error: ${e.message}`);
         }
-
-        this._alive = true;
     }
-
-    async ensureAlive() {
-        if (!this._alive) {
-            await this.ping();
+    docker() {
+        if (!this._docker) {
+            throw new Error(`Docker not running`);
         }
-    }
-
-    async docker() {
-        await this.ensureAlive();
         return this._docker;
     }
 
     async getContainerByName(containerName) {
-        const containers = await this._docker.container.list({all: true});
+        const containers = await this.docker().container.list({all: true});
         return containers.find(container => {
             return container.data.Names.indexOf(`/${containerName}`) > -1;
         });
@@ -95,7 +108,7 @@ class ContainerManager {
             tag = 'latest';
         }
 
-        await this._docker.image
+        await this.docker().image
             .create(
                 {},
                 {
@@ -105,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,
+        };
+    }
 
     /**
      *
@@ -114,7 +155,7 @@ class ContainerManager {
      * @return {Promise<ContainerInfo>}
      */
     async run(image, name, opts) {
-        const Mounts = [];
+        
         const PortBindings = {};
         const Env = [];
         const Labels = {
@@ -138,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);
@@ -155,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);
         }
@@ -183,14 +207,14 @@ class ContainerManager {
         });
 
         if (opts.health) {
-            await this._waitForHealthy(dockerContainer);
+            await this.waitForHealthy(dockerContainer);
         }
 
         return new ContainerInfo(dockerContainer);
     }
 
     async startContainer(opts) {
-        const dockerContainer = await this._docker.container.create(opts);
+        const dockerContainer = await this.docker().container.create(opts);
 
         await dockerContainer.start();
 
@@ -198,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";
     }
 
@@ -235,7 +261,7 @@ class ContainerManager {
         let dockerContainer = null;
 
         try {
-            dockerContainer = await this._docker.container.get(name);
+            dockerContainer = await this.docker().container.get(name);
             await dockerContainer.status();
         } catch (err) {
             //Ignore

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 {
     /**
@@ -386,6 +383,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 +401,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,6 +442,10 @@ class BlockInstanceRunner {
                     }).map(([key, value]) => `${key}=${value}`)
                 ]
             });
+
+            if (HealthCheck) {
+                await containerManager.waitForHealthy(container);
+            }
         }
 
         return this._handleContainer(container, logs, true);