@kapeta/local-cluster-service 0.6.0 → 0.7.0

package/dist/cjs/src/proxy/types/rest.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyRestRequest = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const request_1 = __importDefault(require("request"));
+const path_1 = __importDefault(require("path"));
+const pathTemplateParser_1 = require("../../utils/pathTemplateParser");
+const networkManager_1 = require("../../networkManager");
+const socketManager_1 = require("../../socketManager");
+function getRestMethodId(restResource, httpMethod, httpPath) {
+    return lodash_1.default.findKey(restResource.spec.methods, (method) => {
+        let methodType = method.method ? method.method.toUpperCase() : 'GET';
+        if (methodType.toUpperCase() !== httpMethod.toUpperCase()) {
+            return false;
+        }
+        let path = method.path;
+        if (restResource.spec.basePath) {
+            path = path_1.default.join(restResource.spec.basePath, path);
+        }
+        const pathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(path);
+        return pathTemplate.matches(httpPath);
+    });
+}
+/**
+ *
+ * @param req {Request}
+ * @param opts {ProxyRequestInfo}
+ * @return {{consumerMethod: *, providerMethod: *}}
+ */
+function resolveMethods(req, opts) {
+    const consumerMethodId = getRestMethodId(opts.consumerResource, req.method, opts.consumerPath);
+    if (!consumerMethodId) {
+        throw new Error(`Consumer method not found for path "${req.method} ${opts.consumerPath}" in resource "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`);
+    }
+    const consumerMethod = lodash_1.default.cloneDeep(opts.consumerResource.spec.methods[consumerMethodId]);
+    if (!consumerMethod) {
+        throw new Error(`Consumer method not found for path "${req.method} ${opts.consumerPath}" in resource "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`);
+    }
+    consumerMethod.id = consumerMethodId;
+    const providerMethodId = lodash_1.default.findKey(opts.connection.mapping, (mapping) => {
+        return mapping.targetId === consumerMethodId;
+    });
+    if (!providerMethodId) {
+        throw new Error(`Connection contained no mapping for consumer method "${consumerMethodId}`);
+    }
+    const providerMethod = lodash_1.default.cloneDeep(opts.providerResource.spec.methods[providerMethodId]);
+    if (!providerMethod) {
+        throw new Error(`Provider method not found "${providerMethodId}" in resource "${opts.connection.provider.blockId}::${opts.connection.provider.resourceName}`);
+    }
+    providerMethod.id = providerMethodId;
+    return {
+        consumerMethod,
+        providerMethod,
+    };
+}
+function proxyRestRequest(req, res, opts) {
+    let { consumerMethod, providerMethod } = resolveMethods(req, opts);
+    const consumerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(consumerMethod.path);
+    const providerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(providerMethod.path);
+    const pathVariables = consumerPathTemplate.parse(opts.consumerPath);
+    if (!pathVariables) {
+        res.status(400).send({
+            error: `Path did not match any patterns: "${opts.consumerPath}"`,
+        });
+        return;
+    }
+    let providerPath = providerPathTemplate.create(pathVariables);
+    if (!providerPath.startsWith('/')) {
+        providerPath = '/' + providerPath;
+    }
+    const requestHeaders = lodash_1.default.clone(req.headers);
+    delete requestHeaders['content-length'];
+    delete requestHeaders['content-encoding'];
+    delete requestHeaders['connection'];
+    delete requestHeaders['host'];
+    delete requestHeaders['origin'];
+    console.log('Proxy request to provider: %s => %s [rest]', opts.consumerPath, opts.address + providerPath);
+    const reqOpts = {
+        method: providerMethod.method || 'GET',
+        url: opts.address + providerPath,
+        body: req.stringBody,
+        headers: requestHeaders,
+    };
+    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, reqOpts, consumerMethod.id, providerMethod.id);
+    socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    (0, request_1.default)(reqOpts, function (err, response, responseBody) {
+        if (err) {
+            traffic.asError(err);
+            socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+            res.status(500).send({ error: '' + err });
+            return;
+        }
+        const responseHeaders = lodash_1.default.clone(response.headers);
+        delete responseHeaders['content-length'];
+        delete responseHeaders['content-encoding'];
+        delete responseHeaders['connection'];
+        res.set(responseHeaders);
+        res.status(response.statusCode);
+        traffic.withResponse({
+            code: response.statusCode,
+            headers: response.headers,
+            body: responseBody,
+        });
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        if (responseBody) {
+            res.write(responseBody);
+        }
+        res.end();
+    });
+}
+exports.proxyRestRequest = proxyRestRequest;

package/dist/cjs/src/proxy/types/web.d.ts

@@ -0,0 +1,4 @@
+import { Response } from 'express';
+import { ProxyRequestInfo } from '../../types';
+import { StringBodyRequest } from '../../middleware/stringBody';
+export declare function proxyWebRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo): void;

