@kapeta/local-cluster-service 0.0.60

package/src/assets/routes.js

@@ -0,0 +1,133 @@
+const Router = require('express-promise-router').default;
+const YAML = require('yaml');
+const assetManager = require('../assetManager');
+
+
+function parseBody(req) {
+    switch(req.headers['content-type']) {
+        case 'application/json':
+        case 'application/x-json':
+        case 'text/json':
+            return JSON.parse(req.stringBody);
+
+        case 'application/yaml':
+        case 'application/x-yaml':
+        case 'text/yaml':
+        case 'text/x-yaml':
+        default:
+            return YAML.parse(req.stringBody);
+    }
+}
+
+const router = new Router();
+
+router.use('/', require('../middleware/cors'));
+router.use('/', require('../middleware/stringBody'));
+
+/**
+ * Get all local assets available
+ */
+router.get('/', (req, res) => {
+    res.send(assetManager.getAssets());
+});
+
+/**
+ * Get single asset
+ */
+router.get('/read', (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({error:'Query parameter "ref" is missing'});
+        return;
+    }
+
+    try {
+        res.send(assetManager.getAsset(req.query.ref));
+    } catch(err) {
+        res.status(400).send({error: err.message});
+    }
+
+});
+
+/**
+ * Creates a new local file and registers it as an asset
+ */
+router.post('/create', async (req, res) => {
+    if (!req.query.path) {
+        res.status(400).send({error:'Query parameter "path" is missing'});
+        return;
+    }
+
+    const content = parseBody(req);
+
+    try {
+        const assets = await assetManager.createAsset(req.query.path, content);
+
+        res.status(200).send(assets);
+    } catch(err) {
+        console.log('Failed while creating asset', req.query.path, err.message);
+        res.status(400).send({error: err.message});
+    }
+
+});
+
+/**
+ * Updates reference with new content
+ */
+router.put('/update', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({error:'Query parameter "ref" is missing'});
+        return;
+    }
+
+    const content = parseBody(req);
+
+    try {
+        await assetManager.updateAsset(req.query.ref, content);
+
+        res.sendStatus(204);
+    } catch(err) {
+        console.log('Failed while updating asset', req.query.ref, err.message);
+        res.status(400).send({error: err.message});
+    }
+
+});
+
+
+/**
+ * Unregisters an asset (doesn't delete the asset)
+ */
+router.delete('/', (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({error:'Query parameter "ref" is missing'});
+        return;
+    }
+
+    try {
+        assetManager.unregisterAsset(req.query.ref);
+
+        res.status(204).send();
+    } catch(err) {
+        res.status(400).send({error: err.message});
+    }
+});
+
+
+/**
+ * Registers an existing file as an asset
+ */
+router.put('/import', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({error:'Query parameter "ref" is missing'});
+        return;
+    }
+
+    try {
+        const assets = await assetManager.importFile(req.query.ref);
+
+        res.status(200).send(assets);
+    } catch(err) {
+        res.status(400).send({error: err.message});
+    }
+});
+
+module.exports = router;

package/src/clusterService.js

