@kapeta/local-cluster-service 0.6.0 → 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/config/routes.js

@@ -1,160 +0,0 @@
-const Router = require('express-promise-router').default;
-const configManager = require('../configManager');
-const serviceManager = require('../serviceManager');
-const operatorManager = require('../operatorManager');
-
-const router = new Router();
-const SYSTEM_ID = '$plan';
-
-router.use('/', require('../middleware/cors'));
-router.use('/', require('../middleware/kapeta'));
-router.use('/', require('../middleware/stringBody'));
-
-/**
- * Returns the full configuration for a given service.
- */
-router.get('/instance', (req, res) => {
-
-    const config = req.kapeta.instanceId ?
-        configManager.getConfigForSection(req.kapeta.systemId, req.kapeta.instanceId) :
-        configManager.getConfigForSystem(req.kapeta.systemId);
-
-    res.send(config);
-});
-
-/**
- * Updates the full configuration for a given service.
- */
-router.put('/instance', (req, res) => {
-
-    let config = JSON.parse(req.stringBody);
-    if (!config) {
-        config = {};
-    }
-
-    if (req.kapeta.instanceId) {
-        configManager.setConfigForSection(
-            req.kapeta.systemId,
-            req.kapeta.instanceId,
-            config
-        );
-    } else {
-        configManager.setConfigForSystem(
-            req.kapeta.systemId,
-            config
-        );
-    }
-
-    res.status(202).send({ok:true});
-});
-
-/**
- * Returns the full configuration for a plan
- */
-router.get('/system', (req, res) => {
-    const config = configManager.getConfigForSection(req.kapeta.systemId, SYSTEM_ID);
-
-    res.send(config);
-});
-
-/**
- * Updates the full configuration for a plan
- */
-router.put('/system', (req, res) => {
-
-    let config = JSON.parse(req.stringBody);
-    if (!config) {
-        config = {};
-    }
-    configManager.setConfigForSection(
-        req.kapeta.systemId,
-        SYSTEM_ID,
-        config
-    );
-    res.status(202).send({ok:true});
-});
-
-
-/**
- * Resolves and checks the identity of a block instance
- */
-router.get('/identity', async (req, res) => {
-
-
-    const identity = {
-        systemId: req.kapeta.systemId,
-        instanceId: req.kapeta.instanceId
-    };
-
-    if (!req.kapeta.blockRef) {
-        res.status(400).send({error: 'Missing required header "X-Kapeta-Block"'});
-        return;
-    }
-
-    try {
-
-        if (!identity.systemId ||
-            !identity.instanceId) {
-            const {systemId, instanceId} = await configManager.resolveIdentity(req.kapeta.blockRef, identity.systemId);
-            identity.systemId = systemId;
-            identity.instanceId = instanceId;
-        } else {
-            await configManager.verifyIdentity(req.kapeta.blockRef, identity.systemId, identity.instanceId);
-        }
-
-        res.send(identity);
-    } catch(err) {
-        console.warn('Failed to resolve identity', err);
-        res.status(400).send({error: err.message});
-    }
-});
-
-/**
- * Services call this to request a free port. If a service has
- * already called the endpoint the same port is returned.
- */
-router.get('/provides/:type', async (req, res) => {
-    //Get service port
-    res.send('' + await serviceManager.ensureServicePort(
-        req.kapeta.systemId,
-        req.kapeta.instanceId,
-        req.params.type
-    ));
-});
-
-/**
- * Used by services to get info for consumed operator resource.
- *
- * If the operator resource is not already available this will cause it to start an instance and
- * assign port numbers to it etc.
- */
-router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res) => {
-    const operatorInfo = await operatorManager.getConsumerResourceInfo(
-        req.kapeta.systemId,
-        req.kapeta.instanceId,
-        req.params.resourceType,
-        req.params.portType,
-        req.params.name,
-        req.kapeta.environment
-    );
-
-    res.send(operatorInfo);
-});
-
-/**
- * Used by services to get address for their clients.
- *
- * If the remote service is not already registered with a port - we do that here
- * to handle clients for services that hasn't started yet.
- */
-router.get('/consumes/:resourceName/:type', (req, res) => {
-    res.send(serviceManager.getConsumerAddress(
-        req.kapeta.systemId,
-        req.kapeta.instanceId,
-        req.params.resourceName,
-        req.params.type,
-        req.kapeta.environment,
-    ));
-});
-
-module.exports = router;

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