@kapeta/local-cluster-service 0.6.0 → 0.7.0

package/{src → dist/esm/src}/containerManager.js

@@ -1,62 +1,52 @@
-const { Docker } = require('node-docker-api');
-const path = require('path');
-const _ = require('lodash');
-const os = require('os');
-const Path = require('path');
-const storageService = require('./storageService');
-const mkdirp = require('mkdirp');
-const { parseKapetaUri } = require('@kapeta/nodejs-utils');
-
-const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
-
+import Path from 'path';
+import { storageService } from './storageService';
+import os from 'os';
+import _ from 'lodash';
+import FSExtra from 'fs-extra';
+import { Docker } from 'node-docker-api';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
 const LABEL_PORT_PREFIX = 'kapeta_port-';
-
 const NANO_SECOND = 1000000;
 const HEALTH_CHECK_INTERVAL = 2000;
 const HEALTH_CHECK_MAX = 30;
 const IMAGE_PULL_CACHE_TTL = 30 * 60 * 1000;
 const IMAGE_PULL_CACHE = {};
-
-
-const promisifyStream = (stream) =>
-    new Promise((resolve, reject) => {
-        stream.on('data', (d) => console.log(d.toString()));
-        stream.on('end', resolve);
-        stream.on('error', reject);
-    });
-
+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 {
+    _docker;
+    _alive;
+    _mountDir;
     constructor() {
         this._docker = null;
         this._alive = false;
         this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
-        mkdirp.sync(this._mountDir);
+        FSExtra.mkdirpSync(this._mountDir);
     }
-
     async initialize() {
         // Use the value from cluster-service.yml if configured
         const dockerConfig = ClusterConfiguration.getDockerConfig();
-        const connectOptions =
-            Object.keys(dockerConfig).length > 0
-                ? [dockerConfig]
-                : [
-                      // use defaults: DOCKER_HOST etc from env, if available
-                      undefined,
-                      // default linux
-                      { socketPath: '/var/run/docker.sock' },
-                      // default macOS
-                      {
-                          socketPath: path.join(
-                              os.homedir(),
-                              '.docker/run/docker.sock'
-                          ),
-                      },
-                      // Default http
-                      { protocol: 'http', host: 'localhost', port: 2375 },
-                      { protocol: 'https', host: 'localhost', port: 2376 },
-                      { protocol: 'http', host: '127.0.0.1', port: 2375 },
-                      { protocol: 'https', host: '127.0.0.1', port: 2376 },
-                  ];
+        const connectOptions = Object.keys(dockerConfig).length > 0
+            ? [dockerConfig]
+            : [
+                // use defaults: DOCKER_HOST etc from env, if available
+                undefined,
+                // default linux
+                { socketPath: '/var/run/docker.sock' },
+                // default macOS
+                {
+                    socketPath: Path.join(os.homedir(), '.docker/run/docker.sock'),
+                },
+                // Default http
+                { protocol: 'http', host: 'localhost', port: 2375 },
+                { protocol: 'https', host: 'localhost', port: 2376 },
+                { protocol: 'http', host: '127.0.0.1', port: 2375 },
+                { protocol: 'https', host: '127.0.0.1', port: 2376 },
+            ];
         for (const opts of connectOptions) {
             try {
                 const client = new Docker(opts);
@@ -64,49 +54,38 @@ class ContainerManager {
                 this._docker = client;
                 this._alive = true;
                 return;
-            } catch (err) {
+            }
+            catch (err) {
                 // silently ignore bad configs
             }
         }
-
         throw new Error('Could not connect to docker daemon. Please make sure docker is running and working.');
     }
-
     isAlive() {
         return this._alive;
     }
-
     getMountPoint(kind, mountName) {
         const kindUri = parseKapetaUri(kind);
-        return Path.join(
-            this._mountDir,
-            kindUri.handle,
-            kindUri.name,
-            mountName
-        );
+        return Path.join(this._mountDir, kindUri.handle, kindUri.name, mountName);
     }
-
     createMounts(kind, mountOpts) {
         const mounts = {};
-
         _.forEach(mountOpts, (containerPath, mountName) => {
             const hostPath = this.getMountPoint(kind, mountName);
-            mkdirp.sync(hostPath);
+            FSExtra.mkdirpSync(hostPath);
             mounts[containerPath] = hostPath;
         });
         return mounts;
     }
-
     async ping() {
         try {
             const pingResult = await this.docker().ping();
             if (pingResult !== 'OK') {
                 throw new Error(`Ping failed: ${pingResult}`);
             }
-        } catch (e) {
-            throw new Error(
-                `Docker not running. Please start the docker daemon before running this command. Error: ${e.message}`
-            );
+        }
+        catch (e) {
+            throw new Error(`Docker not running. Please start the docker daemon before running this command. Error: ${e.message}`);
         }
     }
     docker() {
@@ -115,20 +94,17 @@ class ContainerManager {
         }
         return this._docker;
     }
-
     async getContainerByName(containerName) {
         const containers = await this.docker().container.list({ all: true });
         return containers.find((container) => {
             return container.data.Names.indexOf(`/${containerName}`) > -1;
         });
     }
-
     async pull(image, cacheForMS = IMAGE_PULL_CACHE_TTL) {
         let [imageName, tag] = image.split(/:/);
         if (!tag) {
             tag = 'latest';
         }
-
         if (tag !== 'latest') {
             if (IMAGE_PULL_CACHE[image]) {
                 const timeSince = Date.now() - IMAGE_PULL_CACHE[image];
@@ -136,33 +112,26 @@ class ContainerManager {
                     return;
                 }
             }
-
             const imageTagList = (await this.docker().image.list())
-                .filter(image => !!image.data.RepoTags)
-                .map(image => image.data.RepoTags);
+                .map((image) => image.data)
+                .filter((imageData) => !!imageData.RepoTags)
+                .map((imageData) => imageData.RepoTags);
             if (imageTagList.some((imageTags) => imageTags.indexOf(image) > -1)) {
                 console.log('Image found: %s', image);
                 return;
             }
             console.log('Image not found: %s', image);
         }
-
         console.log('Pulling image: %s', image);
         await this.docker()
-            .image.create(
-                {},
-                {
-                    fromImage: imageName,
-                    tag: tag,
-                }
-            )
+            .image.create({}, {
+            fromImage: imageName,
+            tag: tag,
+        })
             .then((stream) => promisifyStream(stream));
-
         IMAGE_PULL_CACHE[image] = Date.now();
-
         console.log('Image pulled: %s', image);
     }
-
     toDockerMounts(mounts) {
         const Mounts = [];
         _.forEach(mounts, (Source, Target) => {
@@ -174,41 +143,24 @@ class ContainerManager {
                 Consistency: 'consistent',
             });
         });
-
         return Mounts;
     }
-
     toDockerHealth(health) {
         return {
             Test: ['CMD-SHELL', health.cmd],
-            Interval: health.interval
-                ? health.interval * NANO_SECOND
-                : 5000 * NANO_SECOND,
-            Timeout: health.timeout
-                ? health.timeout * NANO_SECOND
-                : 15000 * NANO_SECOND,
+            Interval: health.interval ? health.interval * NANO_SECOND : 5000 * NANO_SECOND,
+            Timeout: health.timeout ? health.timeout * NANO_SECOND : 15000 * NANO_SECOND,
             Retries: health.retries || 10,
         };
     }
-
-    /**
-     *
-     * @param {string} image
-     * @param {string} name
-     * @param {{ports:{},mounts:{},env:{}}} opts
-     * @return {Promise<ContainerInfo>}
-     */
     async run(image, name, opts) {
         const PortBindings = {};
         const Env = [];
         const Labels = {
             kapeta: 'true',
         };
-
         await this.pull(image);
-
         const ExposedPorts = {};
-
         _.forEach(opts.ports, (portInfo, containerPort) => {
             ExposedPorts['' + containerPort] = {};
             PortBindings['' + containerPort] = [
@@ -217,18 +169,13 @@ class ContainerManager {
                     HostIp: '127.0.0.1',
                 },
             ];
-
             Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
         });
-
         const Mounts = this.toDockerMounts(opts.mounts);
-
         _.forEach(opts.env, (value, name) => {
             Env.push(name + '=' + value);
         });
-
         let HealthCheck = undefined;
-
         if (opts.health) {
             HealthCheck = this.toDockerHealth(opts.health);
         }
@@ -238,7 +185,6 @@ class ContainerManager {
             Hostname: name + '.kapeta',
             Labels,
             Cmd: opts.cmd,
-
             ExposedPorts,
             Env,
             HealthCheck,
@@ -247,86 +193,73 @@ class ContainerManager {
                 Mounts,
             },
         });
-
         if (opts.health) {
             await this.waitForHealthy(dockerContainer);
         }
-
         return new ContainerInfo(dockerContainer);
     }
