@kapeta/local-cluster-service 0.6.1 → 0.7.0

package/src/utils/pathTemplateParser.ts

@@ -0,0 +1,138 @@
+import { StringMap } from '../types';
+
+const TYPE_VARIABLE = 'variable';
+const TYPE_PATH = 'path';
+
+/**
+ * A path template is a string that can be used to match a path and extract variables from it.
+ *
+ * E.g. /foo/{bar}/baz
+ *
+ * Would match /foo/123/baz and extract bar=123
+ *
+ * You can also specify a regex for the variable:
+ *  /foo/{bar:[0-9]+}/baz
+ *
+ */
+export class PathTemplate {
+    private _path: string;
+    private _parts: { type: 'variable' | 'path'; value: string; regex?: RegExp }[] = [];
+
+    constructor(pathTemplate: string) {
+        if (!pathTemplate.startsWith('/')) {
+            pathTemplate = '/' + pathTemplate;
+        }
+        this._path = pathTemplate;
+
+        const variableRegex = /{([^}]+)}/g;
+        let match,
+            offset = 0;
+        this._parts = [];
+        while ((match = variableRegex.exec(pathTemplate)) !== null) {
+            if (match.index > offset) {
+                this._parts.push({
+                    type: TYPE_PATH,
+                    value: pathTemplate.substring(offset, match.index),
+                });
+            }
+
+            let regex;
+            let value = match[1];
+            [value, regex] = value.split(/:/, 2);
+
+            if (regex) {
+                regex = new RegExp('^' + regex);
+            } else {
+                regex = /^[^\/]+/;
+            }
+
+            this._parts.push({
+                type: TYPE_VARIABLE,
+                value,
+                regex,
+            });
+            offset = match.index + match[0].length;
+        }
+
+        if (offset < pathTemplate.length) {
+            this._parts.push({
+                type: TYPE_PATH,
+                value: pathTemplate.substring(offset),
+            });
+        }
+    }
+
+    get path() {
+        return this._path;
+    }
+
+    matches(path: string) {
+        return this.parse(path) !== null;
+    }
+
+    parse(path: string) {
+        if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+
+        const values: StringMap = {};
+
+        for (let i = 0; i < this._parts.length; i++) {
+            const part = this._parts[i];
+            switch (part.type) {
+                case TYPE_PATH:
+                    if (!path.startsWith(part.value)) {
+                        return null;
+                    }
+
+                    path = path.substring(part.value.length);
+                    break;
+                case TYPE_VARIABLE:
+                    if (!part.regex?.test(path)) {
+                        return null;
+                    }
+
+                    const newPath = path.replace(part.regex, '');
+                    const value = path.substr(0, path.length - newPath.length);
+                    values[part.value] = value;
+                    path = newPath;
+                    break;
+            }
+        }
+
+        if (path && path !== '/') {
+            //We did not match all of it
+            return null;
+        }
+
+        return values;
+    }
+
+    create(variables: StringMap) {
+        return this._parts
+            .map((part) => {
+                switch (part.type) {
+                    case TYPE_PATH:
+                        return part.value;
+                    case TYPE_VARIABLE:
+                        if (variables[part.value] === undefined || variables[part.value] === null) {
+                            return '';
+                        }
+
+                        return variables[part.value];
+                }
+            })
+            .join('');
+    }
+
+    toString() {
+        return 'tmpl: ' + this.path;
+    }
+}
+
+/**
+ * Parses a path into a RESTPath
+ */
+export function pathTemplateParser(path: string) {
+    return new PathTemplate(path);
+}

package/src/utils/utils.ts

@@ -0,0 +1,12 @@
+import FS from 'node:fs';
+import YAML from 'yaml';
+
+export function readYML(path: string) {
+    const rawYaml = FS.readFileSync(path);
+
+    try {
+        return YAML.parse(rawYaml.toString());
+    } catch (err) {
+        throw new Error('Failed to parse plan YAML: ' + err);
+    }
+}

package/start.ts

@@ -0,0 +1,8 @@
+import localClusterService from './index';
+
+localClusterService
+    .start()
+    .then(({ host, port }) => console.log('Listening on port %s:%s', host, port))
+    .catch((e) => {
+        console.error('Failed to start local cluster due to an error:\n\t - %s', e.toString());
+    });

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "extends": "@tsconfig/node18/tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "declaration": true,
+        "esModuleInterop": true
+    },
+    "ts-node": {
+        "files": true
+    },
+    "include": ["definitions.d.ts", "src/**/*", "index.ts", "start.ts"],
+    "exclude": ["node_modules", "dist"]
+}

