@kapeta/local-cluster-service 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.5.2](https://github.com/kapetacom/local-cluster-service/compare/v0.5.1...v0.5.2) (2023-06-06)
+
+
+### Bug Fixes
+
+* Use internal docker host when inside docker ([#28](https://github.com/kapetacom/local-cluster-service/issues/28)) ([3b0ae9d](https://github.com/kapetacom/local-cluster-service/commit/3b0ae9d7612ae54b38ec8e39f632932f8543206e))
+
+## [0.5.1](https://github.com/kapetacom/local-cluster-service/compare/v0.5.0...v0.5.1) (2023-06-06)
+
+
+### Bug Fixes
+
+* Improve starting and stopping local instances ([#27](https://github.com/kapetacom/local-cluster-service/issues/27)) ([83ff53a](https://github.com/kapetacom/local-cluster-service/commit/83ff53a31e98aa8984ff6a9a1e80ddb94653ce18))
+
 # [0.5.0](https://github.com/kapetacom/local-cluster-service/compare/v0.4.1...v0.5.0) (2023-06-02)
 
 

package/package.json

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

package/src/config/routes.js

@@ -86,6 +86,11 @@ router.get('/identity', async (req, res) => {
         instanceId: req.kapeta.instanceId
     };
 
+    if (!req.kapeta.blockRef) {
+        res.status(400).send({error: 'Missing required header "X-Kapeta-Block"'});
+        return;
+    }
+
     try {
 
         if (!identity.systemId ||
@@ -99,6 +104,7 @@ router.get('/identity', async (req, res) => {
 
         res.send(identity);
     } catch(err) {
+        console.warn('Failed to resolve identity', err);
         res.status(400).send({error: err.message});
     }
 });
@@ -128,7 +134,8 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res)
         req.kapeta.instanceId,
         req.params.resourceType,
         req.params.portType,
-        req.params.name
+        req.params.name,
+        req.kapeta.environment
     );
 
     res.send(operatorInfo);

package/src/configManager.js

@@ -109,17 +109,19 @@ class ConfigManager {
 
     async verifyIdentity(blockRef, systemId, instanceId) {
         const planAssets = await assetManager.getPlans();
-
+        const systemUri = systemId ? parseKapetaUri(systemId) : null;
+        const blockUri = parseKapetaUri(blockRef);
         let found = false;
         planAssets.forEach((planAsset) => {
-            if (planAsset.ref !== systemId) {
+            if (systemUri &&
+                !parseKapetaUri(planAsset.ref).equals(systemUri)) {
                 //Skip plans that do not match systemid if provided
                 return;
             }
 
             planAsset.data.spec.blocks.forEach((blockInstance) => {
                 if (blockInstance.id === instanceId &&
-                    blockInstance.block.ref === blockRef) {
+                    parseKapetaUri(blockInstance.block.ref).equals(blockUri)) {
                     found = true;
                 }
             });

package/src/containerManager.js

@@ -13,7 +13,10 @@ const LABEL_PORT_PREFIX = 'kapeta_port-';
 
 const NANO_SECOND = 1000000;
 const HEALTH_CHECK_INTERVAL = 2000;
-const HEALTH_CHECK_MAX = 20;
+const HEALTH_CHECK_MAX = 30;
+const IMAGE_PULL_CACHE_TTL = 30 * 60 * 1000;
+const IMAGE_PULL_CACHE = {};
+
 
 const promisifyStream = (stream) =>
     new Promise((resolve, reject) => {
@@ -63,6 +66,8 @@ class ContainerManager {
                 // silently ignore bad configs
             }
         }
+
+        throw new Error('Could not connect to docker daemon. Please make sure docker is running and working.');
     }
 
     isAlive() {
@@ -116,12 +121,21 @@ class ContainerManager {
         });
     }
 
-    async pull(image) {
+    async pull(image, cacheForMS = IMAGE_PULL_CACHE_TTL) {
         let [imageName, tag] = image.split(/:/);
         if (!tag) {
             tag = 'latest';
         }
 
+        if (tag !== 'latest') {
+            if (IMAGE_PULL_CACHE[image]) {
+                const timeSince = Date.now() - IMAGE_PULL_CACHE[image];
+                if (timeSince < cacheForMS) {
+                    return;
+                }
+            }
+        }
+
         await this.docker()
             .image.create(
                 {},
@@ -131,6 +145,8 @@ class ContainerManager {
                 }
             )
             .then((stream) => promisifyStream(stream));
+
+        IMAGE_PULL_CACHE[image] = Date.now();
     }
 
     toDockerMounts(mounts) {
@@ -202,8 +218,6 @@ class ContainerManager {
 
         if (opts.health) {
             HealthCheck = this.toDockerHealth(opts.health);
-
-            console.log('Adding health check', HealthCheck);
         }
 
         const dockerContainer = await this.startContainer({
@@ -335,6 +349,10 @@ class ContainerInfo {
         this._container = dockerContainer;
     }
 
+    get native() {
+        return this._container;
+    }
+
     async isRunning() {
         const inspectResult = await this.getStatus();
 

package/src/instanceManager.js

@@ -253,21 +253,23 @@ class InstanceManager {
             return [];
         }
 
-        let processes = [];
+        let promises = [];
         let errors = [];
         for(let blockInstance of Object.values(plan.spec.blocks)) {
             try {
-                processes.push(await this.createProcess(planRef, blockInstance.id));
+                promises.push(this.createProcess(planRef, blockInstance.id));
             } catch (e) {
                 errors.push(e);
             }
         }
 
+        const settled = await Promise.allSettled(promises);
+
         if (errors.length > 0) {
             throw errors[0];
         }
 
-        return processes;
+        return settled.map(p => p.value);
     }
 
     async _stopInstance(instance) {
@@ -283,7 +285,11 @@ class InstanceManager {
             if (instance.type === 'docker') {
                 const container = await containerManager.get(instance.pid);
                 if (container) {
-                    await container.stop();
+                    try {
+                        await container.stop();
+                    } catch (e) {
+                        console.error('Failed to stop container', e);
+                    }
                 }
                 return;
             }
@@ -294,11 +300,16 @@ class InstanceManager {
     }
 
     async stopAllForPlan(planRef) {
+
         if (this._processes[planRef]) {
+            const promises = [];
+            console.log('Stopping all processes for plan', planRef);
             for(let instance of Object.values(this._processes[planRef])) {
-                await instance.stop();
+                promises.push(instance.stop());
             }
 
+            await Promise.all(promises);
+
             this._processes[planRef] = {};
         }
 
@@ -306,9 +317,12 @@ class InstanceManager {
         const instancesForPlan = this._instances
             .filter(instance => instance.systemId === planRef);
 
+        const promises = [];
         for(let instance of instancesForPlan) {
-            await this._stopInstance(instance);
+            promises.push(this._stopInstance(instance));
         }
+
+        await Promise.all(promises);
     }
 
     /**

package/src/operatorManager.js

@@ -71,7 +71,7 @@ class OperatorManager {
      * @param {string} name
      * @returns {Promise<{host: string, port: (*|string), type: *, protocol: *, credentials: *}>}
      */
-    async getResourceInfo(systemId, fromServiceId, resourceType, portType, name) {
+    async getResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
 
         const operator = this.getOperator(resourceType);
 
@@ -88,7 +88,7 @@ class OperatorManager {
         const dbName = name + '_' + fromServiceId.replace(/[^a-z0-9]/gi, '');
 
         return {
-            host: 'localhost',
+            host: environment === 'docker' ? 'host.docker.internal' : 'localhost',
             port: portInfo.hostPort,
             type: portType,
             protocol: portInfo.protocol,
@@ -167,6 +167,16 @@ class OperatorManager {
                 });
         }
 
+        try {
+            if (operatorData.health) {
+                await containerManager.waitForHealthy(container.native);
+            } else {
+                await containerManager.waitForReady(container.native);
+            }
+        } catch (e) {
+            console.error(e.message);
+        }
+
         return container;
     }
 }

package/src/utils/BlockInstanceRunner.js

@@ -35,7 +35,7 @@ function getProvider(uri) {
 }
 
 function getProviderPorts(assetVersion) {
-    return assetVersion.definition?.spec?.providers.map(provider => {
+    return assetVersion.definition?.spec?.providers?.map(provider => {
         return provider.spec?.port?.type
     }).filter(t => !!t) ?? [];
 }
@@ -168,7 +168,11 @@ class BlockInstanceRunner {
             );
         }
 
-        const kindUri = parseKapetaUri(assetVersion.definition.spec.target.kind);
+        if (!assetVersion.definition.spec?.target?.kind) {
+            throw new Error('Missing target kind in block definition');
+        }
+
+        const kindUri = parseKapetaUri(assetVersion.definition.spec?.target?.kind);
 
         const targetVersion = getProvider(kindUri);
 
@@ -270,10 +274,14 @@ class BlockInstanceRunner {
             ...dockerOpts
         });
 
-        if (HealthCheck) {
-            await containerManager.waitForHealthy(container);
-        } else {
-            await containerManager.waitForReady(container);
+        try {
+            if (HealthCheck) {
+                await containerManager.waitForHealthy(container);
+            } else {
+                await containerManager.waitForReady(container);
+            }
+        } catch (e) {
+            logs.addLog(e.message, 'ERROR');
         }
 
         return this._handleContainer(container, logs);
@@ -404,7 +412,11 @@ class BlockInstanceRunner {
                 }
             });
 
-            await containerManager.waitForReady(container);
+            try {
+                await containerManager.waitForReady(container);
+            } catch (e) {
+                logs.addLog(e.message, 'ERROR');
+            }
         }
 
         return this._handleContainer(container, logs);
@@ -539,10 +551,14 @@ class BlockInstanceRunner {
                 ]
             });
 
-            if (HealthCheck) {
-                await containerManager.waitForHealthy(container);
-            } else {
-                await containerManager.waitForReady(container);
+            try {
+                if (HealthCheck) {
+                    await containerManager.waitForHealthy(container);
+                } else {
+                    await containerManager.waitForReady(container);
+                }
+            } catch (e) {
+                logs.addLog(e.message, 'ERROR');
             }
         }