@kapeta/local-cluster-service 0.6.1 → 0.7.1

package/src/serviceManager.ts

@@ -0,0 +1,120 @@
+import _ from 'lodash';
+import { clusterService } from './clusterService';
+import { storageService } from './storageService';
+import { EnvironmentType } from './types';
+
+const DEFAULT_PORT_TYPE = 'rest';
+
+class ServiceManager {
+    private _systems: any;
+
+    constructor() {
+        this._systems = storageService.get('services');
+        if (!this._systems) {
+            this._systems = {};
+        }
+
+        _.forEach(this._systems, (system) => {
+            _.forEach(system, (services) => {
+                _.forEach(services, (portInfo) => {
+                    clusterService.reservePort(portInfo.port);
+                });
+            });
+        });
+    }
+
+    _forLocal(port: string | number, path?: string, environmentType?: 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.getClusterServiceHost();
+        }
+
+        if (path.startsWith('/')) {
+            path = path.substring(1);
+        }
+        return `http://${host}:${port}/${path}`;
+    }
+
+    _ensureSystem(systemId: string) {
+        if (!this._systems[systemId]) {
+            this._systems[systemId] = {};
+        }
+
+        return this._systems[systemId];
+    }
+
+    _ensureService(systemId: string, serviceId: string) {
+        const system = this._ensureSystem(systemId);
+
+        if (!system[serviceId]) {
+            system[serviceId] = {};
+        }
+
+        return system[serviceId];
+    }
+
+    async ensureServicePort(systemId: string, blockInstanceId: string, portType: string = 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 };
+            this._save();
+        }
+
+        const portTypeSection = service[portType];
+
+        return portTypeSection.port;
+    }
+
+    _save() {
+        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: string,
+        consumerInstanceId: string,
+        consumerResourceName: string,
+        portType: string,
+        environmentType?: EnvironmentType
+    ): string {
+        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
+     *
+     * 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: string, providerInstanceId: string, portType: string): Promise<string> {
+        const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
+        return this._forLocal(port);
+    }
+
+    getServices() {
+        return this._systems;
+    }
+}
+
+export const serviceManager = new ServiceManager();

package/src/socketManager.ts

@@ -0,0 +1,57 @@
+import _ from 'lodash';
+import { Socket, Server } from 'socket.io';
+
+export class SocketManager {
+    private _io: Server | null;
+    private _sockets: Socket[];
+
+    constructor() {
+        this._io = null;
+        this._sockets = [];
+        return this;
+    }
+
+    setIo(io: Server) {
+        console.log('Socket server ready');
+        this._io = io;
+
+        this._bindIO();
+    }
+
+    private get io() {
+        if (!this._io) {
+            throw new Error('Socket server not ready');
+        }
+        return this._io;
+    }
+
+    emit(context: string, type: string, payload: any) {
+        this.io.to(context).emit(type, { context, payload });
+    }
+
+    _bindIO() {
+        this.io.on('connection', (socket) => this._handleSocketCreated(socket));
+    }
+
+    _handleSocketCreated(socket: Socket) {
+        this._bindSocket(socket);
+        this._sockets.push(socket);
+    }
+
+    _bindSocket(socket: 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: Socket) {
+        _.pull(this._sockets, socket);
+    }
+}
+export const socketManager = new SocketManager();

package/src/storageService.ts

