@kapeta/local-cluster-service 0.6.1 → 0.7.0

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

@@ -0,0 +1,107 @@
+import _ from 'lodash';
+import request from 'request';
+import Path from 'path';
+import { pathTemplateParser } from '../../utils/pathTemplateParser';
+import { networkManager } from '../../networkManager';
+import { socketManager } from '../../socketManager';
+function getRestMethodId(restResource, httpMethod, httpPath) {
+    return _.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.join(restResource.spec.basePath, path);
+        }
+        const pathTemplate = 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 = _.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 = _.findKey(opts.connection.mapping, (mapping) => {
+        return mapping.targetId === consumerMethodId;
+    });
+    if (!providerMethodId) {
+        throw new Error(`Connection contained no mapping for consumer method "${consumerMethodId}`);
+    }
+    const providerMethod = _.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,
+    };
+}
+export function proxyRestRequest(req, res, opts) {
+    let { consumerMethod, providerMethod } = resolveMethods(req, opts);
+    const consumerPathTemplate = pathTemplateParser(consumerMethod.path);
+    const providerPathTemplate = 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 = _.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.addRequest(req.params.systemId, opts.connection, reqOpts, consumerMethod.id, providerMethod.id);
+    socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    request(reqOpts, function (err, response, responseBody) {
+        if (err) {
+            traffic.asError(err);
+            socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+            res.status(500).send({ error: '' + err });
+            return;
+        }
+        const responseHeaders = _.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.emit(traffic.connectionId, 'traffic_end', traffic);
+        if (responseBody) {
+            res.write(responseBody);
+        }
+        res.end();
+    });
+}

package/dist/esm/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/{src → dist/esm/src}/proxy/types/web.js

@@ -1,68 +1,46 @@
-const request = require('request');
-const _ = require('lodash');
-
-const networkManager = require('../../networkManager');
-const socketManager = require('../../socketManager');
-
-/**
- *
- * @param req {Request}
- * @param res {Response}
- * @param opts {ProxyRequestInfo}
- */
-module.exports = function proxyWebRequest(req, res, opts) {
-
+import request from 'request';
+import _ from 'lodash';
+import { networkManager } from '../../networkManager';
+import { socketManager } from '../../socketManager';
+export function proxyWebRequest(req, res, opts) {
     const requestHeaders = _.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
+        body: req.stringBody,
     };
-
-    const traffic = networkManager.addRequest(
-        req.params.systemId,
-        opts.connection,
-        reqOpts
-    );
-
+    const traffic = networkManager.addRequest(req.params.systemId, opts.connection, reqOpts);
     socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
     const proxyReq = request(reqOpts);
-
-    proxyReq.on('error', function(err) {
+    proxyReq.on('error', function (err) {
         traffic.asError(err);
         socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
         if (!res.headersSent) {
-            res.status(500).send({error: '' + err});
+            res.status(500).send({ error: '' + err });
         }
     });
-
-    proxyReq.on('response', function(response) {
+    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
+            headers: response.headers,
+            body: null,
         });
-
         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);
-};
+}

package/dist/esm/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/esm/src/repositoryManager.js

@@ -0,0 +1,209 @@
+import FS from 'node:fs';
+import os from 'node:os';
+import Path from 'node:path';
+import FSExtra from 'fs-extra';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { socketManager } from './socketManager';
+import { progressListener } from './progressListener';
+import { Actions, Config, RegistryService } from '@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 RegistryService(Config.data.registry.url);
+        this._cache = {};
+        this._installQueue = [];
+    }
+    setChangeEventsEnabled(enabled) {
+        this.changeEventsEnabled = enabled;
+    }
+    listenForChanges() {
+        const baseDir = ClusterConfiguration.getRepositoryBasedir();
+        if (!FS.existsSync(baseDir)) {
+            FSExtra.mkdirpSync(baseDir);
+        }
+        let allDefinitions = ClusterConfiguration.getDefinitions();
+        console.log('Watching local repository for provider changes: %s', baseDir);
+        try {
+            this.watcher = FS.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 = Path.join(baseDir, handle, name, version, 'kapeta.yml');
+            const newDefinitions = ClusterConfiguration.getDefinitions();
+            const newDefinition = newDefinitions.find((d) => d.ymlPath === ymlPath);
+            let currentDefinition = allDefinitions.find((d) => d.ymlPath === ymlPath);
+            const ymlExists = FS.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 = 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.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) => 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(os.tmpdir());
+                            //Disable change events while installing
+                            this.setChangeEventsEnabled(false);
+                            socketManager.emit(`install`, 'install:action', {
+                                type: 'start',
+                                refs,
+                            });
+                            await Actions.install(progressListener, normalizedRefs, {});
+                            socketManager.emit(`install`, 'install:action', {
+                                type: 'done',
+                                refs,
+                            });
+                        }
+                        catch (e) {
+                            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 = ClusterConfiguration.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);
+        }
+    }
+}
+export const repositoryManager = new RepositoryManager();

