@kapeta/local-cluster-service 0.6.0 → 0.7.0

package/dist/cjs/src/instanceManager.js

@@ -0,0 +1,424 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceManager = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const request_1 = __importDefault(require("request"));
+const events_1 = __importDefault(require("events"));
+const BlockInstanceRunner_1 = require("./utils/BlockInstanceRunner");
+const storageService_1 = require("./storageService");
+const socketManager_1 = require("./socketManager");
+const serviceManager_1 = require("./serviceManager");
+const assetManager_1 = require("./assetManager");
+const containerManager_1 = require("./containerManager");
+const configManager_1 = require("./configManager");
+const CHECK_INTERVAL = 10000;
+const DEFAULT_HEALTH_PORT_TYPE = 'rest';
+const EVENT_STATUS_CHANGED = 'status-changed';
+const EVENT_INSTANCE_CREATED = 'instance-created';
+const EVENT_INSTANCE_EXITED = 'instance-exited';
+const EVENT_INSTANCE_LOG = 'instance-log';
+const STATUS_STARTING = 'starting';
+const STATUS_READY = 'ready';
+const STATUS_UNHEALTHY = 'unhealthy';
+const STATUS_STOPPED = 'stopped';
+const MIN_TIME_RUNNING = 30000; //If something didnt run for more than 30 secs - it failed
+class InstanceManager {
+    _interval;
+    /**
+     * Contains an array of running instances that have self-registered with this
+     * cluster service. This is done by the Kapeta SDKs
+     */
+    _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.
+     *
+     */
+    _processes = {};
+    constructor() {
+        this._interval = setInterval(() => this._checkInstances(), CHECK_INTERVAL);
+        this._instances = storageService_1.storageService.section('instances', []);
+        this._processes = {};
+        this._checkInstances();
+    }
+    _save() {
+        storageService_1.storageService.put('instances', this._instances);
+    }
+    async _checkInstances() {
+        let changed = false;
+        for (let i = 0; i < this._instances.length; i++) {
+            const instance = this._instances[i];
+            const newStatus = await this._getInstanceStatus(instance);
+            if (newStatus === STATUS_UNHEALTHY && instance.status === STATUS_STARTING) {
+                // If instance is starting we consider unhealthy an indication
+                // that it is still starting
+                continue;
+            }
+            if (instance.status !== newStatus) {
+                instance.status = newStatus;
+                console.log('Instance status changed: %s %s -> %s', instance.systemId, instance.instanceId, instance.status);
+                this._emit(instance.systemId, EVENT_STATUS_CHANGED, instance);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this._save();
+        }
+    }
+    async _isRunning(instance) {
+        if (!instance.pid) {
+            return;
+        }
+        if (instance.type === 'docker') {
+            const container = await containerManager_1.containerManager.get(instance.pid);
+            if (!container) {
+                console.warn('Container not found: %s', instance.pid);
+                return false;
+            }
+            return await container.isRunning();
+        }
+        //Otherwise its just a normal process.
+        //TODO: Handle for Windows
+        try {
+            return process.kill(instance.pid, 0);
+        }
+        catch (err) {
+            return err.code === 'EPERM';
+        }
+    }
+    async _getInstanceStatus(instance) {
+        if (instance.status === STATUS_STOPPED) {
+            //Will only change when it reregisters
+            return STATUS_STOPPED;
+        }
+        if (!(await this._isRunning(instance))) {
+            return STATUS_STOPPED;
+        }
+        if (!instance.health) {
+            //No health url means we assume it's healthy as soon as it's running
+            return STATUS_READY;
+        }
+        return new Promise((resolve) => {
+            if (!instance.health) {
+                resolve(STATUS_READY);
+                return;
+            }
+            (0, request_1.default)(instance.health, (err, response) => {
+                if (err) {
+                    resolve(STATUS_UNHEALTHY);
+                    return;
+                }
+                if (response.statusCode > 399) {
+                    resolve(STATUS_UNHEALTHY);
+                    return;
+                }
+                resolve(STATUS_READY);
+            });
+        });
+    }
+    getInstances() {
+        if (!this._instances) {
+            return [];
+        }
+        return [...this._instances];
+    }
+    getInstancesForPlan(systemId) {
+        if (!this._instances) {
+            return [];
+        }
+        return this._instances.filter((instance) => instance.systemId === systemId);
+    }
+    /**
+     * Get instance information
+     *
+     * @param {string} systemId
+     * @param {string} instanceId
+     * @return {*}
+     */
+    getInstance(systemId, instanceId) {
+        return lodash_1.default.find(this._instances, { systemId, instanceId });
+    }
+    /**
+     *
+     * @param {string} systemId
+     * @param {string} instanceId
+     * @param {InstanceInfo} info
+     * @return {Promise<void>}
+     */
+    async registerInstance(systemId, instanceId, info) {
+        let instance = this.getInstance(systemId, instanceId);
+        //Get target address
+        let address = await serviceManager_1.serviceManager.getProviderAddress(systemId, instanceId, info.portType ?? DEFAULT_HEALTH_PORT_TYPE);
+        let healthUrl = null;
+        let health = info.health;
+        if (health) {
+            if (health.startsWith('/')) {
+                health = health.substring(1);
+            }
+            healthUrl = address + health;
+        }
+        if (instance) {
+            instance.status = STATUS_STARTING;
+            instance.pid = info.pid;
+            instance.address = address;
+            if (info.type) {
+                instance.type = info.type;
+            }
+            if (healthUrl) {
+                instance.health = healthUrl;
+            }
+            this._emit(systemId, EVENT_STATUS_CHANGED, instance);
+        }
+        else {
+            instance = {
+                systemId,
+                instanceId,
+                status: STATUS_STARTING,
+                pid: info.pid,
+                type: info.type,
+                health: healthUrl,
+                address,
+            };
+            this._instances.push(instance);
+            this._emit(systemId, EVENT_INSTANCE_CREATED, instance);
+        }
+        this._save();
+    }
+    setInstanceAsStopped(systemId, instanceId) {
+        const instance = lodash_1.default.find(this._instances, { systemId, instanceId });
+        if (instance) {
+            instance.status = STATUS_STOPPED;
+            instance.pid = null;
+            instance.health = null;
+            this._emit(systemId, EVENT_STATUS_CHANGED, instance);
+            this._save();
+        }
+    }
+    _emit(systemId, type, payload) {
+        try {
+            socketManager_1.socketManager.emit(`${systemId}/instances`, type, payload);
+        }
+        catch (e) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
+    async createProcessesForPlan(planRef) {
+        await this.stopAllForPlan(planRef);
+        const plan = await assetManager_1.assetManager.getPlan(planRef, true);
+        if (!plan) {
+            throw new Error('Plan not found: ' + planRef);
+        }
+        if (!plan.spec.blocks) {
+            console.warn('No blocks found in plan', planRef);
+            return [];
+        }
+        let promises = [];
+        let errors = [];
+        for (let blockInstance of Object.values(plan.spec.blocks)) {
+            try {
+                promises.push(this.createProcess(planRef, blockInstance.id));
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        const settled = await Promise.allSettled(promises);
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+        return settled.map((p) => (p.status === 'fulfilled' ? p.value : null)).filter((p) => !!p);
+    }
+    async _stopInstance(instance) {
+        if (!instance.pid) {
+            return;
+        }
+        if (instance.status === 'stopped') {
+            return;
+        }
+        try {
+            if (instance.type === 'docker') {
+                const container = await containerManager_1.containerManager.get(instance.pid);
+                if (container) {
+                    try {
+                        await container.stop();
+                    }
+                    catch (e) {
+                        console.error('Failed to stop container', e);
+                    }
+                }
+                return;
+            }
+            process.kill(instance.pid, 'SIGTERM');
+        }
+        catch (e) {
+            console.error('Failed to stop process', e);
+        }
+    }
+    async stopAllForPlan(planRef) {
+        if (this._processes[planRef]) {
+            const promises = [];
+            console.log('Stopping all processes for plan', planRef);
+            for (let instance of Object.values(this._processes[planRef])) {
+                promises.push(instance.stop());
+            }
+            await Promise.all(promises);
+            this._processes[planRef] = {};
+        }
+        //Also stop instances not being maintained by the cluster service
+        const instancesForPlan = this._instances.filter((instance) => instance.systemId === planRef);
+        const promises = [];
+        for (let instance of instancesForPlan) {
+            promises.push(this._stopInstance(instance));
+        }
+        await Promise.all(promises);
+    }
+    async createProcess(planRef, instanceId) {
+        const plan = await assetManager_1.assetManager.getPlan(planRef, true);
+        if (!plan) {
+            throw new Error('Plan not found: ' + planRef);
+        }
+        const blockInstance = plan.spec && plan.spec.blocks ? lodash_1.default.find(plan.spec.blocks, { id: instanceId }) : null;
+        if (!blockInstance) {
+            throw new Error('Block instance not found: ' + instanceId);
+        }
+        const blockRef = blockInstance.block.ref;
+        const blockAsset = await assetManager_1.assetManager.getAsset(blockRef, true);
+        const instanceConfig = await configManager_1.configManager.getConfigForSection(planRef, instanceId);
+        if (!blockAsset) {
+            throw new Error('Block not found: ' + blockRef);
+        }
+        if (!this._processes[planRef]) {
+            this._processes[planRef] = {};
+        }
+        await this.stopProcess(planRef, instanceId);
+        const type = blockAsset.version === 'local' ? 'local' : 'docker';
+        const runner = new BlockInstanceRunner_1.BlockInstanceRunner(planRef);
+        const startTime = Date.now();
+        try {
+            const process = await runner.start(blockRef, instanceId, instanceConfig);
+            //emit stdout/stderr via sockets
+            process.output.on('data', (data) => {
+                const payload = {
+                    source: 'stdout',
+                    level: 'INFO',
+                    message: data.toString(),
+                    time: Date.now(),
+                };
+                this._emit(instanceId, EVENT_INSTANCE_LOG, payload);
+            });
+            process.output.on('exit', (exitCode) => {
+                const timeRunning = Date.now() - startTime;
+                const instance = this.getInstance(planRef, instanceId);
+                if (instance?.status === STATUS_READY) {
+                    //It's already been running
+                    return;
+                }
+                if (exitCode === 143 || exitCode === 137) {
+                    //Process got SIGTERM (143) or SIGKILL (137)
+                    //TODO: Windows?
+                    return;
+                }
+                if (exitCode !== 0 || timeRunning < MIN_TIME_RUNNING) {
+                    this._emit(blockInstance.id, EVENT_INSTANCE_EXITED, {
+                        error: 'Failed to start instance',
+                        status: EVENT_INSTANCE_EXITED,
+                        instanceId: blockInstance.id,
+                    });
+                }
+            });
+            await this.registerInstance(planRef, instanceId, {
+                type: process.type,
+                pid: process.pid ?? -1,
+                health: null,
+                portType: process.portType,
+                status: STATUS_STARTING,
+            });
+            return (this._processes[planRef][instanceId] = process);
+        }
+        catch (e) {
+            console.warn('Failed to start instance', e);
+            const logs = [
+                {
+                    source: 'stdout',
+                    level: 'ERROR',
+                    message: e.message,
+                    time: Date.now(),
+                },
+            ];
+            await this.registerInstance(planRef, instanceId, {
+                type: 'local',
+                pid: null,
+                health: null,
+                portType: DEFAULT_HEALTH_PORT_TYPE,
+                status: STATUS_UNHEALTHY,
+            });
+            this._emit(instanceId, EVENT_INSTANCE_LOG, logs[0]);
+            this._emit(blockInstance.id, EVENT_INSTANCE_EXITED, {
+                error: `Failed to start instance: ${e.message}`,
+                status: EVENT_INSTANCE_EXITED,
+                instanceId: blockInstance.id,
+            });
+            return (this._processes[planRef][instanceId] = {
+                pid: -1,
+                type,
+                logs: () => logs,
+                stop: () => Promise.resolve(),
+                ref: blockRef,
+                id: instanceId,
+                name: blockInstance.name,
+                output: new events_1.default(),
+            });
+        }
+    }
+    /**
+     *
+     * @param {string} planRef
+     * @param {string} instanceId
+     * @return {ProcessInfo|null}
+     */
+    getProcessForInstance(planRef, instanceId) {
+        if (!this._processes[planRef]) {
+            return null;
+        }
+        return this._processes[planRef][instanceId];
+    }
+    async restartIfRunning(planRef, instanceId) {
+        if (!this._processes[planRef] || !this._processes[planRef][instanceId]) {
+            return;
+        }
+        // createProcess will stop the process first if it's running
+        return this.createProcess(planRef, instanceId);
+    }
+    async stopProcess(planRef, instanceId) {
+        if (!this._processes[planRef]) {
+            return;
+        }
+        if (this._processes[planRef][instanceId]) {
+            try {
+                await this._processes[planRef][instanceId].stop();
+            }
+            catch (e) {
+                console.error('Failed to stop process for instance: %s -> %s', planRef, instanceId, e);
+            }
+            delete this._processes[planRef][instanceId];
+        }
+    }
+    async stopAllProcesses() {
+        for (let processesForPlan of Object.values(this._processes)) {
+            for (let processInfo of Object.values(processesForPlan)) {
+                await processInfo.stop();
+            }
+        }
+        this._processes = {};
+        for (let instance of this._instances) {
+            await this._stopInstance(instance);
+        }
+    }
+}
+exports.instanceManager = new InstanceManager();
+process.on('exit', async () => {
+    await exports.instanceManager.stopAllProcesses();
+});

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

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

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

@@ -0,0 +1,134 @@
+"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 instanceManager_1 = require("../instanceManager");
+const serviceManager_1 = require("../serviceManager");
+const cors_1 = require("../middleware/cors");
+const kapeta_1 = require("../middleware/kapeta");
+const stringBody_1 = require("../middleware/stringBody");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', kapeta_1.kapetaHeaders);
+/**
+ * Get all instances
+ */
+router.get('/', (req, res) => {
+    res.send(instanceManager_1.instanceManager.getInstances());
+});
+/**
+ * Get all instances
+ */
+router.get('/:systemId/instances', (req, res) => {
+    res.send(instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
+});
+/**
+ * Start all instances in a plan
+ */
+router.post('/:systemId/start', async (req, res) => {
+    const processes = await instanceManager_1.instanceManager.createProcessesForPlan(req.params.systemId);
+    res.status(202).send({
+        ok: true,
+        processes: processes.map((p) => {
+            return { pid: p.pid, type: p.type };
+        }),
+    });
+});
+/**
+ * Stop all instances in plan
+ */
+router.post('/:systemId/stop', async (req, res) => {
+    await instanceManager_1.instanceManager.stopAllForPlan(req.params.systemId);
+    res.status(202).send({
+        ok: true,
+    });
+});
+/**
+ * Start single instance in a plan
+ */
+router.post('/:systemId/:instanceId/start', async (req, res) => {
+    const process = await instanceManager_1.instanceManager.createProcess(req.params.systemId, req.params.instanceId);
+    res.status(202).send({
+        ok: true,
+        pid: process.pid,
+        type: process.type,
+    });
+});
+/**
+ * Stop single instance in a plan
+ */
+router.post('/:systemId/:instanceId/stop', async (req, res) => {
+    await instanceManager_1.instanceManager.stopProcess(req.params.systemId, req.params.instanceId);
+    res.status(202).send({ ok: true });
+});
+/**
+ * Get logs for instance in a plan
+ */
+router.get('/:systemId/:instanceId/logs', (req, res) => {
+    const processInfo = instanceManager_1.instanceManager.getProcessForInstance(req.params.systemId, req.params.instanceId);
+    if (!processInfo) {
+        res.status(404).send({ ok: false });
+        return;
+    }
+    res.status(202).send({
+        logs: processInfo.logs(),
+    });
+});
+/**
+ * Get public address for instance in a plan if available
+ */
+router.get('/:systemId/:instanceId/address/public', (req, res) => {
+    const instance = instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    if (!instance) {
+        res.status(404).send({ ok: false });
+        return;
+    }
+    if (!instance.address) {
+        res.status(400).send({ error: `Instance does not have an address. Make sure it's running.` });
+        return;
+    }
+    res.status(200).send(instance.address);
+});
+/**
+ * Get public address for particular resource on instance in a plan if available
+ */
+router.get('/:systemId/:instanceId/provider/:portType/:resourceName/address/public', (req, res) => {
+    res.send(serviceManager_1.serviceManager.getConsumerAddress(req.params.systemId, req.params.instanceId, req.params.resourceName, req.params.portType, req.kapeta?.environment));
+});
+router.use('/', stringBody_1.stringBody);
+router.use('/', (req, res, next) => {
+    if (!req.kapeta.blockRef) {
+        res.status(400).send({ error: 'Missing X-Kapeta-Block header.' });
+        return;
+    }
+    next();
+});
+/**
+ * Updates the full configuration for a given service.
+ */
+router.put('/', async (req, res) => {
+    let instance = req.stringBody ? JSON.parse(req.stringBody) : null;
+    if (req.kapeta.environment === 'docker') {
+        //A bit hacky but we want to avoid overwriting the docker PID with a process PID
+        const oldInstance = instanceManager_1.instanceManager.getInstance(req.kapeta.systemId, req.kapeta.instanceId);
+        if (oldInstance) {
+            instance.pid = oldInstance.pid;
+        }
+        instance.type = 'docker';
+    }
+    else if (req.kapeta.environment === 'process') {
+        instance.type = 'process';
+    }
+    await instanceManager_1.instanceManager.registerInstance(req.kapeta.systemId, req.kapeta.instanceId, instance);
+    res.status(202).send({ ok: true });
+});
+/**
+ * Delete instance
+ */
+router.delete('/', async (req, res) => {
+    await instanceManager_1.instanceManager.setInstanceAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
+    res.status(202).send({ ok: true });
+});
+exports.default = router;

package/dist/cjs/src/middleware/cors.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function corsHandler(req: Request, res: Response, next: NextFunction): void;

package/dist/cjs/src/middleware/cors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsHandler = void 0;
+function corsHandler(req, res, next) {
+    res.set('Access-Control-Allow-Origin', req.headers.origin);
+    res.set('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE, HEAD, PATCH');
+    res.set('Access-Control-Allow-Headers', '*');
+    next();
+}
+exports.corsHandler = corsHandler;

package/dist/cjs/src/middleware/kapeta.d.ts

@@ -0,0 +1,11 @@
+import { NextFunction, Request, Response } from 'express';
+import { EnvironmentType } from '../types';
+export interface KapetaRequest extends Request {
+    kapeta?: {
+        blockRef: string;
+        instanceId: string;
+        systemId: string;
+        environment?: EnvironmentType;
+    };
+}
+export declare function kapetaHeaders(req: KapetaRequest, res: Response, next: NextFunction): void;

package/dist/cjs/src/middleware/kapeta.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kapetaHeaders = void 0;
+function kapetaHeaders(req, res, next) {
+    let blockRef = req.headers['x-kapeta-block'];
+    let systemId = req.headers['x-kapeta-system'];
+    let instanceId = req.headers['x-kapeta-instance'];
+    let environment = req.headers['x-kapeta-environment'];
+    req.kapeta = {
+        blockRef,
+        instanceId,
+        systemId,
+        environment: environment ? environment : undefined,
+    };
+    next();
+}
+exports.kapetaHeaders = kapetaHeaders;

package/dist/cjs/src/middleware/stringBody.d.ts

@@ -0,0 +1,5 @@
+import { NextFunction, Request, Response } from 'express';
+export type StringBodyRequest = Request<any> & {
+    stringBody?: string;
+};
+export declare function stringBody(req: StringBodyRequest, res: Response, next: NextFunction): void;

package/dist/cjs/src/middleware/stringBody.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringBody = void 0;
+function stringBody(req, res, next) {
+    // push the data to body
+    const body = [];
+    req.on('data', (chunk) => {
+        body.push(chunk);
+    }).on('end', () => {
+        req.stringBody = Buffer.concat(body).toString();
+        next();
+    });
+}
+exports.stringBody = stringBody;

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

@@ -0,0 +1,32 @@
+import { Connection, SimpleRequest, SimpleResponse } from './types';
+declare class NetworkManager {
+    private _connections;
+    private _sources;
+    private _targets;
+    static toConnectionId(connection: Connection): string;
+    constructor();
+    _ensureSystem(systemId: string): void;
+    _ensureConnection(systemId: string, connectionId: string): Traffic[];
+    _ensureSource(systemId: string, sourceBlockInstanceId: string): Traffic[];
+    _ensureTarget(systemId: string, targetBlockInstanceId: string): Traffic[];
+    addRequest(systemId: string, connection: Connection, request: SimpleRequest, consumerMethodId?: string, providerMethodId?: string): Traffic;
+    getTrafficForConnection(systemId: string, connectionId: string): Traffic[];
+    getTrafficForSource(systemId: string, blockInstanceId: string): Traffic[];
+    getTrafficForTarget(systemId: string, blockInstanceId: string): Traffic[];
+}
+declare class Traffic {
+    readonly id: string;
+    readonly connectionId: string;
+    readonly consumerMethodId: string | undefined;
+    readonly providerMethodId: string | undefined;
+    readonly created: number;
+    readonly request: SimpleRequest;
+    ended: null | number;
+    error: null | string;
+    response: SimpleResponse | null;
+    constructor(connection: Connection, request: SimpleRequest, consumerMethodId?: string, providerMethodId?: string);
+    asError(err: any): void;
+    withResponse(response: SimpleResponse): void;
+}
+export declare const networkManager: NetworkManager;
+export {};