-
     async startContainer(opts) {
         const dockerContainer = await this.docker().container.create(opts);
         await dockerContainer.start();
         return dockerContainer;
     }
-
-    async waitForReady(container, attempt) {
+    async waitForReady(container, attempt = 0) {
         if (!attempt) {
             attempt = 0;
         }
-
         if (attempt >= HEALTH_CHECK_MAX) {
-            throw new Error(
-                'Container did not become ready within the timeout'
-            );
+            throw new Error('Container did not become ready within the timeout');
         }
-
         if (await this._isReady(container)) {
             return;
         }
-
         return new Promise((resolve, reject) => {
             setTimeout(async () => {
                 try {
                     await this.waitForReady(container, attempt + 1);
                     resolve();
-                } catch (err) {
+                }
+                catch (err) {
                     reject(err);
                 }
             }, HEALTH_CHECK_INTERVAL);
         });
     }
-
     async waitForHealthy(container, attempt) {
         if (!attempt) {
             attempt = 0;
         }
-
         if (attempt >= HEALTH_CHECK_MAX) {
-            throw new Error(
-                'Container did not become healthy within the timeout'
-            );
+            throw new Error('Container did not become healthy within the timeout');
         }
-
         if (await this._isHealthy(container)) {
             return;
         }
-
         return new Promise((resolve, reject) => {
             setTimeout(async () => {
                 try {
-                    await this.waitForHealthy(container, attempt + 1);
+                    await this.waitForHealthy(container, (attempt ?? 0) + 1);
                     resolve();
-                } catch (err) {
+                }
+                catch (err) {
                     reject(err);
                 }
             }, HEALTH_CHECK_INTERVAL);
         });
     }
-
     async _isReady(container) {
         const info = await container.status();
-        if (info?.data?.State?.Status === 'exited') {
+        const infoData = info?.data;
+        if (infoData?.State?.Status === 'exited') {
             throw new Error('Container exited unexpectedly');
         }
-        return info?.data?.State?.Running;
+        return infoData?.State?.Running ?? false;
     }
     async _isHealthy(container) {
         const info = await container.status();
-        return info?.data?.State?.Health?.Status === 'healthy';
+        const infoData = info?.data;
+        return infoData?.State?.Health?.Status === 'healthy';
     }
-
     /**
      *
      * @param name
@@ -334,24 +267,22 @@ class ContainerManager {
      */
     async get(name) {
         let dockerContainer = null;
-
         try {
             dockerContainer = await this.docker().container.get(name);
             await dockerContainer.status();
-        } catch (err) {
+        }
+        catch (err) {
             //Ignore
             dockerContainer = null;
         }
-
         if (!dockerContainer) {
             return null;
         }
-
         return new ContainerInfo(dockerContainer);
     }
 }
-
-class ContainerInfo {
+export class ContainerInfo {
+    _container;
     /**
      *
      * @param {Container} dockerContainer
@@ -364,96 +295,64 @@ class ContainerInfo {
          */
         this._container = dockerContainer;
     }
-
     get native() {
         return this._container;
     }
-
     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 });