package/dist/esm/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/{src → dist/esm/src}/serviceManager.js

@@ -1,17 +1,14 @@
-const clusterService = require('./clusterService');
-const storageService = require('./storageService');
-const _ = require('lodash');
-
+import _ from 'lodash';
+import { clusterService } from './clusterService';
+import { storageService } from './storageService';
 const DEFAULT_PORT_TYPE = 'rest';
-
 class ServiceManager {
-
+    _systems;
     constructor() {
-        this._systems = storageService.get("services");
+        this._systems = storageService.get('services');
         if (!this._systems) {
             this._systems = {};
         }
-
         _.forEach(this._systems, (system) => {
             _.forEach(system, (services) => {
                 _.forEach(services, (portInfo) => {
@@ -20,7 +17,6 @@ class ServiceManager {
             });
         });
     }
-
     _forLocal(port, path, environmentType) {
         if (!path) {
             path = '';
@@ -29,75 +25,55 @@ class ServiceManager {
         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 {
+        }
+        else {
             host = 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) {
+    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.getNextAvailablePort();
-            service[portType] = {port};
+            service[portType] = { port };
             this._save();
         }
-
         const portTypeSection = service[portType];
-
         return portTypeSection.port;
     }
-
     _save() {
-        storageService.put("services", this._systems);
+        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.
      *
-     * @param {string} systemId
-     * @param {string} consumerInstanceId
-     * @param {string} consumerResourceName
-     * @param {string} portType
-     * @param {'docker'|'process'} environmentType
-     * @return {string}
      */
     getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
         const port = clusterService.getClusterServicePort();
         const path = clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
         return this._forLocal(port, path, environmentType);
     }
-
     /**
      * Gets the direct address of a service block
      *
@@ -105,19 +81,13 @@ class ServiceManager {
      * For local services this address will be on localhost - for remote services it will
      * be their remotely available address.
      *
-     * @param {string} systemId
-     * @param {string} providerInstanceId
-     * @param {string} portType
-     * @return {Promise<string>}
      */
     async getProviderAddress(systemId, providerInstanceId, portType) {
         const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
-        return this._forLocal(port)
+        return this._forLocal(port);
     }
-
     getServices() {
         return this._systems;
     }
 }
-
-module.exports = new ServiceManager();
+export const serviceManager = new ServiceManager();

package/dist/esm/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/{src → dist/esm/src}/socketManager.js

@@ -1,50 +1,46 @@
-const _ = require('lodash');
-
-class SocketManager {
-
+import _ from 'lodash';
+export class SocketManager {
+    _io;
+    _sockets;
     constructor() {
         this._io = null;
         this._sockets = [];
         return this;
     }
-
     setIo(io) {
-        console.log("socket ready");
+        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});
+        this.io.to(context).emit(type, { context, payload });
     }
-
     _bindIO() {
-        this._io.on('connection', (socket) => this._handleSocketCreated(socket))
+        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('disconnect', () => this._handleSocketDestroyed(socket));
         socket.on('join', (id) => {
-            console.log("socket joined ", id);
+            console.log('socket joined ', id);
             socket.join(id);
-        })
+        });
         socket.on('leave', (id) => {
-            console.log("socket left ", id);
+            console.log('socket left ', id);
             socket.leave(id);
-        })
+        });
     }
-
     _handleSocketDestroyed(socket) {
         _.pull(this._sockets, socket);
     }
-
 }
-
-
-module.exports = new SocketManager();
+export const socketManager = new SocketManager();