vrpc 2.5.1 → 3.0.0-alpha.3

package/index.js

@@ -1,7 +1,7 @@
 'use strict'
 module.exports = {
-  VrpcLocal: require('./vrpc/VrpcLocal'),
-  VrpcRemote: require('./vrpc/VrpcRemote'),
+  VrpcNative: require('./vrpc/VrpcNative'),
+  VrpcClient: require('./vrpc/VrpcClient'),
   VrpcAdapter: require('./vrpc/VrpcAdapter'),
   VrpcAgent: require('./vrpc/VrpcAgent')
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vrpc",
-  "version": "2.5.1",
+  "version": "3.0.0-alpha.3",
   "description": "Variadic Remote Procedure Calls",
   "main": "index.js",
   "directories": {
@@ -9,18 +9,15 @@
     "test": "test"
   },
   "scripts": {
-    "build": "ln -sf binding.gyp.no-auto binding.gyp && third_party/install.sh && node-gyp rebuild && rm binding.gyp",
-    "test": "npm run test:cpp && npm run test:jsLocal && npm run test:jsRemote && npm run test:jsRemoteClient && npm run test:jsAgent",
-    "test:cpp": "build/Release/vrpc-test",
-    "test:jsLocal": "./node_modules/.bin/mocha test/js/local/*.js --exit",
-    "test:jsRemote": "./node_modules/.bin/mocha test/js/remote/lifeCycleTest.js --timeout 30000 --exit && test/js/remote/test.sh",
-    "test:jsRemoteClient": "test/js/remoteClient/test.sh",
-    "test:jsAgent": "test/js/agent/test.sh",
-    "test:jsPerformance": "test/js/performance/test.sh",
-    "build:pydoc": "pydoc-markdown -I vrpc -m VrpcLocal --render-toc > docs/reference/python.md",
-    "build:jsdoc": "./node_modules/.bin/jsdoc2md -f vrpc/*.js --param-list-format=list --separators > docs/reference/nodeJs.md",
-    "build:doc": "npm run build:pydoc; npm run build:jsdoc",
-    "build:browser": "./node_modules/.bin/webpack"
+    "build:addon": "ln -sf binding.gyp.no-auto binding.gyp && node-gyp rebuild && rm binding.gyp",
+    "build:browser": "./node_modules/.bin/webpack",
+    "build:doc": "./node_modules/.bin/jsdoc2md -f vrpc/*.js --param-list-format=list --separators > docs/api.md",
+    "test": "npm run test:agent && npm run test:client && npm run test:native",
+    "test:agent": "tests/agent/test.sh",
+    "test:client": "tests/client/test.sh",
+    "test:native": "./node_modules/.bin/mocha tests/native/vrpc-native*.js --exit",
+    "test:performance": "tests/performance/test.sh",
+    "test:production": "./node_modules/.bin/mocha tests/production/lifeCycleTest.js --timeout 30000 --exit && tests/production/test.sh"
   },
   "bin": {
     "vrpc-agent-js": "./vrpc/vrpc-agent-js"
@@ -34,7 +31,7 @@
     "remote procedural calls",
     "language binding",
     "C++",
-    "C++ binding",
+    "C++ embedding",
     "header-only"
   ],
   "repository": {
@@ -51,7 +48,7 @@
     "chai": "^4.2.0",
     "crypto-browserify": "^3.12.0",
     "dockerode": "^3.2.0",
-    "jsdoc-to-markdown": "^6.0.1",
+    "jsdoc-to-markdown": "^7.0.1",
     "mocha": "^6.1.4",
     "os-browserify": "^0.3.0",
     "sinon": "^7.3.2",
@@ -62,7 +59,6 @@
   },
   "files": [
     "vrpc/",
-    "third_party/",
     "browser/",
     "binding.gyp.no-auto"
   ],

package/vrpc/VrpcAdapter.js

@@ -10,9 +10,9 @@ __\/\\\_______\/\\\__/\\\///////\\\___\/\\\/////////\\\____/\\\////////__
        ________\///________\///________\///__\///___________________\/////////__
 
 
-Non-intrusively binds code and provides access in form of asynchronous remote
+Non-intrusively adapts code and provides access in form of asynchronous remote
 procedure calls (RPC).
-Author: Dr. Burkhard C. Heisen (https://github.com/bheisen/vrpc)
+Author: Dr. Burkhard C. Heisen (https://github.com/heisenware/vrpc)
 
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -42,9 +42,9 @@ const path = require('path')
 const fs = require('fs')
 const Ajv = require('ajv')
 const caller = require('caller')
-const { nanoid } = require('nanoid')
 const commentParser = require('./comment-parser')
 const EventEmitter = require('events')
+const { type } = require('os')
 
 /**
  * Generates an adapter layer for existing code and enables further VRPC-based
@@ -152,10 +152,14 @@ class VrpcAdapter {
       meta,
       Klass: {},
       withNew: false,
-      staticFunctions: ['__getNamed__'],
+      staticFunctions: [],
       schema: null
     })
-    VrpcAdapter._instances.set(instance, { className, instance: obj })
+    VrpcAdapter._instances.set(instance, {
+      className,
+      instance: obj,
+      isIsolated: false
+    })
   }
 
   static getClasses () {
@@ -351,11 +355,10 @@ class VrpcAdapter {
       staticFunctions = staticFunctions.filter(f => !f.startsWith('_'))
     }
     // Inject constructor and destructor
-    staticFunctions.push('__create__')
-    staticFunctions.push('__delete__')
-    staticFunctions.push('__createNamed__')
-    staticFunctions.push('__getNamed__')
+    staticFunctions.push('__createIsolated__')
+    staticFunctions.push('__createShared__')
     staticFunctions.push('__callAll__')
+    staticFunctions.push('__delete__')
     let memberFunctions = VrpcAdapter._extractMemberFunctions(Klass)
     if (onlyPublic) {
       memberFunctions = memberFunctions.filter(f => {
@@ -416,7 +419,7 @@ class VrpcAdapter {
               },
               ...params
             ]
-            meta.__createNamed__ = { description, params: modified, ret }
+            meta.__createShared__ = { description, params: modified, ret }
           } else {
             meta[functionName] = { description, params, ret }
           }
@@ -427,133 +430,170 @@ class VrpcAdapter {
   }
 
   static _call (json) {
-    const { context, method, data } = json
-    const wrappedArgs = VrpcAdapter._wrapCallbacks(json)
-    // VrpcAdapter._log.debug(`Calling function: ${method} with payload: ${data}`)
-    switch (method) {
-      // Special case: ctor
-      case '__create__':
-        try {
-          const instance = VrpcAdapter._create(context, ...wrappedArgs)
-          const instanceId = nanoid(9)
-          VrpcAdapter._instances.set(instanceId, { context, instance })
-          data.r = instanceId
-        } catch (err) {
-          data.e = err.message
-        }
+    const before = Object.keys(VrpcAdapter._listeners).length
+    switch (json.f) {
+      case '__createIsolated__':
+        VrpcAdapter._handleCreateIsolated(json)
+        break
+      case '__createShared__':
+        VrpcAdapter._handleCreateShared(json)
+        break
+      case '__callAll__':
+        VrpcAdapter._handleCallAll(json)
         break
-      // Special case: dtor
       case '__delete__':
-        try {
-          const instanceId = wrappedArgs[0]
-          data.r = VrpcAdapter._delete(instanceId)
-          VrpcAdapter._emitter.emit('delete', {
-            className: context,
-            instance: wrappedArgs[0]
-          })
-        } catch (err) {
-          data.e = err.message
-        }
+        VrpcAdapter._handleDelete(json)
         break
-      // Special case: named construction
-      case '__createNamed__':
+      default:
+        VrpcAdapter._handleCall(json)
+    }
+    const after = Object.keys(VrpcAdapter._listeners).length
+    // if we took a listener on board we must tell our caller such that
+    // things can be cleaned up later.
+    return after > before
+  }
+
+  static _handleCreateIsolated (json) {
+    try {
+      const className = json.c
+      const [instanceId, ...args] = json.a
+      const instance = VrpcAdapter._create(className, instanceId, ...args)
+      VrpcAdapter._instances.set(instanceId, {
+        instance,
+        className,
+        isIsolated: true
+      })
+      json.r = instanceId
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static _handleCreateShared (json) {
+    try {
+      const className = json.c
+      const [instanceId, ...args] = json.a
+      const instance = VrpcAdapter._create(className, instanceId, ...args)
+      VrpcAdapter._instances.set(instanceId, {
+        instance,
+        className,
+        isIsolated: false
+      })
+      json.r = instanceId
+      VrpcAdapter._emitter.emit('create', {
+        args,
+        className,
+        instance: instanceId
+      })
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static _handleCallAll (json) {
+    try {
+      const calls = []
+      for (const [
+        id,
+        { className, instance, isIsolated }
+      ] of VrpcAdapter._instances) {
+        // TODO Think about a configurable behavior w.r.t. isolated instances...
+        if (className !== json.c || isIsolated) continue
+        let v
+        let e = null
         try {
-          VrpcAdapter._createNamed(context, ...wrappedArgs)
-          data.r = wrappedArgs[0] // First argument is instanceId
-          VrpcAdapter._emitter.emit('create', {
-            className: context,
-            instance: wrappedArgs[0],
-            args: wrappedArgs.slice(1)
-          })
+          const wrappedArgs = VrpcAdapter._wrapArguments(json, id)
+          const funcName = wrappedArgs[0]
+          v = instance[funcName].apply(instance, wrappedArgs.slice(1))
+          v = VrpcAdapter.sanitizeEventListenerReturnValues(v)
         } catch (err) {
-          data.e = err.message
+          e = err.message
         }
-        break
-      case '__getNamed__': // Special case: retrieval of known instance
+        if (VrpcAdapter._isPromise(v)) {
+          calls.push(
+            v
+              .then(val => ({ id, val, err: null }))
+              .catch(err => ({ id, err, val: null }))
+          )
+        } else {
+          calls.push({ id, val: v, err: e })
+        }
+      }
+      this._handlePromise(json, Promise.all(calls))
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static sanitizeEventListenerReturnValues (ret) {
+    return typeof ret === 'object' &&
+      ret._events !== undefined &&
+      ret._eventsCount !== undefined
+      ? true
+      : ret
+  }
+
+  static _handleDelete (json) {
+    try {
+      const wrappedArgs = VrpcAdapter._wrapArguments(json)
+      const instanceId = wrappedArgs[0]
+      json.r = VrpcAdapter._delete(instanceId)
+      VrpcAdapter._emitter.emit('delete', {
+        className: json.c,
+        instance: wrappedArgs[0]
+      })
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static _handleCall (json) {
+    const wrappedArgs = VrpcAdapter._wrapArguments(json)
+    // Check whether context is a registered class
+    const entry = VrpcAdapter._functionRegistry.get(json.c)
+    if (entry !== undefined) {
+      // entry is class -> function is static
+      const { Klass } = entry
+      // TODO Think about whether to do live checking (like here) or
+      // rather sticking to those functions registered before...
+      // TODO This is even more important now as the agent does a wildcard
+      // subscription against all functions
+      if (VrpcAdapter._isFunction(Klass[json.f])) {
         try {
-          const instanceId = wrappedArgs[0]
-          const entry = VrpcAdapter._instances.get(instanceId)
-          if (entry) data.r = instanceId
-          else data.e = `Instance with id: ${instanceId} does not exist`
+          const ret = Klass[json.f].apply(null, wrappedArgs)
+          // check if function returns promise
+          if (VrpcAdapter._isPromise(ret)) {
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
+          json.e = err.message
         }
-        break
-      case '__callAll__': // Special case: call on all known instances
+      } else throw new Error(`Could not find function: ${json.f}`)
+    } else {
+      // is not static
+      const entry = VrpcAdapter._instances.get(json.c)
+      if (entry === undefined) {
+        throw new Error(`Could not find context: ${json.c}`)
+      }
+      const { instance } = entry
+      if (VrpcAdapter._isFunction(instance[json.f])) {
         try {
-          const funcName = wrappedArgs[0]
-          const calls = []
-          for (const [id, { className, instance }] of VrpcAdapter._instances) {
-            if (className !== context) continue
-            let v
-            let e = null
-            try {
-              v = instance[funcName].apply(instance, wrappedArgs.slice(1))
-            } catch (err) {
-              e = err
-            }
-            // check wether function returned a promise
-            if (VrpcAdapter._isPromise(v)) {
-              calls.push(
-                v
-                  .then(val => ({ id, val, err: null }))
-                  .catch(err => ({ id, err, val: null }))
-              )
-            } else {
-              calls.push({ id, val: v, err: e })
-            }
-          }
-          this._handlePromise(json, method, Promise.all(calls))
+          let ret = instance[json.f].apply(instance, wrappedArgs)
+          ret = VrpcAdapter.sanitizeEventListenerReturnValues(ret)
+          // check if function returns promise
+          if (VrpcAdapter._isPromise(ret)) {
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
+          json.e = err.message
         }
-        break
-      // Regular function call
-      default: {
-        // Check whether context is a registered class
-        const entry = VrpcAdapter._functionRegistry.get(context)
-        if (entry !== undefined) {
-          // entry is class -> function is static
-          const { Klass } = entry
-          // TODO Think about whether to do live checking (like here) or
-          // rather sticking to those functions registered before...
-          // TODO This is even more important now as the agent does a wildcard
-          // subscription against all functions
-          if (VrpcAdapter._isFunction(Klass[method])) {
-            try {
-              const ret = Klass[method].apply(null, wrappedArgs)
-              // check if function returns promise
-              if (ret && this._isFunction(ret.then)) {
-                this._handlePromise(json, method, ret)
-              } else data.r = ret
-            } catch (err) {
-              data.e = err.message
-            }
-          } else throw new Error(`Could not find function: ${method}`)
-        } else {
-          // is not static
-          const entry = VrpcAdapter._instances.get(context)
-          if (entry === undefined) {
-            throw new Error(`Could not find context: ${context}`)
-          }
-          const { instance } = entry
-          if (VrpcAdapter._isFunction(instance[method])) {
-            try {
-              const ret = instance[method].apply(instance, wrappedArgs)
-              // check if function returns promise
-              if (VrpcAdapter._isPromise(ret)) {
-                this._handlePromise(json, method, ret)
-              } else data.r = ret
-            } catch (err) {
-              data.e = err.message
-            }
-          } else throw new Error(`Could not find function: ${method}`)
-        }
-      }
+      } else throw new Error(`Could not find function: ${json.f}`)
     }
   }
 
-  static _create (className, ...args) {
+  static _create (className, instanceId, ...args) {
+    const entry = VrpcAdapter._instances.get(instanceId)
+    if (entry) return entry.instance
     const { Klass, withNew, schema } = VrpcAdapter._getClassEntry(className)
     if (schema !== null) {
       VrpcAdapter._validate(schema, ...args)
@@ -562,16 +602,6 @@ class VrpcAdapter {
     return Klass(...args)
   }
 
-  static _createNamed (className, instanceId, ...args) {
-    const entry = VrpcAdapter._instances.get(instanceId)
-    if (!entry) {
-      const instance = VrpcAdapter._create(className, ...args)
-      VrpcAdapter._instances.set(instanceId, { className, instance })
-      return instance
-    }
-    return entry.instance
-  }
-
   static _delete (instanceId) {
     const entry = VrpcAdapter._instances.get(instanceId)
     if (entry) {
@@ -591,6 +621,18 @@ class VrpcAdapter {
     delete VrpcAdapter._listeners[clientId]
   }
 
+  static _unregisterEventListenersOfInstance (instance) {
+    for (const [key, value] of Object.entries(VrpcAdapter._listeners)) {
+      VrpcAdapter._listeners[key] = value.filter(({ i, e, f }) => {
+        if (instance === i) {
+          VrpcAdapter.getInstance(i).removeListener(e, f)
+          return false
+        }
+        return true
+      })
+    }
+  }
+
   static _validate (schema, params) {
     if (!VrpcAdapter._ajv) {
       VrpcAdapter._ajv = new Ajv({ useDefaults: true })
@@ -599,42 +641,30 @@ class VrpcAdapter {
     if (!valid) throw new Error(VrpcAdapter._ajv.errorsText())
   }
 
-  static _wrapCallbacks (json) {
-    const { method, sender, data, context } = json
-    const args = VrpcAdapter._extractDataToArray(data)
-    const wrappedArgs = []
+  static _wrapArguments (json, instanceId) {
+    const { f: func, s: sender, a: args, c: context } = json
+    const wrapped = []
     args.forEach(arg => {
       // Find those args that actually need to be function callbacks
       if (typeof arg === 'string' && arg.substr(0, 5) === '__f__') {
-        const f = (...innerArgs) => {
-          // do not even trigger a callback for already offline clients
-          if (sender && !VrpcAdapter._listeners[sender]) return
-          const data = {}
-          innerArgs.forEach((value, index) => {
-            data[`_${index + 1}`] = value
-          })
-          const callbackJson = Object.assign({}, json, { data, id: arg })
-          const callbackJsonString = VrpcAdapter._stringifySafely(callbackJson)
-          VrpcAdapter._callback(callbackJsonString, callbackJson)
-        }
-        wrappedArgs.push(f)
+        const f = this._generateWrapper(arg, json, instanceId)
+        wrapped.push(f)
         if (!sender) return
         // Register this client to later know when he is dead and skip callbacks
         if (!VrpcAdapter._listeners[sender]) VrpcAdapter._listeners[sender] = []
         // Check whether injected callback is an EventEmitter registration
-        if (method === 'on' && typeof args[0] === 'string') {
+        if (func === 'on' && typeof args[0] === 'string') {
           const e = args[0]
           const i = context
           const r = arg
           VrpcAdapter._listeners[sender].push({ i, e, f, r })
         }
         if (
-          (method === 'off' || method === 'removeListener') &&
+          (func === 'off' || func === 'removeListener') &&
           typeof args[0] === 'string'
         ) {
-          const r = arg
-          const s = VrpcAdapter._listeners[sender]
-          const entry = s && s.find(x => x.r === r)
+          const listener = VrpcAdapter._listeners[sender]
+          const entry = listener && listener.find(x => x.r === arg)
           if (entry) {
             const { i, e, f } = entry
             VrpcAdapter.getInstance(i).removeListener(e, f)
@@ -642,54 +672,33 @@ class VrpcAdapter {
         }
       } else {
         // Leave the others untouched
-        wrappedArgs.push(arg)
+        wrapped.push(arg)
       }
     })
-    return wrappedArgs
+    return wrapped
   }
 
-  static _handlePromise (json, method, promise) {
-    try {
-      const cid = VrpcAdapter._correlationId++ % Number.MAX_SAFE_INTEGER
-      const id = `__p__${method}-${cid}`
-      json.data.r = id
-      promise
-        .then(value => {
-          const data = { r: value }
-          const promiseJson = Object.assign({}, json, { data, id })
-          const promiseJsonString = VrpcAdapter._stringifySafely(promiseJson)
-          VrpcAdapter._callback(promiseJsonString, promiseJson)
-        })
-        .catch(err => {
-          const data = { e: err.message }
-          const promiseJson = Object.assign({}, json, { data, id })
-          const promiseJsonString = VrpcAdapter._stringifySafely(promiseJson)
-          VrpcAdapter._callback(promiseJsonString, promiseJson)
-        })
-    } catch (err) {
-      json.data.e = err.message
+  static _generateWrapper (id, json, instanceId) {
+    const wrapper = (...innerArgs) => {
+      // do not even trigger a callback for already offline clients
+      if (json.s && !VrpcAdapter._listeners[json.s]) return
+      const a = instanceId ? [instanceId, ...innerArgs] : [...innerArgs]
+      VrpcAdapter._callback({ a, s: json.s, f: json.f, i: id })
     }
+    return wrapper
   }
 
-  static _stringifySafely (json) {
-    let jsonString
+  static _handlePromise (json, promise) {
     try {
-      jsonString = JSON.stringify(json)
+      const cid = VrpcAdapter._correlationId++ % Number.MAX_SAFE_INTEGER
+      const id = `__p__${json.f}-${cid}`
+      json.r = id
+      promise
+        .then(r => VrpcAdapter._callback({ ...json, r, i: id }))
+        .catch(err => VrpcAdapter._callback({ ...json, e: err.message, i: id }))
     } catch (err) {
-      this._log.debug(
-        `Failed serialization of return value for: ${json.context}::${json.method}, because: ${err.message}`
-      )
-      json.data.r = '__vrpc::not-serializable__'
-      jsonString = JSON.stringify(json)
+      json.data.e = err.message
     }
-    return jsonString
-  }
-
-  static _extractDataToArray (data) {
-    return Object.keys(data)
-      .sort()
-      .filter(value => value[0] === '_')
-      .map(key => data[key])
   }
 
   static _generateId (object) {
@@ -775,8 +784,8 @@ class VrpcAdapter {
 
   static _getInstancesArray (className) {
     const instances = []
-    VrpcAdapter._instances.forEach((value, key) => {
-      if (value.className === className) instances.push(key)
+    VrpcAdapter._instances.forEach((v, k) => {
+      if (v.className === className && !v.isIsolated) instances.push(k)
     })
     return instances
   }