@kapeta/local-cluster-service 0.0.60

package/src/serviceManager.js

@@ -0,0 +1,117 @@
+const clusterService = require('./clusterService');
+const storageService = require('./storageService');
+const _ = require('lodash');
+
+const DEFAULT_PORT_TYPE = 'rest';
+
+class ServiceManager {
+
+    constructor() {
+        this._systems = storageService.get("services");
+        if (!this._systems) {
+            this._systems = {};
+        }
+
+        _.forEach(this._systems, (system) => {
+            _.forEach(system, (services) => {
+                _.forEach(services, (portInfo) => {
+                    clusterService.reservePort(portInfo.port);
+                });
+            });
+        });
+    }
+
+    _forLocal(port, path) {
+        if (!path) {
+            path = '';
+        }
+        const host = clusterService.getClusterServiceHost();
+
+        if (path.startsWith('/')) {
+            path = path.substr(1);
+        }
+        return `http://${host}:${port}/${path}`;
+    }
+
+    _ensureSystem(systemId) {
+        if (!this._systems[systemId]) {
+            this._systems[systemId] = {};
+        }
+
+        return this._systems[systemId];
+    }
+
+    _ensureService(systemId, serviceId) {
+
+        const system = this._ensureSystem(systemId);
+
+        if (!system[serviceId]) {
+            system[serviceId] = {};
+        }
+
+        return system[serviceId];
+    }
+
+    async ensureServicePort(systemId, blockInstanceId, portType) {
+        if (!portType) {
+            portType = DEFAULT_PORT_TYPE;
+        }
+
+        const service = this._ensureService(systemId, blockInstanceId);
+
+        if (!service[portType]) {
+            const port = await clusterService.getNextAvailablePort();
+            service[portType] = {port};
+            this._save();
+        }
+
+        const portTypeSection = service[portType];
+
+
+        return portTypeSection.port;
+    }
+
+    _save() {
+        storageService.put("services", this._systems);
+    }
+
+    /**
+     * Gets the consumable address of a service block resource
+     *
+     * This returns a local proxy path to allow traffic inspection and control.
+     *
+     * @param {string} systemId
+     * @param {string} consumerInstanceId
+     * @param {string} consumerResourceName
+     * @param {string} portType
+     * @return {string}
+     */
+    getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType) {
+        const port = clusterService.getClusterServicePort();
+        const path = clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
+        return this._forLocal(port, path);
+    }
+
+    /**
+     * Gets the direct address of a service block
+     *
+     * This returns the actual endpoint address of a service that we're talking to.
+     * For local services this address will be on localhost - for remote services it will
+     * be their remotely available address.
+     *
+     * @param {string} systemId
+     * @param {string} providerInstanceId
+     * @param {string} portType
+     * @return {Promise<string>}
+     */
+    async getProviderAddress(systemId, providerInstanceId, portType) {
+        const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
+        return this._forLocal(port)
+    }
+
+    getServices() {
+        return this._systems;
+    }
+}
+
+module.exports = new ServiceManager();

package/src/socketManager.js

@@ -0,0 +1,50 @@
+const _ = require('lodash');
+
+class SocketManager {
+
+    constructor() {
+        this._io = null;
+        this._sockets = [];
+        return this;
+    }
+
+    setIo(io) {
+        console.log("socket ready");
+        this._io = io;
+
+        this._bindIO();
+    }
+
+    emit(context, type, payload) {
+        this._io.to(context).emit(type, {context, payload});
+    }
+
+    _bindIO() {
+        this._io.on('connection', (socket) => this._handleSocketCreated(socket))
+    }
+
+    _handleSocketCreated(socket) {
+        this._bindSocket(socket);
+        this._sockets.push(socket);
+    }
+
+    _bindSocket(socket) {
+        socket.on('disconnect', () => this._handleSocketDestroyed(socket))
+        socket.on('join', (id) => {
+            console.log("socket joined ", id);
+            socket.join(id);
+        })
+        socket.on('leave', (id) => {
+            console.log("socket left ", id);
+            socket.leave(id);
+        })
+    }
+
+    _handleSocketDestroyed(socket) {
+        _.pull(this._sockets, socket);
+    }
+
+}
+
+
+module.exports = new SocketManager();

package/src/storageService.js

