@kapeta/local-cluster-service 0.6.0 → 0.7.0

package/dist/cjs/src/containerManager.js

@@ -0,0 +1,365 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerManager = exports.ContainerInfo = void 0;
+const path_1 = __importDefault(require("path"));
+const storageService_1 = require("./storageService");
+const os_1 = __importDefault(require("os"));
+const lodash_1 = __importDefault(require("lodash"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_docker_api_1 = require("node-docker-api");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const local_cluster_config_1 = __importDefault(require("@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);
+});
+class ContainerManager {
+    _docker;
+    _alive;
+    _mountDir;
+    constructor() {
+        this._docker = null;
+        this._alive = false;
+        this._mountDir = path_1.default.join(storageService_1.storageService.getKapetaBasedir(), 'mounts');
+        fs_extra_1.default.mkdirpSync(this._mountDir);
+    }
+    async initialize() {
+        // Use the value from cluster-service.yml if configured
+        const dockerConfig = local_cluster_config_1.default.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_1.default.join(os_1.default.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 node_docker_api_1.Docker(opts);
+                await client.ping();
+                this._docker = client;
+                this._alive = true;
+                return;
+            }
+            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 = (0, nodejs_utils_1.parseKapetaUri)(kind);
+        return path_1.default.join(this._mountDir, kindUri.handle, kindUri.name, mountName);
+    }
+    createMounts(kind, mountOpts) {
+        const mounts = {};
+        lodash_1.default.forEach(mountOpts, (containerPath, mountName) => {
+            const hostPath = this.getMountPoint(kind, mountName);
+            fs_extra_1.default.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}`);
+        }
+    }
+    docker() {
+        if (!this._docker) {
+            throw new Error(`Docker not running`);
+        }
+        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];
+                if (timeSince < cacheForMS) {
+                    return;
+                }
+            }
+            const imageTagList = (await this.docker().image.list())
+                .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,
+        })
+            .then((stream) => promisifyStream(stream));
+        IMAGE_PULL_CACHE[image] = Date.now();
+        console.log('Image pulled: %s', image);
+    }
+    toDockerMounts(mounts) {
+        const Mounts = [];
+        lodash_1.default.forEach(mounts, (Source, Target) => {
+            Mounts.push({
+                Target,
+                Source,
+                Type: 'bind',
+                ReadOnly: false,
+                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,
+            Retries: health.retries || 10,
+        };
+    }
+    async run(image, name, opts) {
+        const PortBindings = {};
+        const Env = [];
+        const Labels = {
+            kapeta: 'true',
+        };
+        await this.pull(image);
+        const ExposedPorts = {};
+        lodash_1.default.forEach(opts.ports, (portInfo, containerPort) => {
+            ExposedPorts['' + containerPort] = {};
+            PortBindings['' + containerPort] = [
+                {
+                    HostPort: '' + portInfo.hostPort,
+                    HostIp: '127.0.0.1',
+                },
+            ];
+            Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+        });
+        const Mounts = this.toDockerMounts(opts.mounts);
+        lodash_1.default.forEach(opts.env, (value, name) => {
+            Env.push(name + '=' + value);
+        });
+        let HealthCheck = undefined;
+        if (opts.health) {
+            HealthCheck = this.toDockerHealth(opts.health);
+        }
+        const dockerContainer = await this.startContainer({
+            name: name,
+            Image: image,
+            Hostname: name + '.kapeta',
+            Labels,
+            Cmd: opts.cmd,
+            ExposedPorts,
+            Env,
+            HealthCheck,
+            HostConfig: {
+                PortBindings,
+                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 = 0) {
+        if (!attempt) {
+            attempt = 0;
+        }
+        if (attempt >= HEALTH_CHECK_MAX) {
+            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) {
+                    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');
+        }
+        if (await this._isHealthy(container)) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            setTimeout(async () => {
+                try {
+                    await this.waitForHealthy(container, (attempt ?? 0) + 1);
+                    resolve();
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }, HEALTH_CHECK_INTERVAL);
+        });
+    }
+    async _isReady(container) {
+        const info = await container.status();
+        const infoData = info?.data;
+        if (infoData?.State?.Status === 'exited') {
+            throw new Error('Container exited unexpectedly');
+        }
+        return infoData?.State?.Running ?? false;
+    }
+    async _isHealthy(container) {
+        const info = await container.status();
+        const infoData = info?.data;
+        return infoData?.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
+            dockerContainer = null;
+        }
+        if (!dockerContainer) {
+            return null;
+        }
+        return new ContainerInfo(dockerContainer);
+    }
+}
+class ContainerInfo {
+    _container;
+    /**
+     *
+     * @param {Container} dockerContainer
+     */
+    constructor(dockerContainer) {
+        /**
+         *
+         * @type {Container}
+         * @private
+         */
+        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 });
+    }
+    async getPort(type) {
+        const ports = await this.getPorts();
+        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) {
+            return false;
+        }
+        const portTypes = {};
+        const ports = {};
+        lodash_1.default.forEach(inspectResult.Config.Labels, (portType, name) => {
+            if (!name.startsWith(LABEL_PORT_PREFIX)) {
+                return;
+            }
+            const hostPort = name.substr(LABEL_PORT_PREFIX.length);
+            portTypes[hostPort] = portType;
+        });
+        lodash_1.default.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;
+    }
+}
+exports.ContainerInfo = ContainerInfo;
+exports.containerManager = new ContainerManager();

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

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

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

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const stringBody_1 = require("../middleware/stringBody");
+const filesystemManager_1 = require("../filesystemManager");
+const cors_1 = require("../middleware/cors");
+let router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.get('/root', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getRootFolder());
+});
+router.get('/project/root', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getProjectRootFolder());
+});
+router.use('/project/root', stringBody_1.stringBody);
+router.post('/project/root', (req, res) => {
+    filesystemManager_1.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_1.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_1.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_1.filesystemManager.createFolder(pathArg);
+        res.sendStatus(204);
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+router.use('/writefile', stringBody_1.stringBody);
+router.post('/writefile', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        await filesystemManager_1.filesystemManager.writeFile(pathArg, req.stringBody ?? '');
+        res.sendStatus(204);
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+exports.default = router;

package/dist/cjs/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 {};

package/dist/cjs/src/filesystemManager.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filesystemManager = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const storageService_1 = require("./storageService");
+const SECTION_ID = 'filesystem';
+const PROJECT_ROOT = 'project_root';
+function isFile(path) {
+    try {
+        return fs_1.default.statSync(path).isFile();
+    }
+    catch (error) {
+        return false;
+    }
+}
+class FilesystemManager {
+    async writeFile(path, data) {
+        const dirName = path_1.default.dirname(path);
+        console.log('Dir name', dirName, path);
+        if (!fs_1.default.existsSync(dirName)) {
+            console.log('Making folder', dirName);
+            fs_extra_1.default.mkdirpSync(dirName, {});
+        }
+        fs_1.default.writeFileSync(path, data);
+    }
+    async createFolder(path) {
+        return new Promise((resolve, reject) => {
+            fs_1.default.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_1.default.readdir(path, (err, files) => {
+                if (err) {
+                    reject(new Error(err));
+                    return;
+                }
+                files.forEach((file) => {
+                    response.push({
+                        path: path_1.default.join(path, file),
+                        folder: fs_1.default.lstatSync(path_1.default.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_1.default.readFile(path, (err, data) => {
+                    if (err) {
+                        reject(new Error(err.message));
+                        return;
+                    }
+                    resolve(data);
+                });
+            }
+        });
+    }
+    getRootFolder() {
+        return require('os').homedir();
+    }
+    getProjectRootFolder() {
+        return storageService_1.storageService.get(SECTION_ID, PROJECT_ROOT);
+    }
+    setProjectRootFolder(folder) {
+        storageService_1.storageService.put(SECTION_ID, PROJECT_ROOT, folder);
+    }
+}
+exports.filesystemManager = new FilesystemManager();

package/dist/cjs/src/identities/routes.d.ts

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

package/dist/cjs/src/identities/routes.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const cors_1 = require("../middleware/cors");
+const router = (0, express_promise_router_1.default)();
+const api = new nodejs_api_client_1.KapetaAPI();
+router.use('/', cors_1.corsHandler);
+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));
+});
+exports.default = router;

package/dist/cjs/src/instanceManager.d.ts

@@ -0,0 +1,56 @@
+import { InstanceInfo, ProcessInfo } from './types';
+declare class InstanceManager {
+    private _interval;
+    /**
+     * Contains an array of running instances that have self-registered with this
+     * cluster service. This is done by the Kapeta SDKs
+     */
+    private _instances;
+    /**
+     * Contains the process info for the instances started by this manager. In memory only
+     * so can't be relied on for knowing everything that's running.
+     *
+     */
+    private _processes;
+    constructor();
+    _save(): void;
+    _checkInstances(): Promise<void>;
+    _isRunning(instance: InstanceInfo): Promise<any>;
+    _getInstanceStatus(instance: InstanceInfo): Promise<string>;
+    getInstances(): InstanceInfo[];
+    getInstancesForPlan(systemId: string): InstanceInfo[];
+    /**
+     * Get instance information
+     *
+     * @param {string} systemId
+     * @param {string} instanceId
+     * @return {*}
+     */
+    getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
+    /**
+     *
+     * @param {string} systemId
+     * @param {string} instanceId
+     * @param {InstanceInfo} info
+     * @return {Promise<void>}
+     */
+    registerInstance(systemId: string, instanceId: string, info: Omit<InstanceInfo, 'systemId' | 'instanceId'>): Promise<void>;
+    setInstanceAsStopped(systemId: string, instanceId: string): void;
+    _emit(systemId: string, type: string, payload: any): void;
+    createProcessesForPlan(planRef: string): Promise<ProcessInfo[]>;
+    _stopInstance(instance: InstanceInfo): Promise<void>;
+    stopAllForPlan(planRef: string): Promise<void>;
+    createProcess(planRef: string, instanceId: string): Promise<ProcessInfo>;
+    /**
+     *
+     * @param {string} planRef
+     * @param {string} instanceId
+     * @return {ProcessInfo|null}
+     */
+    getProcessForInstance(planRef: string, instanceId: string): ProcessInfo | null;
+    restartIfRunning(planRef: string, instanceId: string): Promise<ProcessInfo | undefined>;
+    stopProcess(planRef: string, instanceId: string): Promise<void>;
+    stopAllProcesses(): Promise<void>;
+}
+export declare const instanceManager: InstanceManager;
+export {};