@kapeta/local-cluster-service 0.0.60

package/src/containerManager.js

@@ -0,0 +1,279 @@
+const {Docker} = require('node-docker-api');
+const _  = require('lodash');
+
+const LABEL_PORT_PREFIX = 'kapeta_port-';
+
+const NANO_SECOND = 1000000;
+const HEALTH_CHECK_INTERVAL = 1000;
+const HEALTH_CHECK_MAX = 20;
+
+const promisifyStream = (stream) => new Promise((resolve, reject) => {
+    stream.on('data', (d) => console.log(d.toString()))
+    stream.on('end', resolve)
+    stream.on('error', reject)
+});
+
+class ContainerManager {
+    constructor() {
+        this._docker = new Docker();
+        this._alive = false;
+    }
+
+    async ping() {
+        await this._docker.ping();
+        this._alive = true;
+    }
+
+    async pull(image) {
+        let [imageName, tag] = image.split(/:/);
+        if (!tag) {
+            tag = 'latest';
+        }
+
+        await this._docker.image.create({}, {
+            fromImage: imageName,
+            tag: tag
+        }).then(stream => promisifyStream(stream));
+
+    }
+
+    /**
+     *
+     * @param {string} image
+     * @param {string} name
+     * @param {{ports:{},mounts:{},env:{}}} opts
+     * @return {Promise<ContainerInfo>}
+     */
+    async run(image, name, opts) {
+
+        const Mounts = [];
+        const PortBindings = {};
+        const Env = [];
+        const Labels = {
+            'kapeta':'true'
+        };
+
+        console.log('Pulling image: %s', image);
+
+        await this.pull(image);
+
+        console.log('Image pulled: %s', image);
+
+        _.forEach(opts.ports, (portInfo, containerPort) => {
+            PortBindings['' + containerPort] = [
+                {
+                    HostPort: '' + portInfo.hostPort
+                }
+            ];
+
+            Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+        });
+
+        _.forEach(opts.mounts, (Source, Target) => {
+            Mounts.push({
+                Target,
+                Source,
+                Type: 'bind',
+                ReadOnly: false,
+                Consistency: 'consistent'
+            });
+        });
+
+        _.forEach(opts.env, (value, name) => {
+            Env.push(name + '=' + value);
+        });
+
+        let HealthCheck = undefined;
+
+        if (opts.health) {
+            HealthCheck = {
+                Test: [
+                    'CMD-SHELL',
+                    opts.health.cmd
+                ],
+                Interval: opts.health.interval ? opts.health.interval * NANO_SECOND : 5000 * NANO_SECOND,
+                Timeout: opts.health.timeout ? opts.health.timeout * NANO_SECOND : 15000 * NANO_SECOND,
+                Retries: opts.health.retries || 10
+            };
+
+            console.log('Adding health check', HealthCheck);
+        }
+
+        const dockerContainer = await this._docker.container.create({
+            name: name,
+            Image: image,
+            Labels,
+            Env,
+            HealthCheck,
+            HostConfig: {
+                PortBindings,
+                Mounts
+            }
+        });
+
+        await dockerContainer.start();
+
+        if (opts.health) {
+            await this._waitForHealthy(dockerContainer);
+        }
+
+        return new ContainerInfo(dockerContainer);
+    }
+
+
+    async _waitForHealthy(container, attempt) {
+        if (!attempt) {
+            attempt = 0;
+        }
+
+        if (attempt >= HEALTH_CHECK_MAX) {
+            throw new Error('Operator did not become healthy within the timeout');
+        }
+
+        if (await this._isHealthy(container)) {
+            console.log('Container became healthy');
+            return;
+        }
+
+        return new Promise((resolve) => {
+            setTimeout(async () => {
+                await this._waitForHealthy(container, attempt + 1);
+                resolve();
+            }, HEALTH_CHECK_INTERVAL)
+        });
+
+    }
+
+    async _isHealthy(container) {
+        const info = await container.status();
+
+        return info?.data?.State?.Health?.Status === 'healthy';
+    }
+
+    /**
+     *
+     * @param name
+     * @return {Promise<ContainerInfo>}
+     */
+    async get(name) {
+        let dockerContainer = null;
+
+        try {
+            dockerContainer = await this._docker.container.get(name);
+            await dockerContainer.status();
+        } catch(err) {
+            //Ignore
+            console.log('Container not available - creating it: %s', name);
+            dockerContainer = null;
+        }
+
+        if (!dockerContainer) {
+            return null;
+        }
+
+        return new ContainerInfo(dockerContainer);
+    }
+}
+
+class ContainerInfo {
+    /**
+     *
+     * @param {Container} dockerContainer
+     */
+    constructor(dockerContainer) {
+
+        /**
+         *
+         * @type {Container}
+         * @private
+         */
+        this._container = dockerContainer;
+    }
+
+    async isRunning() {
+        const inspectResult = await this.getStatus();
+
+        if (!inspectResult || 
+            !inspectResult.State) {
+            return false;
+        }
+
+
+        return inspectResult.State.Running || inspectResult.State.Restarting;
+    }
+
+    async start() {
+        await this._container.start();
+    }
+
+    async restart() {
+        await this._container.restart();
+    }
+
+    async stop() {
+        await this._container.stop();
+    }
+
+    async remove(opts) {
+        await this._container.delete({ force: !!opts.force });
+    }
+
+    async getPort(type) {
+        const ports = await this.getPorts();
+
+        if (ports[type]) {
+            return ports[type];
+        }
+
+        return null;
+    }
+
+    async getStatus() {
+        const result = await this._container.status();
+
+        return result ? result.data : null;
+    }
+
+    async getPorts() {
+        const inspectResult = await this.getStatus();
+
+        if (!inspectResult ||
+            !inspectResult.Config ||
+            !inspectResult.Config.Labels) {
+            return false;
+        }
+
+        const portTypes = {};
+        const ports = {};
+
+        _.forEach(inspectResult.Config.Labels, (portType, name) => {
+            if (!name.startsWith(LABEL_PORT_PREFIX)) {
+                return;
+            }
+
+            const hostPort = name.substr(LABEL_PORT_PREFIX.length);
+
+            portTypes[hostPort] = portType;
+
+        });
+
+        _.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {
+            let [containerPort, protocol] = containerPortSpec.split(/\//);
+
+            const hostPort = portBindings[0].HostPort;
+
+            const portType = portTypes[hostPort];
+
+            ports[portType] = {
+                containerPort,
+                protocol,
+                hostPort
+            };
+        });
+
+        return ports;
+    }
+}
+
+
+module.exports = new ContainerManager();