@@ -0,0 +1,87 @@
+const _ = require('lodash');
+const FS = require('fs');
+const mkdirp = require('mkdirp');
+const YAML = require('yaml');
+const ClusterConfiguration = require('@kapeta/local-cluster-config');
+
+/**
+ * Class that handles reading and writing from local configuration file.
+ */
+class StorageService {
+
+    constructor() {
+        this._data = this._readConfig();
+    }
+
+    getKapetaBasedir() {
+        return ClusterConfiguration.getKapetaBasedir();
+    }
+
+    _readConfig() {
+        return ClusterConfiguration.getClusterConfig();
+    }
+
+    _writeConfig() {
+        const configFile = ClusterConfiguration.getClusterConfigFile();
+
+        mkdirp.sync(this.getKapetaBasedir());
+
+        FS.writeFileSync(configFile, YAML.stringify(this._data));
+    }
+
+    section(section, defaultValue) {
+        if (!defaultValue) {
+            defaultValue = {};
+        }
+        if (!this._data[section]) {
+            this._data[section] = defaultValue;
+            this._writeConfig();
+        }
+
+        return this._data[section];
+    }
+
+    put(section, property, value) {
+        if (!_.isString(property)) {
+            this._data[section] = property;
+            this._writeConfig();
+            return;
+        }
+
+        this.section(section)[property] = value;
+        this._writeConfig();
+    }
+
+    get(section, property) {
+        if (!property) {
+            return this.section(section);
+        }
+
+        return this.section(section)[property];
+    }
+
+    contains(section, property) {
+        if (!this._data[section]) {
+            return false;
+        }
+
+        return this._data[section].hasOwnProperty(property);
+    }
+
+    ensure(section, property, value) {
+        if (this.contains(section, property)) {
+            return this.get(section, property);
+        }
+
+        let out = value;
+        if (typeof value === 'function') {
+            out = value();
+        }
+
+        this.put(section, property, out);
+
+        return out;
+    }
+}
+
+module.exports = new StorageService();

package/src/traffic/routes.js

@@ -0,0 +1,18 @@
+const Router = require('express-promise-router').default;
+const router = new Router();
+const networkManager = require('../networkManager');
+
+router.get('/:systemId/target/:connectionId/', (req, res) => {
+    res.send(networkManager.getTrafficForConnection(req.params.systemId, req.params.connectionId));
+});
+
+router.get('/:systemId/source/:blockInstanceId/', (req, res) => {
+    res.send(networkManager.getTrafficForSource(req.params.systemId, req.params.blockInstanceId));
+});
+
+router.get('/:systemId/target/:blockInstanceId/', (req, res) => {
+    res.send(networkManager.getTrafficForTarget(req.params.systemId, req.params.blockInstanceId));
+});
+
+
+module.exports = router;

package/src/utils/pathTemplateParser.js

@@ -0,0 +1,116 @@
+
+const TYPE_VARIABLE = 'variable';
+const TYPE_PATH = 'path';
+
+class PathTemplate {
+    constructor(pathTemplate) {
+        if (!pathTemplate.startsWith('/')) {
+            pathTemplate = '/' + pathTemplate;
+        }
+        this._path = pathTemplate;
+
+        this._parts = pathTemplate.split(/{/g).map((part) => {
+            if (part.endsWith('}')) {
+                let regex,
+                    value = part.substr(0, part.length -  1);
+
+                [value, regex] = value.split(/:/, 2);
+
+                if (regex) {
+                    regex = new RegExp('^' + regex);
+                } else {
+                    regex = /^[^\/]+/
+                }
+
+                return {
+                    type: TYPE_VARIABLE,
+                    value,
+                    regex
+                };
+            }
+
+            return {
+                type: TYPE_PATH,
+                value: part
+            };
+        });
+
+
+    }
+
+    get path() {
+        return this._path;
+    }
+
+    matches(path) {
+        return this.parse(path) !== null;
+    }
+
+    parse(path) {
+        if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+
+        const values = {};
+
+        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.substr(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) {
+        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
+ * @param {string} path
+ */
+function pathTemplateParser(path) {
+    return new PathTemplate(path);
+}
+
+module.exports = pathTemplateParser;

package/start.js

@@ -0,0 +1,7 @@
+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())
+    });