@@ -0,0 +1,134 @@
+const net = require('net');
+const DEFAULT_SERVER_PORT = 35100;
+const DEFAULT_START_PORT = 40000;
+const DEFAULT_HOST = '127.0.0.1';
+
+class ClusterService {
+
+    constructor() {
+        this._port = DEFAULT_SERVER_PORT;
+        this._currentPort = DEFAULT_START_PORT;
+        this._initialized = false;
+        this._reservedPorts = [];
+        this._host = DEFAULT_HOST;
+    }
+
+    reservePort(port) {
+        const intPort = parseInt(port);
+        if (this._reservedPorts.indexOf(intPort) > -1) {
+            throw new Error('Port already reserved: ' + intPort);
+        }
+
+        this._reservedPorts.push(intPort);
+    }
+
+    async init() {
+        if (this._initialized) {
+            return;
+        }
+
+        this._initialized = true;
+        await this._findClusterServicePort();
+
+    }
+
+    async _findClusterServicePort() {
+        while(true) {
+
+            const isUsed = await this._checkIfPortIsUsed(this._port);
+            if (!isUsed) {
+                break;
+            }
+
+            this._port++;
+
+        }
+    }
+
+
+    /**
+     * Gets next available port
+     * @return {Promise<number>}
+     */
+    async getNextAvailablePort() {
+        while(true) {
+
+            while (this._reservedPorts.indexOf(this._currentPort) > -1) {
+                this._currentPort++;
+            }
+
+            const nextPort = this._currentPort++;
+            const isUsed = await this._checkIfPortIsUsed(nextPort);
+            if (!isUsed) {
+                return nextPort;
+            }
+        }
+    }
+
+    _checkIfPortIsUsed(port, host=this._host) {
+        return new Promise((resolve, reject) => {
+            const server = net.createServer();
+
+            server.once('error', function(err) {
+                if (err.code === 'EADDRINUSE') {
+                    server.close();
+                    resolve(true);
+                    return;
+                }
+
+                server.close();
+                reject(err);
+            });
+
+            server.once('listening', function() {
+                server.close();
+                resolve(false);
+            });
+
+            server.listen( port, host );
+        });
+
+    }
+
+
+    /**
+     * The port of this local cluster service itself
+     */
+    getClusterServicePort() {
+        return this._port;
+    }
+    
+    /* 
+     *Gets the host name ( 127.0.0.1 ) on which Express JS is listening
+     */
+     getClusterServiceHost() {
+        return this._host;
+    }
+
+    /**
+     * Set the port to be used for this local service
+     * @param port
+     */
+    setClusterServicePort(port) {
+        this._port = port;
+    }
+
+    setClusterServiceHost(host) {
+        this._host = host;
+    }
+
+    /**
+     * Gets that proxy path of a given request
+     *
+     * @param systemId
+     * @param consumerInstanceId
+     * @param consumerResourceName
+     * @param portType
+     * @return {string}
+     */
+    getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType) {
+        return `/proxy/${encodeURIComponent(systemId)}/${encodeURIComponent(consumerInstanceId)}/${encodeURIComponent(consumerResourceName)}/${encodeURIComponent(portType)}/`;
+    }
+}
+
+module.exports = new ClusterService();

package/src/codeGeneratorManager.js