package/dist/cjs/src/proxy/types/web.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyWebRequest = void 0;
+const request_1 = __importDefault(require("request"));
+const lodash_1 = __importDefault(require("lodash"));
+const networkManager_1 = require("../../networkManager");
+const socketManager_1 = require("../../socketManager");
+function proxyWebRequest(req, res, opts) {
+    const requestHeaders = lodash_1.default.clone(req.headers);
+    delete requestHeaders['content-length'];
+    delete requestHeaders['content-encoding'];
+    delete requestHeaders['connection'];
+    delete requestHeaders['host'];
+    delete requestHeaders['origin'];
+    const sourceBasePath = opts.consumerResource.spec.path;
+    const targetBasePath = opts.providerResource.spec.path;
+    let path = opts.consumerPath;
+    if (opts.consumerPath.startsWith(sourceBasePath)) {
+        path = path.replace(sourceBasePath, targetBasePath);
+    }
+    console.log('Proxy request to provider: %s => %s%s [web]', opts.consumerPath, opts.address, path);
+    const reqOpts = {
+        method: req.method,
+        url: opts.address + path,
+        headers: requestHeaders,
+        body: req.stringBody,
+    };
+    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, reqOpts);
+    socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    const proxyReq = (0, request_1.default)(reqOpts);
+    proxyReq.on('error', function (err) {
+        traffic.asError(err);
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        if (!res.headersSent) {
+            res.status(500).send({ error: '' + err });
+        }
+    });
+    proxyReq.on('response', function (response) {
+        //TODO: Include the response body in the traffic object when it is not a stream
+        traffic.withResponse({
+            code: response.statusCode,
+            headers: response.headers,
+            body: null,
+        });
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+    });
+    //We need to pipe the proxy response to the client response to handle sockets and event streams
+    proxyReq.pipe(res);
+}
+exports.proxyWebRequest = proxyWebRequest;

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

@@ -0,0 +1,17 @@
+declare class RepositoryManager {
+    private changeEventsEnabled;
+    private _registryService;
+    private _cache;
+    private watcher?;
+    private _installQueue;
+    private _processing;
+    constructor();
+    setChangeEventsEnabled(enabled: boolean): void;
+    listenForChanges(): void;
+    stopListening(): void;
+    private _install;
+    _processNext(): Promise<void>;
+    ensureAsset(handle: string, name: string, version: string): Promise<void>;
+}
+export declare const repositoryManager: RepositoryManager;
+export {};