@@ -0,0 +1,88 @@
+import _ from 'lodash';
+import FS from 'fs';
+import FSExtra from 'fs-extra';
+import YAML from 'yaml';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+
+/**
+ * Class that handles reading and writing from local configuration file.
+ */
+class StorageService {
+    private _data: { [key: string]: any };
+
+    constructor() {
+        this._data = this._readConfig();
+    }
+
+    getKapetaBasedir() {
+        return ClusterConfiguration.getKapetaBasedir();
+    }
+
+    _readConfig() {
+        return ClusterConfiguration.getClusterConfig();
+    }
+
+    _writeConfig() {
+        const configFile = ClusterConfiguration.getClusterConfigFile();
+
+        FSExtra.mkdirsSync(this.getKapetaBasedir());
+
+        FS.writeFileSync(configFile, YAML.stringify(this._data));
+    }
+
+    section<T = any>(section: string, defaultValue?: any): T {
+        if (!defaultValue) {
+            defaultValue = {};
+        }
+        if (!this._data[section]) {
+            this._data[section] = defaultValue;
+            this._writeConfig();
+        }
+
+        return this._data[section];
+    }
+
+    put(section: string, property: string | any, value?: any) {
+        if (!_.isString(property)) {
+            this._data[section] = property;
+            this._writeConfig();
+            return;
+        }
+
+        this.section(section)[property] = value;
+        this._writeConfig();
+    }
+
+    get(section: string, property?: string): any {
+        if (!property) {
+            return this.section(section);
+        }
+
+        return this.section(section)[property];
+    }
+
+    contains(section: string, property: string) {
+        if (!this._data[section]) {
+            return false;
+        }
+
+        return this._data[section].hasOwnProperty(property);
+    }
+
+    ensure(section: string, property: string, value: any) {
+        if (this.contains(section, property)) {
+            return this.get(section, property);
+        }
+
+        let out = value;
+        if (typeof value === 'function') {
+            out = value();
+        }
+
+        this.put(section, property, out);
+
+        return out;
+    }
+}
+
+export const storageService = new StorageService();

package/src/traffic/routes.ts

@@ -0,0 +1,18 @@
+import Router from 'express-promise-router';
+import { Request, Response } from 'express';
+import { networkManager } from '../networkManager';
+
+const router = Router();
+router.get('/:systemId/target/:connectionId/', (req: Request, res: Response) => {
+    res.send(networkManager.getTrafficForConnection(req.params.systemId, req.params.connectionId));
+});
+
+router.get('/:systemId/source/:blockInstanceId/', (req: Request, res: Response) => {
+    res.send(networkManager.getTrafficForSource(req.params.systemId, req.params.blockInstanceId));
+});
+
+router.get('/:systemId/target/:blockInstanceId/', (req: Request, res: Response) => {
+    res.send(networkManager.getTrafficForTarget(req.params.systemId, req.params.blockInstanceId));
+});
+
+export default router;

package/src/types.ts

@@ -0,0 +1,97 @@
+import EventEmitter from 'events';
+import express from 'express';
+import { Resource } from '@kapeta/schemas';
+import { StringBodyRequest } from './middleware/stringBody';
+import { KapetaRequest } from './middleware/kapeta';
+
+export type StringMap = { [key: string]: string };
+export type AnyMap = { [key: string]: any };
+
+export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE' | 'FATAL';
+export type LogSource = 'stdout' | 'stderr';
+export type EnvironmentType = 'docker' | 'process';
+export interface LogEntry {
+    source: LogSource;
+    level: LogLevel;
+    message: string;
+    time: number;
+}
+
+export interface BlockProcessParams {
+    id: string;
+    ref: string;
+    configuration?: AnyMap;
+}
+
+export type ProcessType = 'docker' | 'local';
+
+export interface ProcessDetails {
+    pid: number | string;
+    type: ProcessType;
+    portType?: string;
+    output: EventEmitter;
+    logs: () => LogEntry[];
+    stop: () => Promise<void> | void;
+}
+
+export interface ProcessInfo extends ProcessDetails {
+    id: string;
+    ref: string;
+    name: string;
+}
+
+export type InstanceInfo = {
+    systemId: string;
+    instanceId: string;
+    address?: string;
+    health?: string | null;
+    status: string;
+    pid?: number | string | null;
+    type: ProcessType;
+    portType?: string;
+};
+
+interface ResourceRef {
+    blockId: string;
+    resourceName: string;
+}
+
+export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
+
+export interface Connection {
+    mapping: any;
+    provider: ResourceRef;
+    consumer: ResourceRef;
+}
+
+export interface OperatorInfo {
+    host: string;
+    port: string;
+    type: string;
+    protocol: string;
+    options: AnyMap;
+    credentials: AnyMap;
+}
+
+export interface ProxyRequestInfo {
+    address: string;
+    connection: Connection;
+    providerResource: Resource;
+    consumerResource: Resource;
+    consumerPath: string;
+}
+
+export interface SimpleResponse {
+    code: number;
+    headers: StringMap;
+    body: any;
+}
+
+export interface SimpleRequest {
+    method: string;
+    url: string;
+    headers: StringMap;
+    body: any;
+}
+
+export type KapetaBodyRequest = KapetaRequest & StringBodyRequest;