@kumologica/sdk 3.2.0-beta9 → 4.0.0-alpha2

package/src/api/core/settings.js

@@ -0,0 +1,287 @@
+/**
+ * @mixin @kumologica-core/runtime_settings
+ */
+
+var util = require('util');
+var runtime;
+
+function extend(target, source) {
+  var keys = Object.keys(source);
+  var i = keys.length;
+  while (i--) {
+    var value = source[keys[i]];
+    var type = typeof value;
+    if (
+      type === 'string' ||
+      type === 'number' ||
+      type === 'boolean' ||
+      Array.isArray(value)
+    ) {
+      target[keys[i]] = value;
+    } else if (value === null) {
+      if (target.hasOwnProperty(keys[i])) {
+        delete target[keys[i]];
+      }
+    } else {
+      // Object
+      if (target.hasOwnProperty(keys[i])) {
+        target[keys[i]] = extend(target[keys[i]], value);
+      } else {
+        target[keys[i]] = value;
+      }
+    }
+  }
+  return target;
+}
+
+function getSSHKeyUsername(userObj) {
+  var username = '__default';
+  if (userObj && userObj.username) {
+    username = userObj.username;
+  }
+  return username;
+}
+var api = (module.exports = {
+  init: function (_runtime) {
+    runtime = _runtime;
+  },
+  // Read a particular key from the runtime settings - unsafe call (?)
+  get: function (key) {
+    return runtime.settings[key];
+  },
+  /**
+   * Gets the runtime settings object
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Object>} - the runtime settings
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getRuntimeSettings: function (opts) {
+    return new Promise(function (resolve, reject) {
+      try {
+        var safeSettings = {
+          httpNodeRoot: runtime.settings.httpNodeRoot || '/',
+          version: runtime.settings.version,
+          userDir: runtime.settings.userDir,
+        };
+        if (opts && opts.user) {
+          safeSettings.user = {};
+          var props = ['anonymous', 'username', 'image', 'permissions'];
+          props.forEach((prop) => {
+            if (opts.user.hasOwnProperty(prop)) {
+              safeSettings.user[prop] = opts.user[prop];
+            }
+          });
+        }
+
+        safeSettings.context = runtime.nodes.listContextStores();
+
+        if (util.isArray(runtime.settings.paletteCategories)) {
+          safeSettings.paletteCategories = runtime.settings.paletteCategories;
+        }
+
+        if (runtime.settings.flowFilePretty) {
+          safeSettings.flowFilePretty = runtime.settings.flowFilePretty;
+        }
+
+        if (!runtime.nodes.paletteEditorEnabled()) {
+          safeSettings.editorTheme = safeSettings.editorTheme || {};
+          safeSettings.editorTheme.palette =
+            safeSettings.editorTheme.palette || {};
+          safeSettings.editorTheme.palette.editable = false;
+        }
+        if (runtime.storage.projects) {
+          var activeProject = runtime.storage.projects.getActiveProject();
+          if (activeProject) {
+            safeSettings.project = activeProject;
+          } else if (runtime.storage.projects.flowFileExists()) {
+            safeSettings.files = {
+              flow: runtime.storage.projects.getFlowFilename(),
+              credentials: runtime.storage.projects.getCredentialsFilename(),
+            };
+          }
+          safeSettings.git = {
+            globalUser: runtime.storage.projects.getGlobalGitUser(),
+          };
+        }
+
+        safeSettings.flowEncryptionType = runtime.nodes.getCredentialKeyType();
+
+        runtime.settings.exportNodeSettings(safeSettings);
+
+        resolve(safeSettings);
+      } catch (err) {
+        console.log(err);
+      }
+    });
+  },
+
+  /**
+   * Gets an individual user's settings object
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Object>} - the user settings
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getUserSettings: function (opts) {
+    opts = opts || {};
+    var username;
+    if (!opts.user || opts.user.anonymous) {
+      username = '_';
+    } else {
+      username = opts.user.username;
+    }
+    return Promise.resolve(runtime.settings.getUserSettings(username) || {});
+  },
+
+  /**
+   * Updates an individual user's settings object.
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {Object} opts.settings - the updates to the user settings
+   * @return {Promise<Object>} - the user settings
+   * @memberof @kumologica-core/runtime_settings
+   */
+  updateUserSettings: function (opts) {
+    var username;
+    if (!opts.user || opts.user.anonymous) {
+      username = '_';
+    } else {
+      username = opts.user.username;
+    }
+    return new Promise(function (resolve, reject) {
+      var currentSettings = runtime.settings.getUserSettings(username) || {};
+      currentSettings = extend(currentSettings, opts.settings);
+      try {
+        runtime.settings
+          .setUserSettings(username, currentSettings)
+          .then(function () {
+            runtime.log.audit({ event: 'settings.update', username: username });
+            return resolve();
+          })
+          .catch(function (err) {
+            runtime.log.audit({
+              event: 'settings.update',
+              username: username,
+              error: err.code || 'unexpected_error',
+              message: err.toString(),
+            });
+            err.status = 400;
+            return reject(err);
+          });
+      } catch (err) {
+        runtime.log.warn(`Cannot save user settings: ${err.toString()}`);
+        runtime.log.audit({
+          event: 'settings.update',
+          username: username,
+          error: err.code || 'unexpected_error',
+          message: err.toString(),
+        });
+        err.status = 400;
+        return reject(err);
+      }
+    });
+  },
+
+  /**
+   * Gets a list of a user's ssh keys
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Object>} - the user's ssh keys
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getUserKeys: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      runtime.storage.projects.ssh
+        .listSSHKeys(username)
+        .then(function (list) {
+          return resolve(list);
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Gets a user's ssh public key
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {User} opts.id - the id of the key to return
+   * @return {Promise<String>} - the user's ssh public key
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getUserKey: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      // console.log('username:', username);
+      runtime.storage.projects.ssh
+        .getSSHKey(username, opts.id)
+        .then(function (data) {
+          if (data) {
+            return resolve(data);
+          } else {
+            var err = new Error('Key not found');
+            err.code = 'not_found';
+            err.status = 404;
+            return reject(err);
+          }
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Generates a new ssh key pair
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {User} opts.name - the id of the key to return
+   * @param {User} opts.password - (optional) the password for the key pair
+   * @param {User} opts.comment - (option) a comment to associate with the key pair
+   * @param {User} opts.size - (optional) the size of the key. Default: 2048
+   * @return {Promise<String>} - the id of the generated key
+   * @memberof @kumologica-core/runtime_settings
+   */
+  generateUserKey: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      runtime.storage.projects.ssh
+        .generateSSHKey(username, opts)
+        .then(function (name) {
+          return resolve(name);
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Deletes a user's ssh key pair
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {User} opts.id - the id of the key to delete
+   * @return {Promise} - resolves when deleted
+   * @memberof @kumologica-core/runtime_settings
+   */
+  removeUserKey: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      runtime.storage.projects.ssh
+        .deleteSSHKey(username, opts.id)
+        .then(function () {
+          return resolve();
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+});

package/src/api/tools/base/DesignerTool.js

@@ -0,0 +1,108 @@
+
+class DesignerTool {
+    constructor(designServer) {
+        this.designServer = designServer;
+        this.adminApp = designServer.getAdminServer(); // TODO: remove
+        this.flowServer = designServer.getFlowServer();
+
+        this.runtimeEventEmitter = this.flowServer.events;
+    }
+
+    getRuntimePlugin(pluginName) {
+        return this.flowServer.runtime.pluginRegistry.getPlugin(pluginName);
+    }
+
+    isRuntimePluginInstalled(pluginName) {
+        return this.getRuntimePlugin(pluginName) ? true : false;
+    }
+
+    // ================================
+    // WebSocket communication with SDK
+    // ================================
+
+    /**
+     * This method will be used by all the tools within the `install` method in order to register a websocket tool
+     * that will respond to each `eventType` request.
+     * @param {string} eventType 
+     * @param {function(string): {type: string, payload?: object}} action 
+    */
+    addEventHandler(eventType, action) {
+        this.designServer.registerEvent(eventType, action);
+    }
+
+    /**
+     * Sends an event over WebSocket back to the client.
+     * If you use this method instead of sendResponse, ensure to follow the naming convention used for responses: `{eventType}:response`
+     * @param {WebSocket} ws - The WebSocket connection.
+     * @param {string} eventType - The type of event to send.
+     * @param {object} payload - The payload data to send with the event.
+     */
+    sendEvent(ws, eventType, payload) {
+        let response = {
+            type: eventType,
+            payload
+        };
+        ws.send(JSON.stringify(response));
+    }
+
+    /**
+     * Sends a response event over WebSocket back to the client
+     * @param {WebSocket} ws - The WebSocket connection.
+     * @param {string} eventType - The type of event to send as a response.
+     * @param {object} payload - The payload data to send with the response.
+     */
+    sendResponse(ws, eventType, payload) {
+        this.sendEvent(ws, `${eventType}:response`, payload);
+    }
+
+    /**
+     * Sends an error event over WebSocket back to the client
+     * @param {WebSocket} ws - The WebSocket connection.
+     * @param {string} eventType - The type of event to send as an error.
+     * @param {Error} err - The error object to send with the error event.
+     */
+    sendError(ws, eventType, err) {
+        this.sendEvent(ws, `${eventType}:error`, { reason: err });
+    }
+
+    // ================================
+    // Communication with Runtime
+    // ================================
+
+    /**
+     * Use these two methods to subscribe to events emitted by a runtime plugin
+     * Remember that whenever you subscribe you will have to unsubscribe it when you are done
+     * otherwise, events will come duplicated.
+     * 
+     * @param {*} listener 
+     */
+    subscribeRuntimeListener(listener) {
+        this.runtimeEventEmitter.on('runtime-event', listener);
+    }
+    clearRuntimeListener(listener) {
+        this.runtimeEventEmitter.off('runtime-event', listener);
+    }
+
+    /**
+     * Use this method to invoke a command to a runtime plugin.
+     * - Plugin must extends the class `Plugin`
+     * - Communication will be done direct call to the object
+     * 
+     * @param {string} pluginName 
+     * @param {string} command 
+     * @param {*} params  - optional 
+     */
+    sendCommandToPlugin(pluginName, command, params) {
+        let plugin = this.getRuntimePlugin(pluginName);
+        if (plugin) {
+            plugin.handleCommand(command, params);
+        } else {
+            throw new Error(`Plugin not found: ${pluginName}`);
+        }
+    }
+
+}
+
+module.exports = {
+    DesignerTool
+}

package/src/api/tools/core/flow.js

@@ -0,0 +1,58 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+class CoreFlowTool extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        /**
+         * { type: 'test:run',
+         *   payload: { testcaseid: '123432.34343'} }
+         */
+        this.addEventHandler('flow:getFlow', this.getFlowAction('flow:getFlow'));
+        this.addEventHandler('flow:deployFlow', this.deployFlowAction('flow:deployFlow'));
+        this.addEventHandler('flow:reloadFlow', this.reloadFlowAction('flow:reloadFlow'));
+
+    }
+    getFlowAction(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.getFlows()
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+    deployFlowAction(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.setFlows(payload, 'full');
+                this.sendResponse(ws, eventType, {});
+
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+    reloadFlowAction(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.loadFlows(true);
+                this.sendResponse(ws, eventType, {});
+
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+
+}
+
+
+module.exports = {
+    CoreFlowTool
+}

package/src/api/tools/core/index.js

@@ -0,0 +1,18 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+const { CoreFlowTool } = require('./flow');
+const { CoreNodeTool } = require('./node');
+
+class CoreTools extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        new CoreFlowTool(this.designServer).install();
+        new CoreNodeTool(this.designServer).install();
+    }
+}
+
+module.exports = {
+    CoreTools
+}

package/src/api/tools/core/node.js

@@ -0,0 +1,77 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+class CoreNodeTool extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        /**
+         * { type: 'test:run',
+         *   payload: { testcaseid: '123432.34343'} }
+         */
+        this.addEventHandler('node:getAllNodes', this.getAllNodes('node:getAllNodes'));
+        this.addEventHandler('node:getAllInstalledTypes', this.getAllInstalledTypes('node:getAllInstalledTypes'));
+
+    }
+    /**
+     *
+     * @param {*} eventType
+     * @returns
+     * {
+    "type": "node:getAllNodes:response",
+    "payload": [
+        {
+            "id": "kumologica-core/sftp",
+            "name": "sftp",
+            "types": [
+                "SFTP"
+            ],
+            "enabled": true,
+            "local": false,
+            "module": "kumologica-core",
+            "version": "3.2.0-beta6"
+        },
+        {
+            "id": "kumologica-core/Rekognition",
+            "name": "Rekognition",
+            "types": [
+                "Rekognition"
+            ],
+            "enabled": true,
+            "local": false,
+            "module": "kumologica-core",
+            "version": "3.2.0-beta6"
+        }, ...  ]
+     */
+    getAllNodes(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.getNodeList();
+                // console.log(this.flowServer.runtime._.nodes.getNodeConfigs());
+                // console.log(this.flowServer.runtime._.nodes.getNodeConfig('kumologica-core/sftp'));
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+
+    getAllInstalledTypes(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.getNodeConfigs();
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+
+}
+
+
+module.exports = {
+    CoreNodeTool
+}
+1