@kapeta/local-cluster-service 0.2.1 → 0.4.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.4.0](https://github.com/kapetacom/local-cluster-service/compare/v0.3.0...v0.4.0) (2023-06-01)
+
+
+### Features
+
+* Change to always run local code in docker container ([#25](https://github.com/kapetacom/local-cluster-service/issues/25)) ([6e4021e](https://github.com/kapetacom/local-cluster-service/commit/6e4021e67968467555f1043f2972fc7a877aa3b7))
+
+# [0.3.0](https://github.com/kapetacom/local-cluster-service/compare/v0.2.1...v0.3.0) (2023-05-08)
+
+
+### Features
+
+* load docker config from clusterConfig if available [KAP-609] ([1ced2c1](https://github.com/kapetacom/local-cluster-service/commit/1ced2c1ed2f72bf3331e558ee2c685385c89ab1f))
+
 ## [0.2.1](https://github.com/kapetacom/local-cluster-service/compare/v0.2.0...v0.2.1) (2023-05-07)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
   "main": "index.js",
   "repository": {
@@ -22,7 +22,7 @@
   "homepage": "https://github.com/kapetacom/local-cluster-service#readme",
   "dependencies": {
     "@kapeta/codegen": "<2",
-    "@kapeta/local-cluster-config": "<2",
+    "@kapeta/local-cluster-config": ">= 0.1.0 <2",
     "@kapeta/nodejs-api-client": "<2",
     "@kapeta/nodejs-registry-utils": "<2",
     "@kapeta/nodejs-utils": "<2",
@@ -44,6 +44,10 @@
   "devDependencies": {
     "nodemon": "^2.0.2"
   },
+  "prettier": {
+    "tabWidth": 4,
+    "singleQuote": true
+  },
   "release": {
     "plugins": [
       "@semantic-release/commit-analyzer",

package/src/config/routes.js

@@ -99,9 +99,7 @@ router.get('/identity', async (req, res) => {
 
         res.send(identity);
     } catch(err) {
-        console.log(err);
-        
-        res.send({error: err.message});
+        res.status(400).send({error: err.message});
     }
 });
 

package/src/configManager.js

@@ -92,7 +92,7 @@ class ConfigManager {
                 throw new Error(`No uses of block "${blockRef}" was found in plan: "${systemId}"`)
             }
 
-            throw new Error(`No uses of block "${blockRef}" was found any known plan`);
+            throw new Error(`No uses of block "${blockRef}" was found in any known plan`);
         }
 
         if (matchingIdentities.length > 1) {

package/src/containerManager.js

@@ -1,13 +1,15 @@
-const {Docker} = require("node-docker-api");
-const path = require("path");
+const { Docker } = require('node-docker-api');
+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 os = require('os');
+const Path = require('path');
+const storageService = require('./storageService');
+const mkdirp = require('mkdirp');
+const { parseKapetaUri } = require('@kapeta/nodejs-utils');
+
+const ClusterConfiguration = require('@kapeta/local-cluster-config');
+
+const LABEL_PORT_PREFIX = 'kapeta_port-';
 
 const NANO_SECOND = 1000000;
 const HEALTH_CHECK_INTERVAL = 2000;
@@ -15,9 +17,9 @@ const HEALTH_CHECK_MAX = 20;
 
 const promisifyStream = (stream) =>
     new Promise((resolve, reject) => {
-        stream.on("data", (d) => console.log(d.toString()));
-        stream.on("end", resolve);
-        stream.on("error", reject);
+        stream.on('data', (d) => console.log(d.toString()));
+        stream.on('end', resolve);
+        stream.on('error', reject);
     });
 
 class ContainerManager {
@@ -27,8 +29,41 @@ class ContainerManager {
         this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
         mkdirp.sync(this._mountDir);
     }
-    
-    
+
+    async initialize() {
+        // Use the value from cluster-service.yml if configured
+        const dockerConfig = ClusterConfiguration.getDockerConfig();
+        const connectOptions =
+            Object.keys(dockerConfig).length > 0
+                ? [dockerConfig]
+                : [
+                      // use defaults: DOCKER_HOST etc from env, if available
+                      undefined,
+                      // default linux
+                      { socketPath: '/var/run/docker.sock' },
+                      // default macOS
+                      {
+                          socketPath: path.join(
+                              os.homedir(),
+                              '.docker/run/docker.sock'
+                          ),
+                      },
+                      // Default http
+                      { protocol: 'http', host: 'localhost', port: 2375 },
+                      { protocol: 'https', host: 'localhost', port: 2376 },
+                  ];
+        for (const opts of connectOptions) {
+            try {
+                const client = new Docker(opts);
+                await client.ping();
+                this._docker = client;
+                this._alive = true;
+                return;
+            } catch (err) {
+                // silently ignore bad configs
+            }
+        }
+    }
 
     isAlive() {
         return this._alive;
@@ -36,9 +71,14 @@ class ContainerManager {
 
     getMountPoint(kind, mountName) {
         const kindUri = parseKapetaUri(kind);
-        return Path.join(this._mountDir, kindUri.handle, kindUri.name, mountName);
+        return Path.join(
+            this._mountDir,
+            kindUri.handle,
+            kindUri.name,
+            mountName
+        );
     }
-    
+
     createMounts(kind, mountOpts) {
         const mounts = {};
 
@@ -50,42 +90,16 @@ class ContainerManager {
         return mounts;
     }
 
-    async initialize() {
-        // try
-        const connectOptions = [
-            // use defaults: DOCKER_HOST etc from env, if available
-            undefined,
-            // default linux
-            {socketPath: "/var/run/docker.sock"},
-            // default macOS
-            {socketPath: path.join(os.homedir(), ".docker/run/docker.sock")},
-            // Default http
-            {protocol: "http", host: "localhost", port: 2375},
-            {protocol: "https", host: "localhost", port: 2376},
-        ];
-        for (const opts of connectOptions) {
-            try {
-                const client = new Docker(opts);
-                await client.ping();
-                this._docker = client;
-                this._alive = true;
-                return;
-            } catch (err) {
-                // silently ignore bad configs
-            }
-        }
-        throw new Error("Unable to connect to docker");
-    }
-
     async ping() {
-
         try {
             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}`);
+            throw new Error(
+                `Docker not running. Please start the docker daemon before running this command. Error: ${e.message}`
+            );
         }
     }
     docker() {
@@ -96,8 +110,8 @@ class ContainerManager {
     }
 
     async getContainerByName(containerName) {
-        const containers = await this.docker().container.list({all: true});
-        return containers.find(container => {
+        const containers = await this.docker().container.list({ all: true });
+        return containers.find((container) => {
             return container.data.Names.indexOf(`/${containerName}`) > -1;
         });
     }
@@ -108,8 +122,8 @@ class ContainerManager {
             tag = 'latest';
         }
 
-        await this.docker().image
-            .create(
+        await this.docker()
+            .image.create(
                 {},
                 {
                     fromImage: imageName,
@@ -118,25 +132,25 @@ class ContainerManager {
             )
             .then((stream) => promisifyStream(stream));
     }
-    
+
     toDockerMounts(mounts) {
-        const Mounts = []; 
+        const Mounts = [];
         _.forEach(mounts, (Source, Target) => {
             Mounts.push({
                 Target,
                 Source,
-                Type: "bind",
+                Type: 'bind',
                 ReadOnly: false,
-                Consistency: "consistent",
+                Consistency: 'consistent',
             });
         });
-        
+
         return Mounts;
     }
-    
+
     toDockerHealth(health) {
         return {
-            Test: ["CMD-SHELL", health.cmd],
+            Test: ['CMD-SHELL', health.cmd],
             Interval: health.interval
                 ? health.interval * NANO_SECOND
                 : 5000 * NANO_SECOND,
@@ -155,25 +169,24 @@ class ContainerManager {
      * @return {Promise<ContainerInfo>}
      */
     async run(image, name, opts) {
-        
         const PortBindings = {};
         const Env = [];
         const Labels = {
-            kapeta: "true",
+            kapeta: 'true',
         };
 
-        console.log("Pulling image: %s", image);
+        console.log('Pulling image: %s', image);
 
         await this.pull(image);
 
-        console.log("Image pulled: %s", image);
+        console.log('Image pulled: %s', image);
 
         _.forEach(opts.ports, (portInfo, containerPort) => {
             PortBindings['' + containerPort] = [
                 {
                     HostPort: '' + portInfo.hostPort,
-                    HostIp: '127.0.0.1'
-                }
+                    HostIp: '127.0.0.1',
+                },
             ];
 
             Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
@@ -182,7 +195,7 @@ class ContainerManager {
         const Mounts = this.toDockerMounts(opts.mounts);
 
         _.forEach(opts.env, (value, name) => {
-            Env.push(name + "=" + value);
+            Env.push(name + '=' + value);
         });
 
         let HealthCheck = undefined;
@@ -190,10 +203,9 @@ class ContainerManager {
         if (opts.health) {
             HealthCheck = this.toDockerHealth(opts.health);
 
-            console.log("Adding health check", HealthCheck);
+            console.log('Adding health check', HealthCheck);
         }
 
-
         const dockerContainer = await this.startContainer({
             name: name,
             Image: image,
@@ -202,8 +214,8 @@ class ContainerManager {
             HealthCheck,
             HostConfig: {
                 PortBindings,
-                Mounts
-            }
+                Mounts,
+            },
         });
 
         if (opts.health) {
@@ -215,12 +227,36 @@ class ContainerManager {
 
     async startContainer(opts) {
         const dockerContainer = await this.docker().container.create(opts);
-
         await dockerContainer.start();
-
         return dockerContainer;
     }
 
+    async waitForReady(container, attempt) {
+        if (!attempt) {
+            attempt = 0;
+        }
+
+        if (attempt >= HEALTH_CHECK_MAX) {
+            throw new Error(
+                'Container did not become ready within the timeout'
+            );
+        }
+
+        if (await this._isReady(container)) {
+            return;
+        }
+
+        return new Promise((resolve, reject) => {
+            setTimeout(async () => {
+                try {
+                    await this.waitForReady(container, attempt + 1);
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            }, HEALTH_CHECK_INTERVAL);
+        });
+    }
 
     async waitForHealthy(container, attempt) {
         if (!attempt) {
@@ -228,7 +264,9 @@ class ContainerManager {
         }
 
         if (attempt >= HEALTH_CHECK_MAX) {
-            throw new Error("Container did not become healthy within the timeout");
+            throw new Error(
+                'Container did not become healthy within the timeout'
+            );
         }
 
         if (await this._isHealthy(container)) {
@@ -247,9 +285,16 @@ class ContainerManager {
         });
     }
 
+    async _isReady(container) {
+        const info = await container.status();
+        if (info?.data?.State?.Status === 'exited') {
+            throw new Error('Container exited unexpectedly');
+        }
+        return info?.data?.State?.Running;
+    }
     async _isHealthy(container) {
         const info = await container.status();
-        return info?.data?.State?.Health?.Status === "healthy";
+        return info?.data?.State?.Health?.Status === 'healthy';
     }
 
     /**
@@ -265,7 +310,6 @@ class ContainerManager {
             await dockerContainer.status();
         } catch (err) {
             //Ignore
-            console.log("Container not available - creating it: %s", name);
             dockerContainer = null;
         }
 
@@ -314,7 +358,7 @@ class ContainerInfo {
     }
 
     async remove(opts) {
-        await this._container.delete({force: !!opts.force});
+        await this._container.delete({ force: !!opts.force });
     }
 
     async getPort(type) {

package/src/instanceManager.js

@@ -393,6 +393,7 @@ class InstanceManager {
 
             return this._processes[planRef][instanceId] = process;
         } catch (e) {
+            console.warn('Failed to start instance', e);
             const logs = [
                 {
                     source: "stdout",

package/src/utils/BlockInstanceRunner.js

@@ -27,6 +27,19 @@ const DOCKER_ENV_VARS = [
 ]
 
 
+function getProvider(uri) {
+    return ClusterConfig.getProviderDefinitions().find(provider => {
+        const ref = `${provider.definition.metadata.name}:${provider.version}`
+        return parseKapetaUri(ref).id === uri.id;
+    });
+}
+
+function getProviderPorts(assetVersion) {
+    return assetVersion.definition?.spec?.providers.map(provider => {
+        return provider.spec?.port?.type
+    }).filter(t => !!t) ?? [];
+}
+
 class BlockInstanceRunner {
     /**
      * @param {string} [planReference]
@@ -66,7 +79,7 @@ class BlockInstanceRunner {
      * @private
      */
     async _execute(blockInstance) {
-        const env = Object.assign({}, process.env);
+        const env = {};
 
         if (this._systemId) {
             env[KAPETA_SYSTEM_ID] = this._systemId;
@@ -86,23 +99,20 @@ class BlockInstanceRunner {
             blockUri.version = 'local';
         }
 
-        const definition = ClusterConfig.getDefinitions().find(definitions => {
+        const assetVersion = ClusterConfig.getDefinitions().find(definitions => {
             const ref = `${definitions.definition.metadata.name}:${definitions.version}`
             return parseKapetaUri(ref).id === blockUri.id;
         });
 
-        if (!definition) {
+        if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
         }
 
-        const kindUri = parseKapetaUri(definition.definition.kind);
+        const kindUri = parseKapetaUri(assetVersion.definition.kind);
 
-        const provider = ClusterConfig.getProviderDefinitions().find(provider => {
-            const ref = `${provider.definition.metadata.name}:${provider.version}`
-            return parseKapetaUri(ref).id === kindUri.id;
-        });
+        const providerVersion = getProvider(kindUri);
 
-        if (!provider) {
+        if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
 
@@ -111,15 +121,14 @@ class BlockInstanceRunner {
          */
         let processDetails;
 
-        if (provider.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
-            processDetails = await this._startOperatorProcess(blockInstance, blockUri, provider, env);
+        if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
+            processDetails = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, 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) ?? [];
+            const portTypes = getProviderPorts(assetVersion);
+
             if (blockUri.version === 'local') {
-                processDetails = await this._startLocalProcess(blockInstance, blockUri, env);
+                processDetails = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             } else {
                 processDetails = await this._startDockerProcess(blockInstance, blockUri, env);
             }
@@ -141,10 +150,11 @@ class BlockInstanceRunner {
      * @param {BlockInstanceInfo} blockInstance
      * @param {BlockInfo} blockInfo
      * @param {EnvironmentVariables} env
+     * @param assetVersion
      * @return {ProcessDetails}
      * @private
      */
-    _startLocalProcess(blockInstance, blockInfo, env) {
+    async _startLocalProcess(blockInstance, blockInfo, env, assetVersion) {
         const baseDir = ClusterConfig.getRepositoryAssetPath(
             blockInfo.handle,
             blockInfo.name,
@@ -158,61 +168,125 @@ class BlockInstanceRunner {
             );
         }
 
-        const startScript = Path.resolve(baseDir, 'scripts/start.sh');
-        if (!FS.existsSync(startScript)) {
-            throw new Error(
-                `Start script did not exist for local block.\n` +
-                `Expected runnable start script here: ${startScript}`
-            )
+        const kindUri = parseKapetaUri(assetVersion.definition.spec.target.kind);
+
+        const targetVersion = getProvider(kindUri);
+
+        if (!targetVersion) {
+            throw new Error(`Target not found: ${kindUri.id}`);
         }
 
+        const localContainer = targetVersion.definition.spec.local;
+
+        if (!localContainer) {
+            throw new Error(`Missing local container information from target: ${kindUri.id}`);
+        }
+
+        const dockerImage = localContainer.image;
+        if (!dockerImage) {
+            throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
+        }
+
+        const containerName = `kapeta-block-instance-${blockInstance.id}`;
         const logs = new LogData();
-        const childProcess = spawn(startScript, [], {
-            cwd: baseDir,
-            env,
-            detached: true,
-            stdio: [
-                'pipe', 'pipe', 'pipe'
-            ]
-        });
+        logs.addLog(`Starting block ${blockInstance.ref}`);
+        let container = await containerManager.getContainerByName(containerName);
+        console.log('Starting dev container', containerName);
 
-        logs.addLog(`Starting block ${blockInstance.ref} using script ${startScript}`);
-        const outputEvents = new EventEmitter();
-        /**
-         *
-         * @type {ProcessDetails}
-         */
-        const out = {
-            type: 'local',
-            pid: childProcess.pid,
-            output: outputEvents,
-            stderr: childProcess.stderr,
-            logs: () => {
-                return logs.getLogs();
-            },
-            stop: () => {
-                childProcess.kill('SIGTERM');
+        if (container) {
+            console.log(`Container already exists. Deleting...`);
+            try {
+                await container.delete({
+                    force: true
+                })
+            } catch (e) {
+                throw new Error('Failed to delete existing container: ' + e.message);
             }
-        };
+            container = null;
+        }
 
-        childProcess.stdout.on('data', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
+        logs.addLog(`Creating new container for block: ${containerName}`);
+        console.log('Creating new dev container', containerName, dockerImage);
+        await containerManager.pull(dockerImage);
+
+        const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
+        const dockerOpts = localContainer.options ?? {};
+        const homeDir = localContainer.homeDir ? localContainer.homeDir : '/root';
+        const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
+
+        const ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+
+        const portTypes = getProviderPorts(assetVersion);
+        let port = 80;
+        const promises = portTypes
+            .map(async (portType) => {
+                const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+                const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
+                const dockerPort = `${thisPort}/tcp`;
+                ExposedPorts[dockerPort] = {};
+                addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = thisPort;
+
+                PortBindings[dockerPort] = [
+                    {
+                        HostIp: "127.0.0.1", //No public
+                        HostPort: `${publicPort}`
+                    }
+                ];
+            });
 
-        childProcess.stderr.on('data', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
+        await Promise.all(promises);
 
-        childProcess.on('exit', (code) => {
-            logs.addLog(`Block ${blockInstance.ref} exited with code: ${code}`);
-            outputEvents.emit('exit', code);
+        let HealthCheck = undefined;
+        if (localContainer.healthcheck) {
+            HealthCheck = containerManager.toDockerHealth({cmd: localContainer.healthcheck});
+        }
+
+        container = await containerManager.startContainer({
+            Image: dockerImage,
+            name: containerName,
+            WorkingDir: workingDir,
+            Labels: {
+                'instance': blockInstance.id
+            },
+            HealthCheck,
+            ExposedPorts,
+            Cmd: startCmd ? startCmd.split(/\s+/g) : [],
+            Env: [
+                ...DOCKER_ENV_VARS,
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv
+                }).map(([key, value]) => `${key}=${value}`)
+            ],
+            HostConfig: {
+                Binds: [
+                    `${ClusterConfig.getKapetaBasedir()}:${homeDir}/.kapeta`,
+                    `${baseDir}:${workingDir}` //We mount
+                ],
+                PortBindings
+            },
+            ...dockerOpts
         });
 
-        return out;
+        if (HealthCheck) {
+            await containerManager.waitForHealthy(container);
+        } else {
+            await containerManager.waitForReady(container);
+        }
+
+        return this._handleContainer(container, logs);
     }
 
+    /**
+     *
+     * @param container
+     * @param logs
+     * @param deleteOnExit
+     * @return {Promise<ProcessDetails>}
+     * @private
+     */
     async _handleContainer(container, logs , deleteOnExit = false) {
         const logStream = await container.logs({
             follow: true,
@@ -315,22 +389,36 @@ class BlockInstanceRunner {
             container = await containerManager.startContainer({
                 Image: dockerImage,
                 name: containerName,
-                Binds: [
-                    `${ClusterConfig.getKapetaBasedir()}:${ClusterConfig.getKapetaBasedir()}`
-                ],
                 Labels: {
                     'instance': blockInstance.id
                 },
                 Env: [
                     ...DOCKER_ENV_VARS,
                     ...Object.entries(env).map(([key, value]) => `${key}=${value}`)
-                ]
+                ],
+                HostConfig: {
+                    Binds: [
+                        `${ClusterConfig.getKapetaBasedir()}:${ClusterConfig.getKapetaBasedir()}`
+                    ],
+
+                }
             });
+
+            await containerManager.waitForReady(container);
         }
 
         return this._handleContainer(container, logs);
     }
 
+    /**
+     *
+     * @param blockInstance
+     * @param blockUri
+     * @param providerDefinition
+     * @param {{[key:string]:string}} env
+     * @return {Promise<ProcessDetails>}
+     * @private
+     */
     async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
         const {assetFile} = ClusterConfig.getRepositoryAssetInfoPath(
             blockUri.handle,
@@ -453,6 +541,8 @@ class BlockInstanceRunner {
 
             if (HealthCheck) {
                 await containerManager.waitForHealthy(container);
+            } else {
+                await containerManager.waitForReady(container);
             }
         }