package/index.js

@@ -1,127 +0,0 @@
-const clusterService = require('./src/clusterService');
-const storageService = require('./src/storageService');
-const serviceManager = require('./src/serviceManager');
-const socketManager = require('./src/socketManager');
-const containerManager = require('./src/containerManager');
-const express = require('express');
-const HTTP = require('http');
-const {Server} = require("socket.io");
-
-let currentServer = null;
-
-function createServer() {
-    const app = express();
-    app.use('/traffic', require('./src/traffic/routes'));
-    app.use('/proxy', require('./src/proxy/routes'));
-    app.use('/config', require('./src/config/routes'));
-    app.use('/instances', require('./src/instances/routes'));
-    app.use('/identities', require('./src/identities/routes'));
-    app.use('/files', require('./src/filesystem/routes'));
-    app.use('/assets', require('./src/assets/routes'));
-    app.use('/providers', require('./src/providers/routes'));
-    app.use('/', (err, req, res, next) => {
-        console.error('Request failed: %s %s', req.method, req.originalUrl, err);
-        res.status(500).send({
-            ok: false,
-            error: err.error ?? err.message
-        })
-    });
-    const server = HTTP.createServer(app);
-
-    //socket 
-    const io = new Server(server, {
-        cors: {
-            //TODO: This should'nt be hardcoded but also shouldn't be "*"
-            origin: "http://localhost:8080"
-        }
-    });
-    socketManager.setIo(io);
-    return server;
-}
-
-module.exports = {
-
-    isRunning: function() {
-        return !!currentServer;
-    },
-
-    getCurrentPort: function() {
-        if (!currentServer) {
-            return -1;
-        }
-
-        return currentServer.port;
-    },
-
-    /**
-     * Starts the local cluster service.
-     * @return {Promise<{ host: string, port: nubmer, dockerStatus: boolean}>} resolves when listening is done with port number. Rejects if listening failed.
-     */
-    start: async function() {
-        if (currentServer) {
-            throw new Error('Server already started');
-        }
-
-        try {
-            await containerManager.initialize()
-        } catch (e) {
-            console.error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
-        }
-
-        const clusterPort = storageService.get('cluster','port');
-        if (clusterPort) {
-            clusterService.setClusterServicePort(clusterPort);
-        }
-
-        const clusterHost = storageService.get('cluster','host');
-        if (clusterHost) {
-            clusterService.setClusterServiceHost(clusterHost);
-        }
-
-        await clusterService.init();
-
-        currentServer = createServer();
-
-        const port = clusterService.getClusterServicePort();
-
-        const host = clusterService.getClusterServiceHost();
-
-        if (clusterPort !== port) {
-            storageService.put('cluster','port', port);
-        }
-
-        if (clusterHost !== host) {
-            storageService.put('cluster','host', host);
-        }
-
-        return new Promise((resolve, reject) => {
-
-            currentServer.once('error', (err) => {
-                currentServer.close();
-                currentServer = null;
-                reject(err);
-            });
-
-            currentServer.listen(port, host, () => resolve({host,port, dockerStatus: containerManager.isAlive()}));
-            currentServer.host = host;
-            currentServer.port = port;
-        });
-    },
-
-    /**
-     * Stops any currently running cluster services.
-     * @return {Promise<boolean>} Returns true if the service was stopped - false if no service was running.
-     */
-    stop: function() {
-        if (currentServer) {
-            return new Promise(function(resolve) {
-                currentServer.close(() => resolve(true));
-                currentServer = null;
-            });
-        }
-
-        return Promise.resolve(false);
-    },
-    getServices: () => serviceManager.getServices()
-};
-

package/src/filesystem/routes.js

