@kapeta/local-cluster-service 0.6.1 → 0.7.0

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

package/{src → dist/esm/src}/storageService.js

@@ -1,34 +1,27 @@
-const _ = require('lodash');
-const FS = require('fs');
-const mkdirp = require('mkdirp');
-const YAML = require('yaml');
-const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
-
+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 {
-
+    _data;
     constructor() {
         this._data = this._readConfig();
     }
-
     getKapetaBasedir() {
         return ClusterConfiguration.getKapetaBasedir();
     }
-
     _readConfig() {
         return ClusterConfiguration.getClusterConfig();
     }
-
     _writeConfig() {
         const configFile = ClusterConfiguration.getClusterConfigFile();
-
-        mkdirp.sync(this.getKapetaBasedir());
-
+        FSExtra.mkdirsSync(this.getKapetaBasedir());
         FS.writeFileSync(configFile, YAML.stringify(this._data));
     }
-
     section(section, defaultValue) {
         if (!defaultValue) {
             defaultValue = {};
@@ -37,51 +30,39 @@ class StorageService {
             this._data[section] = defaultValue;
             this._writeConfig();
         }
-
         return this._data[section];
     }
-
     put(section, property, value) {
         if (!_.isString(property)) {
             this._data[section] = property;
             this._writeConfig();
             return;
         }
-
         this.section(section)[property] = value;
         this._writeConfig();
     }
-
     get(section, property) {
         if (!property) {
             return this.section(section);
         }
-
         return this.section(section)[property];
     }
-
     contains(section, property) {
         if (!this._data[section]) {
             return false;
         }
-
         return this._data[section].hasOwnProperty(property);
     }
-
     ensure(section, property, value) {
         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;
     }
 }
-
-module.exports = new StorageService();
+export const storageService = new StorageService();

package/dist/esm/src/traffic/routes.d.ts

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

package/{src → dist/esm/src}/traffic/routes.js

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

package/dist/esm/src/types.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+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;
+export {};

package/dist/esm/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/utils/BlockInstanceRunner.d.ts

@@ -0,0 +1,29 @@
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
+import { KapetaURI } from '@kapeta/nodejs-utils';
+import { AnyMap, BlockProcessParams, ProcessDetails, ProcessInfo, StringMap } from '../types';
+export declare class BlockInstanceRunner {
+    private readonly _systemId;
+    constructor(planReference: string);
+    /**
+     * Start a block
+     *
+     */
+    start(blockRef: string, instanceId: string, configuration: AnyMap): Promise<ProcessInfo>;
+    private _execute;
+    /**
+     * Starts local process
+     */
+    private _startLocalProcess;
+    private _handleContainer;
+    private _startDockerProcess;
+    /**
+     *
+     * @param blockInstance
+     * @param blockUri
+     * @param providerDefinition
+     * @param {{[key:string]:string}} env
+     * @return {Promise<ProcessDetails>}
+     * @private
+     */
+    _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessDetails>;
+}