@kapeta/local-cluster-service 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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)
 
 

package/package.json

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

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

@@ -227,12 +227,37 @@ 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) {
             attempt = 0;
@@ -260,6 +285,13 @@ 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';
@@ -278,7 +310,6 @@ class ContainerManager {
             await dockerContainer.status();
         } catch (err) {
             //Ignore
-            console.log('Container not available - creating it: %s', name);
             dockerContainer = null;
         }
 

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);
             }
         }