@@ -1,74 +0,0 @@
-const Router = require('express-promise-router').default;
-const stringBodyMiddleware = require('../middleware/stringBody');
-const fileManager = require('../filesystemManager');
-
-let router = new Router();
-
-router.use('/', require('../middleware/cors'));
-
-router.get('/root', (req, res) => {
-  res.send(fileManager.getRootFolder());
-});
-
-router.get('/project/root', (req, res) => {
-  res.send(fileManager.getProjectRootFolder());
-});
-
-router.use('/project/root', stringBodyMiddleware);
-router.post('/project/root', (req, res) => {
-  fileManager.setProjectRootFolder(req.stringBody);
-  res.sendStatus(204);
-});
-
-
-router.use("/",(req,res,next)=>{
-  if (!req.query.path) {
-    res.status(400).send({ error: 'Missing required query parameter "path"' });
-    return;
-  }
-  next();
-});
-
-
-router.get('/list', async (req, res) => {
-  let pathArg = req.query.path;
- 
-  try {
-    res.send(await fileManager.readDirectory(pathArg))
-  } catch (err) {
-    res.status(400).send({error:''+err});
-  }
-
-});
-
-router.get('/readfile', async (req, res) => {
-  let pathArg = req.query.path;
-  try {
-    res.send(await fileManager.readFile(pathArg));
-  } catch (err) {
-    res.status(400).send({error:''+err});
-  }
-});
-
-router.put('/mkdir', async (req, res) => {
-  let pathArg = req.query.path;
-  try {
-    await fileManager.createFolder(pathArg);
-    res.sendStatus(204);
-  } catch (err) {
-    res.status(400).send({error:''+err});
-  }
-});
-
-router.use('/writefile', stringBodyMiddleware);
-router.post('/writefile', async (req, res) => {
-  let pathArg = req.query.path;
-  try {
-    await fileManager.writeFile(pathArg, req.stringBody);
-    res.sendStatus(204);
-  } catch (err) {
-    res.status(400).send({error:''+err});
-  }
-});
-
-module.exports = router;

package/src/identities/routes.js

@@ -1,19 +0,0 @@
-const Router = require('express-promise-router').default;
-const {KapetaAPI} = require('@kapeta/nodejs-api-client');
-
-const instanceManager = require('../instanceManager');
-
-const router = new Router();
-const api = new KapetaAPI();
-
-router.use('/', require('../middleware/cors'));
-
-router.get('/current', async (req, res) => {
-    res.send(await api.getCurrentIdentity());
-});
-
-router.get('/:identityId/memberships', async (req, res) => {
-    res.send(await api.getMemberships(req.params.identityId));
-});
-
-module.exports = router;

package/src/progressListener.js

@@ -1,82 +0,0 @@
-const {spawn} = require("child_process");
-const socketManager = require("./socketManager");
-/**
- *
- * @type {ProgressListener}
- */
-module.exports = {
-    run: (command, directory) => {
-        socketManager.emit(
-            `install`,
-            'install:log',
-            {
-                type: 'info',
-                message: `Running command "${command}"`
-            }
-        );
-
-        return new Promise((resolve, reject) => {
-            const child = spawn(command, {
-                cwd: directory ? directory : process.cwd(),
-                detached: true,
-                shell: true
-            });
-
-            child.stdout.on('data', (data) => {
-                socketManager.emit(`install`, 'install:log', {type: 'info', message: data.toString()});
-            });
-
-            child.stderr.on('data', (data) => {
-                socketManager.emit(`install`, 'install:log', {type: 'info', message: data.toString()});
-            });
-
-            child.on('exit', (exit, signal) => {
-                if (exit !== 0) {
-                    socketManager.emit(`install`, 'install:log', {type: 'info', message: `"${command}" failed: "${exit}"`});
-                    reject(new Error(`Command "${command}" exited with code ${exit}`));
-                } else {
-                    socketManager.emit(`install`, 'install:log', {type: 'info', message: `Command OK: "${command}"`});
-                    resolve({exit, signal});
-                }
-            });
-
-            child.on('error', (err) => {
-                socketManager.emit(`install`, 'install:log', {type: 'info', message: `"${command}" failed: "${err.message}"`});
-                reject(err);
-            });
-        });
-    },
-    progress: async (label, callback) => {
-        socketManager.emit(`install`, 'install:log', {type: 'info', message: `${label}: started`});
-        try {
-            const result = await callback();
-            socketManager.emit(`install`, 'install:log', {type: 'info', message: `${label}: done`});
-            return result;
-        } catch (e) {
-            socketManager.emit(`install`, 'install:log', {type: 'info', message: `${label}: failed. ${e.message}`});
-            throw e;
-        }
-    },
-    check: async (message, ok) => {
-        const wasOk = await ok;
-        socketManager.emit(`install`, 'install:log', {type: 'info', message: `${message}: ${wasOk}`});
-    },
-    start: (label) => {
-        socketManager.emit(`install`, 'install:log', {type: 'info', message: label});
-    },
-    showValue: (label, value) => {
-        socketManager.emit(`install`, 'install:log', {type: 'info', message: `${label}: ${value}`});
-    },
-    error: (msg, ...args) => {
-        socketManager.emit(`install`, 'install:log', {type: 'error', message: msg});
-    },
-    warn: (msg, ...args) => {
-        socketManager.emit(`install`, 'install:log', {type: 'warn', message: msg});
-    },
-    info: (msg, ...args) => {
-        socketManager.emit(`install`, 'install:log', {type: 'info', message: msg});
-    },
-    debug: (msg, ...args) => {
-        socketManager.emit(`install`, 'install:log', {type: 'debug', message: msg});
-    },
-}