+        await this._container.delete({ force: !!opts?.force });
     }
-
     async getPort(type) {
         const ports = await this.getPorts();
-
-        if (ports[type]) {
+        if (ports && 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
-        ) {
+        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,
-                };
-            }
-        );
-
+        _.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();
+export const containerManager = new ContainerManager();

package/dist/esm/src/filesystem/routes.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare let router: import("express").Router;
+export default router;

package/dist/esm/src/filesystem/routes.js

@@ -0,0 +1,64 @@
+import Router from 'express-promise-router';
+import { stringBody } from '../middleware/stringBody';
+import { filesystemManager } from '../filesystemManager';
+import { corsHandler } from '../middleware/cors';
+let router = Router();
+router.use('/', corsHandler);
+router.get('/root', (req, res) => {
+    res.send(filesystemManager.getRootFolder());
+});
+router.get('/project/root', (req, res) => {
+    res.send(filesystemManager.getProjectRootFolder());
+});
+router.use('/project/root', stringBody);
+router.post('/project/root', (req, res) => {
+    filesystemManager.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 filesystemManager.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 filesystemManager.readFile(pathArg));
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+router.put('/mkdir', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        await filesystemManager.createFolder(pathArg);
+        res.sendStatus(204);
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+router.use('/writefile', stringBody);
+router.post('/writefile', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        await filesystemManager.writeFile(pathArg, req.stringBody ?? '');
+        res.sendStatus(204);
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+export default router;

package/dist/esm/src/filesystemManager.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+declare class FilesystemManager {
+    writeFile(path: string, data: string | Buffer): Promise<void>;
+    createFolder(path: string): Promise<void>;
+    readDirectory(path: string): Promise<{
+        path: string;
+        folder: boolean;
+    }[]>;
+    readFile(path: string): Promise<Buffer>;
+    getRootFolder(): string;
+    getProjectRootFolder(): string | undefined;
+    setProjectRootFolder(folder: string): void;
+}
+export declare const filesystemManager: FilesystemManager;
+export {};