package/dist/cjs/src/repositoryManager.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repositoryManager = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const socketManager_1 = require("./socketManager");
+const progressListener_1 = require("./progressListener");
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const INSTALL_ATTEMPTED = {};
+class RepositoryManager {
+    changeEventsEnabled;
+    _registryService;
+    _cache;
+    watcher;
+    _installQueue;
+    _processing = false;
+    constructor() {
+        this.changeEventsEnabled = true;
+        this.listenForChanges();
+        this._registryService = new nodejs_registry_utils_1.RegistryService(nodejs_registry_utils_1.Config.data.registry.url);
+        this._cache = {};
+        this._installQueue = [];
+    }
+    setChangeEventsEnabled(enabled) {
+        this.changeEventsEnabled = enabled;
+    }
+    listenForChanges() {
+        const baseDir = local_cluster_config_1.default.getRepositoryBasedir();
+        if (!node_fs_1.default.existsSync(baseDir)) {
+            fs_extra_1.default.mkdirpSync(baseDir);
+        }
+        let allDefinitions = local_cluster_config_1.default.getDefinitions();
+        console.log('Watching local repository for provider changes: %s', baseDir);
+        try {
+            this.watcher = node_fs_1.default.watch(baseDir, { recursive: true });
+        }
+        catch (e) {
+            // Fallback to run without watch mode due to potential platform issues.
+            // https://nodejs.org/docs/latest/api/fs.html#caveats
+            console.log('Unable to watch for changes. Changes to assets will not update automatically.');
+            return;
+        }
+        this.watcher.on('change', (eventType, filename) => {
+            const [handle, name, version] = filename.toString().split(/\//g);
+            if (!name || !version) {
+                return;
+            }
+            if (!this.changeEventsEnabled) {
+                return;
+            }
+            const ymlPath = node_path_1.default.join(baseDir, handle, name, version, 'kapeta.yml');
+            const newDefinitions = local_cluster_config_1.default.getDefinitions();
+            const newDefinition = newDefinitions.find((d) => d.ymlPath === ymlPath);
+            let currentDefinition = allDefinitions.find((d) => d.ymlPath === ymlPath);
+            const ymlExists = node_fs_1.default.existsSync(ymlPath);
+            let type;
+            if (ymlExists) {
+                if (currentDefinition) {
+                    type = 'updated';
+                }
+                else if (newDefinition) {
+                    type = 'added';
+                    currentDefinition = newDefinition;
+                }
+                else {
+                    //Other definition was added / updated - ignore
+                    return;
+                }
+            }
+            else {
+                if (currentDefinition) {
+                    const ref = (0, nodejs_utils_1.parseKapetaUri)(`${currentDefinition.definition.metadata.name}:${currentDefinition.version}`).id;
+                    delete INSTALL_ATTEMPTED[ref];
+                    //Something was removed
+                    type = 'removed';
+                }
+                else {
+                    //Other definition was removed - ignore
+                    return;
+                }
+            }
+            const payload = {
+                type,
+                definition: currentDefinition?.definition,
+                asset: { handle, name, version },
+            };
+            allDefinitions = newDefinitions;
+            socketManager_1.socketManager.emit(`assets`, 'changed', payload);
+        });
+    }
+    stopListening() {
+        if (!this.watcher) {
+            return;
+        }
+        this.watcher.close();
+        this.watcher = undefined;
+    }
+    async _install(refs) {
+        //We make sure to only install one asset at a time - otherwise unexpected things might happen
+        const out = new Promise((resolve, reject) => {
+            this._installQueue.push(async () => {
+                try {
+                    const normalizedRefs = refs.map((ref) => (0, nodejs_utils_1.parseKapetaUri)(ref).id);
+                    const filteredRefs = normalizedRefs.filter((ref) => !INSTALL_ATTEMPTED[ref]);
+                    console.log(filteredRefs);
+                    if (filteredRefs.length > 0) {
+                        filteredRefs.forEach((ref) => (INSTALL_ATTEMPTED[ref] = true));
+                        //Auto-install missing asset
+                        try {
+                            //We change to a temp dir to avoid issues with the current working directory
+                            process.chdir(node_os_1.default.tmpdir());
+                            //Disable change events while installing
+                            this.setChangeEventsEnabled(false);
+                            socketManager_1.socketManager.emit(`install`, 'install:action', {
+                                type: 'start',
+                                refs,
+                            });
+                            await nodejs_registry_utils_1.Actions.install(progressListener_1.progressListener, normalizedRefs, {});
+                            socketManager_1.socketManager.emit(`install`, 'install:action', {
+                                type: 'done',
+                                refs,
+                            });
+                        }
+                        catch (e) {
+                            socketManager_1.socketManager.emit(`install`, 'install:action', {
+                                type: 'failed',
+                                refs,
+                                error: e.message,
+                            });
+                        }
+                        finally {
+                            this.setChangeEventsEnabled(true);
+                        }
+                    }
+                    resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+                finally {
+                    this._processNext().catch((e) => console.error(e));
+                }
+            });
+        });
+        this._processNext().catch((e) => console.error(e));
+        return out;
+    }
+    async _processNext() {
+        if (this._processing) {
+            return;
+        }
+        this._processing = true;
+        try {
+            while (this._installQueue.length > 0) {
+                const item = this._installQueue.shift();
+                if (item) {
+                    await item();
+                }
+            }
+        }
+        finally {
+            this._processing = false;
+        }
+    }
+    async ensureAsset(handle, name, version) {
+        const fullName = `${handle}/${name}`;
+        const ref = `${fullName}:${version}`;
+        if (version === 'local') {
+            //TODO: Get dependencies for local asset
+            return;
+        }
+        const definitions = local_cluster_config_1.default.getDefinitions();
+        const installedAsset = definitions.find((d) => d.definition.metadata.name === fullName && d.version === version);
+        if (installedAsset && this._cache[ref] === true) {
+            return;
+        }
+        if (!installedAsset && this._cache[ref] === false) {
+            return;
+        }
+        let assetVersion;
+        try {
+            assetVersion = await this._registryService.getVersion(fullName, version);
+            if (!assetVersion) {
+                this._cache[ref] = false;
+                return;
+            }
+        }
+        catch (e) {
+            console.warn(`Unable to resolve asset: ${ref}`, e);
+            if (installedAsset) {
+                return;
+            }
+            throw e;
+        }
+        this._cache[ref] = true;
+        if (!installedAsset) {
+            console.log(`Auto-installing missing asset: ${ref}`);
+            await this._install([ref]);
+        }
+        else {
+            //Ensure dependencies are installed
+            const refs = assetVersion.dependencies.map((dep) => dep.name);
+            console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
+            await this._install(refs);
+        }
+    }
+}
+exports.repositoryManager = new RepositoryManager();

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

@@ -0,0 +1,29 @@
+import { EnvironmentType } from './types';
+declare class ServiceManager {
+    private _systems;
+    constructor();
+    _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType): string;
+    _ensureSystem(systemId: string): any;
+    _ensureService(systemId: string, serviceId: string): any;
+    ensureServicePort(systemId: string, blockInstanceId: string, portType?: string): Promise<any>;
+    _save(): void;
+    /**
+     * Gets the consumable address of a service block resource
+     *
+     * This returns a local proxy path to allow traffic inspection and control.
+     *
+     */
+    getConsumerAddress(systemId: string, consumerInstanceId: string, consumerResourceName: string, portType: string, environmentType?: EnvironmentType): string;
+    /**
+     * 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.
+     *
+     */
+    getProviderAddress(systemId: string, providerInstanceId: string, portType: string): Promise<string>;
+    getServices(): any;
+}
+export declare const serviceManager: ServiceManager;
+export {};

package/dist/cjs/src/serviceManager.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceManager = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const clusterService_1 = require("./clusterService");
+const storageService_1 = require("./storageService");
+const DEFAULT_PORT_TYPE = 'rest';
+class ServiceManager {
+    _systems;
+    constructor() {
+        this._systems = storageService_1.storageService.get('services');
+        if (!this._systems) {
+            this._systems = {};
+        }
+        lodash_1.default.forEach(this._systems, (system) => {
+            lodash_1.default.forEach(system, (services) => {
+                lodash_1.default.forEach(services, (portInfo) => {
+                    clusterService_1.clusterService.reservePort(portInfo.port);
+                });
+            });
+        });
+    }
+    _forLocal(port, path, environmentType) {
+        if (!path) {
+            path = '';
+        }
+        let host;
+        if (environmentType === 'docker') {
+            //We're inside a docker container, so we can use this special host name to access the host machine
+            host = 'host.docker.internal';
+        }
+        else {
+            host = clusterService_1.clusterService.getClusterServiceHost();
+        }
+        if (path.startsWith('/')) {
+            path = path.substring(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 = DEFAULT_PORT_TYPE) {
+        if (!portType) {
+            portType = DEFAULT_PORT_TYPE;
+        }
+        const service = this._ensureService(systemId, blockInstanceId);
+        if (!service[portType]) {
+            const port = await clusterService_1.clusterService.getNextAvailablePort();
+            service[portType] = { port };
+            this._save();
+        }
+        const portTypeSection = service[portType];
+        return portTypeSection.port;
+    }
+    _save() {
+        storageService_1.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.
+     *
+     */
+    getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
+        const port = clusterService_1.clusterService.getClusterServicePort();
+        const path = clusterService_1.clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
+        return this._forLocal(port, path, environmentType);
+    }
+    /**
+     * 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.
+     *
+     */
+    async getProviderAddress(systemId, providerInstanceId, portType) {
+        const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
+        return this._forLocal(port);
+    }
+    getServices() {
+        return this._systems;
+    }
+}
+exports.serviceManager = new ServiceManager();

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

@@ -0,0 +1,14 @@
+import { Socket, Server } from 'socket.io';
+export declare class SocketManager {
+    private _io;
+    private _sockets;
+    constructor();
+    setIo(io: Server): void;
+    private get io();
+    emit(context: string, type: string, payload: any): void;
+    _bindIO(): void;
+    _handleSocketCreated(socket: Socket): void;
+    _bindSocket(socket: Socket): void;
+    _handleSocketDestroyed(socket: Socket): void;
+}
+export declare const socketManager: SocketManager;

package/dist/cjs/src/socketManager.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socketManager = exports.SocketManager = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+class SocketManager {
+    _io;
+    _sockets;
+    constructor() {
+        this._io = null;
+        this._sockets = [];
+        return this;
+    }
+    setIo(io) {
+        console.log('Socket server ready');
+        this._io = io;
+        this._bindIO();
+    }
+    get io() {
+        if (!this._io) {
+            throw new Error('Socket server not ready');
+        }
+        return this._io;
+    }
+    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) {
+        lodash_1.default.pull(this._sockets, socket);
+    }
+}
+exports.SocketManager = SocketManager;
+exports.socketManager = new SocketManager();

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

@@ -0,0 +1,17 @@
+/**
+ * Class that handles reading and writing from local configuration file.
+ */
+declare class StorageService {
+    private _data;
+    constructor();
+    getKapetaBasedir(): string;
+    _readConfig(): import("@kapeta/local-cluster-config").ClusterConfig;
+    _writeConfig(): void;
+    section<T = any>(section: string, defaultValue?: any): T;
+    put(section: string, property: string | any, value?: any): void;
+    get(section: string, property?: string): any;
+    contains(section: string, property: string): any;
+    ensure(section: string, property: string, value: any): any;
+}
+export declare const storageService: StorageService;
+export {};