package/src/proxy/routes.js

@@ -1,126 +0,0 @@
-const Router = require('express-promise-router').default;
-const _ = require('lodash');
-
-const router = new Router();
-const serviceManager = require('../serviceManager');
-const clusterService = require('../clusterService');
-const assetManager = require('../assetManager');
-
-/**
- * @var {{[key:string]:ProxyRequestHandler}}
- */
-const TYPE_HANDLERS = {
-    rest: require('./types/rest'),
-    web: require('./types/web')
-};
-
-function getResource(resources, resourceName) {
-    return _.find(resources, (resource) => {
-        return (resource.metadata.name.toLowerCase() === resourceName.toLowerCase());
-    });
-}
-
-router.use('/:systemId/:consumerInstanceId/:consumerResourceName', require('../middleware/stringBody'));
-
-router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async (req, res) => {
-
-    try {
-
-        const typeHandler = TYPE_HANDLERS[req.params.type.toLowerCase()];
-        if (!typeHandler) {
-            res.status(401).send({error: 'Unknown connection type: ' + req.params.type});
-            return;
-        }
-
-        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) => {
-            return connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
-                connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase();
-        });
-
-        if (!connection) {
-            res.status(401).send({error:`No connection found for consumer "${req.params.consumerInstanceId}::${req.params.consumerResourceName}"`});
-            return;
-        }
-
-        const toBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
-            return blockInstance.id.toLowerCase() === connection.consumer.blockId.toLowerCase();
-        });
-
-        if (!toBlockInstance) {
-            res.status(401).send({error:`Block instance not found "${req.params.consumerInstanceId}`});
-            return;
-        }
-
-        const toBlockAsset = await assetManager.getAsset(toBlockInstance.block.ref);
-
-        const consumerResource = getResource(toBlockAsset.data.spec.consumers, req.params.consumerResourceName);
-
-        if (!consumerResource) {
-            res.status(401).send({error:`Block resource not found "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`});
-            return;
-        }
-
-        const basePath = clusterService.getProxyPath(
-            req.params.systemId,
-            req.params.consumerInstanceId,
-            req.params.consumerResourceName,
-            req.params.type
-        );
-
-        const fromBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
-            return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
-        });
-
-        if (!fromBlockInstance) {
-            res.status(401).send({error:`Block instance not found "${connection.provider.blockId}`});
-            return;
-        }
-
-        const fromBlockAsset = await assetManager.getAsset(fromBlockInstance.block.ref);
-
-        const providerResource = getResource(fromBlockAsset.data.spec.providers, connection.provider.resourceName);
-
-        if (!providerResource) {
-            res.status(401).send({error:`Block resource not found "${connection.provider.blockId}::${connection.provider.resourceName}`});
-            return;
-        }
-
-
-        //Get target address
-        let address = await serviceManager.getProviderAddress(
-            req.params.systemId,
-            connection.provider.blockId,
-            req.params.type
-        );
-
-        while(address.endsWith('/')) {
-            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,
-            consumerResource,
-            providerResource,
-            connection
-        });
-
-    } catch(err) {
-        console.warn("Failed to process proxy request", err);
-        res.status(400).send({error: err.message});
-    }
-
-});
-
-module.exports = router;

package/src/utils/utils.js

@@ -1,13 +0,0 @@
-const FS = require("node:fs");
-const YAML = require("yaml");
-
-
-exports.readYML = function readYML(path) {
-    let rawYaml = FS.readFileSync(path);
-
-    try {
-        return YAML.parse(rawYaml.toString());
-    } catch(err) {
-        throw new Error('Failed to parse plan YAML: ' + err);
-    }
-}

package/start.js

@@ -1,7 +0,0 @@
-const localClusterService = require('./index.js');
-
-localClusterService.start()
-    .then(({host,port}) => console.log('Listening on port %s:%s', host, port))
-    .catch(e => {
-        console.error('Failed to start local cluster due to an error:\n\t - %s', e.toString())
-    });