package/src/filesystem/routes.js

@@ -0,0 +1,74 @@
+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/filesystemManager.js

@@ -0,0 +1,89 @@
+const Path = require("path");
+const FS = require("fs");
+const FSExtra = require('fs-extra');
+const storageService = require('./storageService');
+const SECTION_ID = 'filesystem';
+const PROJECT_ROOT = 'project_root';
+
+function isFile(path) {
+    try {
+        return FS.statSync(path).isFile()
+    } catch (error) {
+        return false;
+    }
+}
+
+class FilesystemManager {
+
+    async writeFile(path, data) {
+        const dirName = Path.dirname(path);
+        console.log('Dir name', dirName, path);
+        if (!FS.existsSync(dirName)) {
+            console.log('Making folder', dirName);
+            FSExtra.mkdirpSync(dirName, {});
+        }
+        FS.writeFileSync(path, data);
+    }
+
+    async createFolder(path) {
+        return new Promise((resolve, reject) => {
+            FS.mkdir(path, (err) => {
+                if (err) {
+                    err.message += ". You can only create one single folder at a time.";
+                    reject(err.message);
+                    return;
+                }
+                resolve();
+            })
+        })
+    }
+
+    async readDirectory(path) {
+        return new Promise((resolve, reject) => {
+            let response = [];
+            FS.readdir(path, (err, files) => {
+                if (err) {
+                    reject(new Error(err));
+                    return;
+                }
+                files.forEach((file) => {
+                    response.push({
+                        path: Path.join(path, file),
+                        folder: FS.lstatSync(Path.join(path, file)).isDirectory()
+                    })
+                });
+                resolve(response)
+            });
+        })
+    }
+
+    async readFile(path) {
+        return new Promise((resolve, reject) => {
+            if (!isFile(path)) {
+                reject(new Error("The path provided is invalid.Please check that the path and file name that were provided are spelled correctly. "));
+            } else {
+                FS.readFile(path, (err, data) => {
+                    if (err) {
+                        reject(new Error(err.message));
+                        return;
+                    }
+                    resolve(data)
+                });
+            }
+        })
+    }
+
+    getRootFolder() {
+        return require('os').homedir();
+    }
+
+    getProjectRootFolder() {
+        return storageService.get(SECTION_ID, PROJECT_ROOT);
+    }
+
+    setProjectRootFolder(folder) {
+        storageService.put(SECTION_ID, PROJECT_ROOT, folder);
+    }
+}
+
+module.exports = new FilesystemManager();

package/src/identities/routes.js

@@ -0,0 +1,19 @@
+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;