@kapeta/local-cluster-service 0.5.8 → 0.5.10

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.5.10](https://github.com/kapetacom/local-cluster-service/compare/v0.5.9...v0.5.10) (2023-06-19)
+
+
+### Bug Fixes
+
+* delete asset via ref ([6b5a968](https://github.com/kapetacom/local-cluster-service/commit/6b5a968a029753baea3a651a0538468086cda665))
+
+## [0.5.9](https://github.com/kapetacom/local-cluster-service/compare/v0.5.8...v0.5.9) (2023-06-18)
+
+
+### Bug Fixes
+
+* Resolves various issues when proxiying HTTP requests ([#34](https://github.com/kapetacom/local-cluster-service/issues/34)) ([cb9a472](https://github.com/kapetacom/local-cluster-service/commit/cb9a472e560412a85cea20a1dc9083826797ac95))
+
 ## [0.5.8](https://github.com/kapetacom/local-cluster-service/compare/v0.5.7...v0.5.8) (2023-06-18)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
   "main": "index.js",
   "repository": {
@@ -34,6 +34,7 @@
     "lodash": "^4.17.15",
     "md5": "2.2.1",
     "mkdirp": "0.5.1",
+    "node-cache": "^5.1.2",
     "node-docker-api": "1.1.22",
     "node-uuid": "^1.4.8",
     "request": "2.88.2",

package/src/assetManager.js

@@ -1,13 +1,14 @@
-const Path = require("node:path");
+const Path = require('node:path');
 const FS = require('node:fs');
 const FSExtra = require('fs-extra');
 const YAML = require('yaml');
 const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
-const {Actions} = require('@kapeta/nodejs-registry-utils');
+const { Actions } = require('@kapeta/nodejs-registry-utils');
 const codeGeneratorManager = require('./codeGeneratorManager');
 const progressListener = require('./progressListener');
-const {parseKapetaUri} = require("@kapeta/nodejs-utils");
-const repositoryManager = require("./repositoryManager");
+const { parseKapetaUri } = require('@kapeta/nodejs-utils');
+const repositoryManager = require('./repositoryManager');
+const NodeCache = require('node-cache');
 
 function enrichAsset(asset) {
     return {
@@ -18,8 +19,8 @@ function enrichAsset(asset) {
         kind: asset.definition.kind,
         data: asset.definition,
         path: asset.path,
-        ymlPath: asset.ymlPath
-    }
+        ymlPath: asset.ymlPath,
+    };
 }
 
 function compareRefs(a, b) {
@@ -29,23 +30,20 @@ function compareRefs(a, b) {
     return aProtocol === bProtocol && aId === bId;
 }
 function parseRef(ref) {
-    let out = ref.split(/:\/\//,2);
+    let out = ref.split(/:\/\//, 2);
 
     if (out.length === 1) {
-        return [
-            'kapeta',
-            ref.toLowerCase()
-        ]
+        return ['kapeta', ref.toLowerCase()];
     }
-    return [
-        out[0].toLowerCase(),
-        out[1].toLowerCase()
-    ];
+    return [out[0].toLowerCase(), out[1].toLowerCase()];
 }
 
 class AssetManager {
-
-
+    constructor() {
+        this.cache = new NodeCache({
+            stdTTL: 60 * 60, // 1 hour
+        });
+    }
 
     /**
      *
@@ -56,10 +54,10 @@ class AssetManager {
         if (!assetKinds) {
             const blockTypeProviders = ClusterConfiguration.getDefinitions([
                 'core/block-type',
-                'core/block-type-operator'
+                'core/block-type-operator',
             ]);
-            assetKinds = blockTypeProviders.map(p => {
-                return `${p.definition.metadata.name}:${p.version}`
+            assetKinds = blockTypeProviders.map((p) => {
+                return `${p.definition.metadata.name}:${p.version}`;
             });
             assetKinds.push('core/plan');
         }
@@ -73,8 +71,8 @@ class AssetManager {
         return this.getAssets(['core/plan']);
     }
 
-    async getPlan(ref) {
-        const asset = await this.getAsset(ref);
+    async getPlan(ref, noCache = false) {
+        const asset = await this.getAsset(ref, noCache);
 
         if ('core/plan' !== asset.kind) {
             throw new Error('Asset was not a plan: ' + ref);
@@ -83,18 +81,22 @@ class AssetManager {
         return asset.data;
     }
 
-    async getAsset(ref) {
+    async getAsset(ref, noCache = false) {
+        const cacheKey = `getAsset:${ref}`;
+        if (noCache !== true && this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
         const uri = parseKapetaUri(ref);
         await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version);
 
         let asset = ClusterConfiguration.getDefinitions()
             .map(enrichAsset)
-            .find(a => parseKapetaUri(a.ref).equals(uri));
+            .find((a) => parseKapetaUri(a.ref).equals(uri));
 
         if (!asset) {
             throw new Error('Asset not found: ' + ref);
         }
-
+        this.cache.set(cacheKey, asset);
         return asset;
     }
 
@@ -115,12 +117,12 @@ class AssetManager {
         if (codeGeneratorManager.canGenerateCode(yaml)) {
             await codeGeneratorManager.generate(path, yaml);
         }
-
+        this.cache.flushAll();
         return asset;
     }
 
     async updateAsset(ref, yaml) {
-        const asset = await this.getAsset(ref);
+        const asset = await this.getAsset(ref, true);
         if (!asset) {
             throw new Error('Attempted to update unknown asset: ' + ref);
         }
@@ -134,11 +136,14 @@ class AssetManager {
         }
 
         FS.writeFileSync(asset.ymlPath, YAML.stringify(yaml));
-
+        this.cache.flushAll();
         if (codeGeneratorManager.canGenerateCode(yaml)) {
             await codeGeneratorManager.generate(asset.ymlPath, yaml);
         } else {
-            console.log('Could not generate code for %s', yaml.kind ? yaml.kind : 'unknown yaml');
+            console.log(
+                'Could not generate code for %s',
+                yaml.kind ? yaml.kind : 'unknown yaml'
+            );
         }
     }
 
@@ -151,24 +156,29 @@ class AssetManager {
             throw new Error('File not found: ' + filePath);
         }
 
-        const assetInfos = YAML.parseAllDocuments(FS.readFileSync(filePath).toString())
-            .map(doc => doc.toJSON());
+        const assetInfos = YAML.parseAllDocuments(
+            FS.readFileSync(filePath).toString()
+        ).map((doc) => doc.toJSON());
 
         await Actions.link(progressListener, Path.dirname(filePath));
 
         const version = 'local';
-        const refs = assetInfos.map(assetInfo => `kapeta://${assetInfo.metadata.name}:${version}`);
-
-        return this.getAssets().filter(a => refs.some(ref => compareRefs(ref, a.ref)));
+        const refs = assetInfos.map(
+            (assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`
+        );
+        this.cache.flushAll();
+        return this.getAssets().filter((a) =>
+            refs.some((ref) => compareRefs(ref, a.ref))
+        );
     }
 
     async unregisterAsset(ref) {
-        const asset = await this.getAsset(ref);
+        const asset = await this.getAsset(ref, true);
         if (!asset) {
             throw new Error('Asset does not exists: ' + ref);
         }
-
-        await Actions.uninstall(progressListener, asset.path);
+        this.cache.flushAll();
+        await Actions.uninstall(progressListener, [asset.ref]);
     }
 }
 

package/src/assets/routes.js

@@ -41,7 +41,7 @@ router.get('/read', async (req, res) => {
     }
 
     try {
-        res.send(await assetManager.getAsset(req.query.ref));
+        res.send(await assetManager.getAsset(req.query.ref, true));
     } catch(err) {
         res.status(400).send({error: err.message});
     }

package/src/instanceManager.js

@@ -243,7 +243,7 @@ class InstanceManager {
     async createProcessesForPlan(planRef) {
         await this.stopAllForPlan(planRef);
 
-        const plan = await assetManager.getPlan(planRef);
+        const plan = await assetManager.getPlan(planRef, true);
         if (!plan) {
             throw new Error('Plan not found: ' + planRef);
         }
@@ -332,7 +332,7 @@ class InstanceManager {
      * @return {Promise<PromiseInfo>}
      */
     async createProcess(planRef, instanceId) {
-        const plan = await assetManager.getPlan(planRef);
+        const plan = await assetManager.getPlan(planRef, true);
         if (!plan) {
             throw new Error('Plan not found: ' + planRef);
         }
@@ -344,7 +344,7 @@ class InstanceManager {
 
         const blockRef = blockInstance.block.ref;
 
-        const blockAsset = await assetManager.getAsset(blockRef);
+        const blockAsset = await assetManager.getAsset(blockRef, true);
         const instanceConfig = await configManager.getConfigForSection(planRef, instanceId);
 
         if (!blockAsset) {

package/src/proxy/routes.js

@@ -34,7 +34,6 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
 
         const plan = await assetManager.getPlan(req.params.systemId);
 
-
         // We can find the connection by the consumer information alone since
         // only 1 provider can be connected to a consumer resource at a time
         const connection = _.find(plan.spec.connections, (connection) => {
@@ -72,13 +71,6 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             req.params.type
         );
 
-        /*
-         Get the path the consumer requested.
-         Note that this might not match the path the destination is expecting so we need to identify the method
-         that is being called and identify the destination path from the connection.
-         */
-        const consumerPath = req.originalUrl.substring(basePath.length - 1);
-
         const fromBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
             return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
         });
@@ -109,6 +101,13 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             address = address.substring(0, address.length - 1);
         }
 
+        /*
+         Get the path the consumer requested.
+         Note that this might not match the path the destination is expecting so we need to identify the method
+         that is being called and identify the destination path from the connection.
+         */
+        const consumerPath = req.originalUrl.substring(basePath.length - 1);
+
         typeHandler(req, res, {
             consumerPath,
             address,

package/src/proxy/types/rest.js

@@ -11,7 +11,7 @@ function getRestMethodId(restResource, httpMethod, httpPath) {
     return _.findKey(restResource.spec.methods, (method) => {
         let methodType = method.method ? method.method.toUpperCase() : 'GET';
 
-        if (methodType !== httpMethod.toUpperCase()) {
+        if (methodType.toUpperCase() !== httpMethod.toUpperCase()) {
             return false;
         }
 
@@ -153,10 +153,10 @@ module.exports = function proxyRestRequest(req, res, opts) {
         socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
 
         if (responseBody) {
-            res.send(responseBody);
-        } else {
-            res.end();
+            res.write(responseBody);
         }
+
+        res.end();
     });
 
 };

package/src/proxy/types/web.js

@@ -10,9 +10,7 @@ const socketManager = require('../../socketManager');
  * @param res {Response}
  * @param opts {ProxyRequestInfo}
  */
-module.exports = function proxyRestRequest(req, res, opts) {
-
-    console.log('Proxy request to provider: %s => %s [web]', opts.consumerPath, opts.address);
+module.exports = function proxyWebRequest(req, res, opts) {
 
     const requestHeaders = _.clone(req.headers);
 
@@ -22,13 +20,14 @@ module.exports = function proxyRestRequest(req, res, opts) {
     delete requestHeaders['host'];
     delete requestHeaders['origin'];
 
-    const sourceBasePath = opts.providerResource.spec.path;
-    const targetBasePath = opts.consumerResource.spec.path;
+    const sourceBasePath = opts.consumerResource.spec.path;
+    const targetBasePath = opts.providerResource.spec.path;
     let path = opts.consumerPath;
     if (opts.consumerPath.startsWith(sourceBasePath)) {
         path = path.replace(sourceBasePath, targetBasePath);
     }
 
+    console.log('Proxy request to provider: %s => %s%s [web]', opts.consumerPath, opts.address, path);
 
     const reqOpts = {
         method: req.method,
@@ -44,38 +43,26 @@ module.exports = function proxyRestRequest(req, res, opts) {
     );
 
     socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    const proxyReq = request(reqOpts);
 
-    request(reqOpts, function(err, response, responseBody) {
-        if (err) {
-            traffic.asError(err);
-            socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
-
+    proxyReq.on('error', function(err) {
+        traffic.asError(err);
+        socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        if (!res.headersSent) {
             res.status(500).send({error: '' + err});
-            return;
         }
+    });
 
-        const responseHeaders = _.clone(response.headers);
-
-        delete responseHeaders['content-length'];
-        delete responseHeaders['content-encoding'];
-        delete responseHeaders['connection'];
-
-        res.set(responseHeaders);
-        res.status(response.statusCode);
-
+    proxyReq.on('response', function(response) {
+        //TODO: Include the response body in the traffic object when it is not a stream
         traffic.withResponse({
             code: response.statusCode,
-            headers: response.headers,
-            body: responseBody
+            headers: response.headers
         });
 
         socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
-
-        if (responseBody) {
-            res.send(responseBody);
-        } else {
-            res.end();
-        }
     });
 
+    //We need to pipe the proxy response to the client response to handle sockets and event streams
+    proxyReq.pipe(res);
 };