@kumologica/sdk 3.0.0-alpha4

package/src/api/core/comms.js

@@ -0,0 +1,141 @@
+ 
+ 
+/**
+ * This is the comms subsystem of the runtime.
+ * @mixin @kumologica-core/runtime_comms
+ */
+
+/**
+ * A WebSocket connection between the runtime and the editor.
+ * @typedef CommsConnection
+ * @type {object}
+ * @property {string} session - a unique session identifier
+ * @property {Object} user - the user associated with the connection
+ * @property {Function} send - publish a message to the connection
+ */
+
+
+var runtime;
+var retained = {};
+var connections = [];
+
+
+function handleCommsEvent(event) {
+    publish(event.topic,event.data,event.retain);
+}
+function handleStatusEvent(event) {
+    var status = {
+        text: event.status.text,
+        fill: event.status.fill,
+        shape: event.status.shape
+    };
+    publish("status/"+event.id,status,true);
+}
+function handleRuntimeEvent(event) {
+    //runtime.log.trace("runtime event: "+JSON.stringify(event));
+    publish("notification/"+event.id,event.payload||{},event.retain);
+}
+function handleEventLog(event) {
+    var type = event.payload.type;
+    var id = event.id;
+    if (event.payload.data) {
+        var data = event.payload.data;
+        if (data.endsWith('\n')) {
+            data = data.substring(0,data.length-1);
+        }
+        var lines = data.split(/\n/);
+        lines.forEach(line => {
+            runtime.log.debug((type?("["+type+"] "):"")+line)
+        })
+    }
+    publish("event-log/"+event.id,event.payload||{});
+}
+
+function publish(topic,data,retain) {
+    if (retain) {
+        retained[topic] = data;
+    } else {
+        delete retained[topic];
+    }
+    connections.forEach(connection => connection.send(topic,data))
+}
+
+
+var api = module.exports = {
+    init: function(_runtime) {
+        runtime = _runtime;
+        connections = [];
+        retained = {};
+        runtime.events.removeListener("node-status",handleStatusEvent);
+        runtime.events.on("node-status",handleStatusEvent);
+        runtime.events.removeListener("runtime-event",handleRuntimeEvent);
+        runtime.events.on("runtime-event",handleRuntimeEvent);
+        runtime.events.removeListener("comms",handleCommsEvent);
+        runtime.events.on("comms",handleCommsEvent);
+        runtime.events.removeListener("event-log",handleEventLog);
+        runtime.events.on("event-log",handleEventLog);
+    },
+
+    /**
+    * Registers a new comms connection
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    addConnection: function(opts) {
+        connections.push(opts.client);
+        return Promise.resolve();
+    },
+
+    /**
+    * Unregisters a comms connection
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    removeConnection: function(opts) {
+        for (var i=0;i<connections.length;i++) {
+            if (connections[i] === opts.client) {
+                connections.splice(i,1);
+                break;
+            }
+        }
+        return Promise.resolve();
+    },
+
+    /**
+    * Subscribes a comms connection to a given topic. Currently, all clients get
+    * automatically subscribed to everything and cannot unsubscribe. Sending a subscribe
+    * request will trigger retained messages to be sent.
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @param {String} opts.topic - the topic to subscribe to
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    subscribe: function(opts) {
+        var re = new RegExp("^"+opts.topic.replace(/([\[\]\?\(\)\\\\$\^\*\.|])/g,"\\$1").replace(/\+/g,"[^/]+").replace(/\/#$/,"(\/.*)?")+"$");
+        for (var t in retained) {
+            if (re.test(t)) {
+                opts.client.send(t,retained[t]);
+            }
+        }
+        return Promise.resolve();
+    },
+
+    /**
+    * TODO: Unsubscribes a comms connection from a given topic
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @param {String} opts.topic - the topic to unsubscribe from
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    unsubscribe: function(opts) {}
+};

package/src/api/core/context.js

@@ -0,0 +1,296 @@
+
+
+/**
+ * @mixin @kumologica-core/runtime_context
+ */
+
+var runtime;
+
+let util = require('@kumologica/runtime').util;
+
+function exportContextStore(scope, ctx, store, result, callback) {
+  ctx.keys(store, function (err, keys) {
+    if (err) {
+      return callback(err);
+    }
+    result[store] = {};
+    var c = keys.length;
+    if (c === 0) {
+      callback(null);
+    } else {
+      keys.forEach(function (key) {
+        ctx.get(key, store, function (err, v) {
+          if (err) {
+            return callback(err);
+          }
+          if (
+            scope !== 'global' ||
+            store === runtime.nodes.listContextStores().default ||
+            !runtime.settings.hasOwnProperty('functionGlobalContext') ||
+            !runtime.settings.functionGlobalContext.hasOwnProperty(key) ||
+            runtime.settings.functionGlobalContext[key] !== v
+          ) {
+            result[store][key] = util.encodeObject({ msg: v });
+          }
+          c--;
+          if (c === 0) {
+            callback(null);
+          }
+        });
+      });
+    }
+  });
+}
+
+var api = (module.exports = {
+  init: function (_runtime) {
+    runtime = _runtime;
+  },
+  /**
+    * Gets the info of an individual node set
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.scope - the scope of the context
+    * @param {String} opts.id - the id of the context
+    * @param {String} opts.store - the context store
+    * @param {String} opts.key - the context key
+
+    * @return {Promise} - the node information
+    * @memberof @kumologica-core/runtime_context
+    */
+  getValue: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var scope = opts.scope;
+      var id = opts.id;
+      var store = opts.store;
+      var key = opts.key;
+
+      var availableStores = runtime.nodes.listContextStores();
+      //{ default: 'default', stores: [ 'default', 'file' ] }
+      if (store && availableStores.stores.indexOf(store) === -1) {
+        runtime.log.audit({
+          event: 'context.get',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key,
+          error: 'not_found'
+        });
+        var err = new Error();
+        err.code = 'not_found';
+        err.status = 404;
+        return reject(err);
+      }
+      var ctx;
+      if (scope === 'global') {
+        ctx = runtime.nodes.getContext('global');
+      } else if (scope === 'flow') {
+        ctx = runtime.nodes.getContext(id);
+      } else if (scope === 'node') {
+        var node = runtime.nodes.getNode(id);
+        if (node) {
+          ctx = node.context();
+        }
+      }
+      if (ctx) {
+        if (key) {
+          store = store || availableStores.default;
+          ctx.get(key, store, function (err, v) {
+            var encoded = util.encodeObject({ msg: v });
+            if (store !== availableStores.default) {
+              encoded.store = store;
+            }
+            runtime.log.audit({
+              event: 'context.get',
+              scope: scope,
+              id: id,
+              store: store,
+              key: key
+            });
+            resolve(encoded);
+          });
+          return;
+        } else {
+          var stores;
+          if (!store) {
+            stores = availableStores.stores;
+          } else {
+            stores = [store];
+          }
+
+          var result = {};
+          var c = stores.length;
+          var errorReported = false;
+          stores.forEach(function (store) {
+            exportContextStore(scope, ctx, store, result, function (err) {
+              if (err) {
+                // TODO: proper error reporting
+                if (!errorReported) {
+                  errorReported = true;
+                  runtime.log.audit({
+                    event: 'context.get',
+                    scope: scope,
+                    id: id,
+                    store: store,
+                    key: key,
+                    error: 'unexpected_error'
+                  });
+                  var err = new Error();
+                  err.code = 'unexpected_error';
+                  err.status = 400;
+                  return reject(err);
+                }
+
+                return;
+              }
+              c--;
+              if (c === 0) {
+                if (!errorReported) {
+                  runtime.log.audit({
+                    event: 'context.get',
+                    scope: scope,
+                    id: id,
+                    store: store,
+                    key: key
+                  });
+                  resolve(result);
+                }
+              }
+            });
+          });
+        }
+      } else {
+        runtime.log.audit({
+          event: 'context.get',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key
+        });
+        resolve({});
+      }
+    });
+  },
+
+  /**
+    * Gets the info of an individual node set
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.scope - the scope of the context
+    * @param {String} opts.id - the id of the context
+    * @param {String} opts.store - the context store
+    * @param {String} opts.key - the context key
+
+    * @return {Promise} - the node information
+    * @memberof @kumologica-core/runtime_context
+    */
+  delete: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var scope = opts.scope;
+      var id = opts.id;
+      var store = opts.store;
+      var key = opts.key;
+
+      var availableStores = runtime.nodes.listContextStores();
+      //{ default: 'default', stores: [ 'default', 'file' ] }
+      if (store && availableStores.stores.indexOf(store) === -1) {
+        runtime.log.audit({
+          event: 'context.get',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key,
+          error: 'not_found'
+        });
+        var err = new Error();
+        err.code = 'not_found';
+        err.status = 404;
+        return reject(err);
+      }
+      var ctx;
+      if (scope === 'global') {
+        ctx = runtime.nodes.getContext('global');
+      } else if (scope === 'flow') {
+        ctx = runtime.nodes.getContext(id);
+      } else if (scope === 'node') {
+        var node = runtime.nodes.getNode(id);
+        if (node) {
+          ctx = node.context();
+        }
+      }
+      if (ctx) {
+        if (key) {
+          store = store || availableStores.default;
+          ctx.set(key, undefined, store, function (err) {
+            runtime.log.audit({
+              event: 'context.delete',
+              scope: scope,
+              id: id,
+              store: store,
+              key: key
+            });
+            resolve();
+          });
+          return;
+        } else {
+          // TODO: support deleting whole context
+          runtime.log.audit({
+            event: 'context.get',
+            scope: scope,
+            id: id,
+            store: store,
+            key: key,
+            error: 'not_found'
+          });
+          var err = new Error();
+          err.code = 'not_found';
+          err.status = 404;
+          return reject(err);
+          // var stores;
+          // if (!store) {
+          //     stores = availableStores.stores;
+          // } else {
+          //     stores = [store];
+          // }
+          //
+          // var result = {};
+          // var c = stores.length;
+          // var errorReported = false;
+          // stores.forEach(function(store) {
+          //     exportContextStore(scope,ctx,store,result,function(err) {
+          //         if (err) {
+          //             // TODO: proper error reporting
+          //             if (!errorReported) {
+          //                 errorReported = true;
+          //                 runtime.log.audit({event: "context.delete",scope:scope,id:id,store:store,key:key,error:"unexpected_error"});
+          //                 var err = new Error();
+          //                 err.code = "unexpected_error";
+          //                 err.status = 400;
+          //                 return reject(err);
+          //             }
+          //
+          //             return;
+          //         }
+          //         c--;
+          //         if (c === 0) {
+          //             if (!errorReported) {
+          //                 runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key});
+          //                 resolve(result);
+          //             }
+          //         }
+          //     });
+          // })
+        }
+      } else {
+        runtime.log.audit({
+          event: 'context.delete',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key
+        });
+        resolve();
+      }
+    });
+  }
+});