@@ -0,0 +1,40 @@
+const Path = require('path');
+
+const {registry:Targets, BlockCodeGenerator, CodeWriter} = require('@kapeta/codegen');
+const ClusterConfiguration = require('@kapeta/local-cluster-config');
+const TARGET_KIND = 'core/language-target';
+const BLOCK_TYPE_KIND = 'core/block-type';
+
+class CodeGeneratorManager {
+
+    reload() {
+        Targets.reset();
+        const languageTargets = ClusterConfiguration.getDefinitions(TARGET_KIND);
+        languageTargets.forEach((languageTarget) => {
+            const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`
+            Targets.register(key, require(languageTarget.path));
+        });
+    }
+
+    canGenerateCode(yamlContent) {
+        const blockTypes = ClusterConfiguration.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypeKinds = blockTypes.map(blockType => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
+        return yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1;
+    }
+
+    async generate(yamlFile, yamlContent) {
+        const baseDir = Path.dirname(yamlFile);
+        console.log('Generating code for path: %s', baseDir);
+        const codeGenerator = new BlockCodeGenerator(yamlContent);
+
+        const output = await codeGenerator.generate();
+        const writer = new CodeWriter(baseDir, {});
+        writer.write(output);
+
+        console.log('Code generated for path: %s', baseDir);
+    }
+}
+
+const manager = new CodeGeneratorManager();
+manager.reload();
+module.exports = manager;

package/src/config/routes.js

@@ -0,0 +1,118 @@
+const Router = require('express-promise-router').default;
+const YAML = require('yaml');
+const configManager = require('../configManager');
+const serviceManager = require('../serviceManager');
+const operatorManager = require('../operatorManager');
+
+const router = new Router();
+
+router.use('/', require('../middleware/kapeta'));
+router.use('/', require('../middleware/stringBody'));
+
+/**
+ * Returns the full configuration for a given service.
+ */
+router.get('/', (req, res) => {
+    //Get service YAML config
+    const config = configManager.getConfigForService(req.kapeta.systemId, req.kapeta.instanceId);
+
+    res.send(YAML.stringify(config));
+});
+
+/**
+ * Updates the full configuration for a given service.
+ */
+router.put('/', (req, res) => {
+
+    let config = YAML.parse(req.stringBody);
+    if (!config) {
+        config = {};
+    }
+    //Get service YAML config
+    configManager.setConfigForService(
+        req.kapeta.systemId,
+        req.kapeta.instanceId,
+        config
+    );
+    res.status(202).send({ok:true});
+});
+
+
+/**
+ * Resolves and checks the identify of a block instance
+ */
+router.get('/identity', async (req, res) => {
+
+
+    const identity = {
+        systemId: req.kapeta.systemId,
+        instanceId: req.kapeta.instanceId
+    };
+
+    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.log(err);
+        
+        res.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.getResourceInfo(
+        req.kapeta.systemId,
+        req.kapeta.instanceId,
+        req.params.resourceType,
+        req.params.portType,
+        req.params.name
+    );
+
+    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
+    ));
+});
+
+module.exports = router;

package/src/configManager.js

@@ -0,0 +1,128 @@
+const _ = require('lodash');
+const storageService = require('./storageService');
+const assetManager = require('./assetManager');
+const {parseKapetaUri} = require("@kapeta/nodejs-utils");
+
+class ConfigManager {
+
+    constructor() {
+        this._config = storageService.section('config');
+    }
+
+    _forSystem(systemId) {
+        if (!this._config[systemId]) {
+            this._config[systemId] = {};
+        }
+
+        return this._config[systemId];
+    }
+
+    setConfigForService(systemId, serviceId, config) {
+        const systemConfig = this._forSystem(systemId);
+        systemConfig[serviceId] = config || {};
+
+        storageService.put('config', systemId, systemConfig);
+    }
+
+    getConfigForService(systemId, serviceId) {
+        const systemConfig = this._forSystem(systemId);
+
+        if (!systemConfig[serviceId]) {
+            systemConfig[serviceId] = {};
+        }
+
+        if (!systemConfig[serviceId].kapeta) {
+            systemConfig[serviceId].kapeta = {};
+        }
+
+        return systemConfig[serviceId];
+    }
+
+    /**
+     * Try to identify the plan and instance in a plan automatically based on the block reference
+     *
+     * It will:
+     * 1. Go through all plans available in the assets
+     * 2. Look through each plan and see if the plan is referencing the block
+     * 3. If only 1 plan references the block - assume that as the system id
+     * 4. If only 1 instance in 1 plan references the block - assume that as instance id
+     *
+     * In case multiple uses of the same block reference we will prompt to user to choose which instance they want to
+     * use.
+     *
+     * @param blockRef block reference
+     * @param [systemId] plan reference
+     * @returns {Promise<{systemId:string,instanceId:string}>}
+     */
+    async resolveIdentity(blockRef, systemId) {
+        const planAssets = assetManager.getPlans();
+
+        const blockUri = parseKapetaUri(blockRef);
+
+        let matchingIdentities = [];
+        planAssets.forEach((planAsset) => {
+            if (systemId && planAsset.ref !== systemId) {
+                //Skip plans that do not match systemid if provided
+                return;
+            }
+
+            if (!planAsset.data.spec.blocks) {
+                return;
+            }
+
+            planAsset.data.spec.blocks.forEach((blockInstance) => {
+                const refUri = parseKapetaUri(blockInstance.block.ref);
+                if (refUri.equals(blockUri)) {
+                    matchingIdentities.push({
+                        systemId: planAsset.ref,
+                        instanceId: blockInstance.id
+                    });
+                }
+            });
+        });
+
+        if (matchingIdentities.length === 0) {
+            if (systemId) {
+                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`);
+        }
+
+        if (matchingIdentities.length > 1) {
+            if (systemId) {
+                throw new Error(`Multiple uses of block "${blockRef}" was found in plan: "${systemId}". Please specify which instance in the plan you wish to run.`)
+            }
+
+            throw new Error(`Multiple uses of block "${blockRef}" was found in 1 or more plan. Please specify which instance in which plan you wish to run.`);
+        }
+
+
+        return matchingIdentities[0];
+    }
+
+    async verifyIdentity(blockRef, systemId, instanceId) {
+        const planAssets = await assetManager.getPlans();
+
+        let found = false;
+        planAssets.forEach((planAsset) => {
+            if (planAsset.ref !== systemId) {
+                //Skip plans that do not match systemid if provided
+                return;
+            }
+
+            planAsset.data.spec.blocks.forEach((blockInstance) => {
+                if (blockInstance.id === instanceId &&
+                    blockInstance.block.ref === blockRef) {
+                    found = true;
+                }
+            });
+        });
+
+        if (!found) {
+            throw new Error(`Block "${blockRef}" was not found in plan: "${systemId}" using instance id ${instanceId}. Please verify that the provided information is accurate.`);
+        }
+    }
+}
+
+module.exports = new ConfigManager();