vrpc 2.6.0 → 3.0.0-alpha.1

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.6.0",
+  "version": "3.0.0-alpha.1",
   "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": {
@@ -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,7 +42,6 @@ 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')
 
@@ -152,10 +151,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 +354,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 +418,7 @@ class VrpcAdapter {
               },
               ...params
             ]
-            meta.__createNamed__ = { description, params: modified, ret }
+            meta.__createShared__ = { description, params: modified, ret }
           } else {
             meta[functionName] = { description, params, ret }
           }
@@ -427,91 +429,61 @@ class VrpcAdapter {
   }
 
   static _call (json) {
-    const { method } = json
-    switch (method) {
-      case '__create__':
-        VrpcAdapter._handleCreate(json)
-        break
-      case '__delete__':
-        VrpcAdapter._handleDelete(json)
+    switch (json.f) {
+      case '__createIsolated__':
+        VrpcAdapter._handleCreateIsolated(json)
         break
-      case '__createNamed__':
-        VrpcAdapter._handleCreateNamed(json)
-        break
-      case '__getNamed__':
-        VrpcAdapter._handleGetNamed(json)
+      case '__createShared__':
+        VrpcAdapter._handleCreateShared(json)
         break
       case '__callAll__':
         VrpcAdapter._handleCallAll(json)
         break
+      case '__delete__':
+        VrpcAdapter._handleDelete(json)
+        break
       default:
         VrpcAdapter._handleCall(json)
     }
   }
 
-  static _handleCreate (json) {
-    const { context, data } = json
+  static _handleCreateIsolated (json) {
     try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      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
-    }
-  }
-
-  static _handleDelete (json) {
-    const { context, data } = json
-    try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      const instanceId = wrappedArgs[0]
-      data.r = VrpcAdapter._delete(instanceId)
-      VrpcAdapter._emitter.emit('delete', {
-        className: context,
-        instance: wrappedArgs[0]
+      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) {
-      data.e = err.message
+      json.e = err.message
     }
   }
 
-  static _handleCreateNamed (json) {
-    const { context, data } = json
+  static _handleCreateShared (json) {
     try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      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 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
     } catch (err) {
-      data.e = err.message
-    }
-  }
-
-  static _handleGetNamed (json) {
-    const { data } = json
-    try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      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`
-    } catch (err) {
-      data.e = err.message
+      json.e = err.message
     }
   }
 
   static _handleCallAll (json) {
-    const { context, method, data } = json
     try {
       const calls = []
       for (const [id, { className, instance }] of VrpcAdapter._instances) {
-        if (className !== context) continue
+        if (className !== json.c) continue
         let v
         let e = null
         try {
@@ -519,7 +491,7 @@ class VrpcAdapter {
           const funcName = wrappedArgs[0]
           v = instance[funcName].apply(instance, wrappedArgs.slice(1))
         } catch (err) {
-          e = err
+          e = err.message
         }
         if (VrpcAdapter._isPromise(v)) {
           calls.push(
@@ -531,17 +503,30 @@ class VrpcAdapter {
           calls.push({ id, val: v, err: e })
         }
       }
-      this._handlePromise(json, method, Promise.all(calls))
+      this._handlePromise(json, Promise.all(calls))
     } catch (err) {
-      data.e = err.message
+      json.e = err.message
+    }
+  }
+
+  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 { context, method, data } = json
     const wrappedArgs = VrpcAdapter._wrapArguments(json)
     // Check whether context is a registered class
-    const entry = VrpcAdapter._functionRegistry.get(context)
+    const entry = VrpcAdapter._functionRegistry.get(json.c)
     if (entry !== undefined) {
       // entry is class -> function is static
       const { Klass } = entry
@@ -549,39 +534,41 @@ class VrpcAdapter {
       // 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])) {
+      if (VrpcAdapter._isFunction(Klass[json.f])) {
         try {
-          const ret = Klass[method].apply(null, wrappedArgs)
+          const ret = Klass[json.f].apply(null, wrappedArgs)
           // check if function returns promise
           if (VrpcAdapter._isPromise(ret)) {
-            this._handlePromise(json, method, ret)
-          } else data.r = ret
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
+          json.e = err.message
         }
-      } else throw new Error(`Could not find function: ${method}`)
+      } else throw new Error(`Could not find function: ${json.f}`)
     } else {
       // is not static
-      const entry = VrpcAdapter._instances.get(context)
+      const entry = VrpcAdapter._instances.get(json.c)
       if (entry === undefined) {
-        throw new Error(`Could not find context: ${context}`)
+        throw new Error(`Could not find context: ${json.c}`)
       }
       const { instance } = entry
-      if (VrpcAdapter._isFunction(instance[method])) {
+      if (VrpcAdapter._isFunction(instance[json.f])) {
         try {
-          const ret = instance[method].apply(instance, wrappedArgs)
+          const ret = instance[json.f].apply(instance, wrappedArgs)
           // check if function returns promise
           if (VrpcAdapter._isPromise(ret)) {
-            this._handlePromise(json, method, ret)
-          } else data.r = ret
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
+          json.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)
@@ -590,16 +577,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) {
@@ -628,31 +605,29 @@ class VrpcAdapter {
   }
 
   static _wrapArguments (json, instanceId) {
-    const { method, sender, data, context } = json
-    const args = VrpcAdapter._extractDataToArray(data)
-    const wrappedArgs = []
+    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 = this._generateWrapper(arg, json, instanceId)
-        wrappedArgs.push(f)
+        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)
@@ -660,88 +635,35 @@ class VrpcAdapter {
         }
       } else {
         // Leave the others untouched
-        wrappedArgs.push(arg)
+        wrapped.push(arg)
       }
     })
-    return wrappedArgs
+    return wrapped
   }
 
   static _generateWrapper (id, json, instanceId) {
-    const { sender } = json
-    if (instanceId) {
-      const wrapper = (...innerArgs) => {
-        // do not even trigger a callback for already offline clients
-        if (sender && !VrpcAdapter._listeners[sender]) return
-        const data = { _1: instanceId }
-        innerArgs.forEach((x, i) => {
-          data[`_${i + 2}`] = x
-        })
-        // TODO Heal that crazy API !!
-        const callbackJson = { ...json, data, id }
-        const callbackJsonString = VrpcAdapter._stringifySafely(callbackJson)
-        VrpcAdapter._callback(callbackJsonString, callbackJson)
-      }
-      return wrapper
-    }
     const wrapper = (...innerArgs) => {
       // do not even trigger a callback for already offline clients
-      if (sender && !VrpcAdapter._listeners[sender]) return
-      const data = {}
-      innerArgs.forEach((x, i) => {
-        data[`_${i + 1}`] = x
-      })
-      // TODO Heal that crazy API !!
-      const callbackJson = { ...json, data, id }
-      const callbackJsonString = VrpcAdapter._stringifySafely(callbackJson)
-      VrpcAdapter._callback(callbackJsonString, callbackJson)
+      if (json.s && !VrpcAdapter._listeners[json.s]) return
+      const a = instanceId ? [instanceId, ...innerArgs] : [...innerArgs]
+      VrpcAdapter._callback({ ...json, a, i: id })
     }
     return wrapper
   }
 
-  static _handlePromise (json, method, promise) {
+  static _handlePromise (json, promise) {
     try {
       const cid = VrpcAdapter._correlationId++ % Number.MAX_SAFE_INTEGER
-      const id = `__p__${method}-${cid}`
-      json.data.r = id
+      const id = `__p__${json.f}-${cid}`
+      json.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)
-        })
+        .then(r => VrpcAdapter._callback({ ...json, r, i: id }))
+        .catch(err => VrpcAdapter._callback({ ...json, e: err.message, i: id }))
     } catch (err) {
       json.data.e = err.message
     }
   }
 
-  static _stringifySafely (json) {
-    let jsonString
-    try {
-      jsonString = JSON.stringify(json)
-    } 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)
-    }
-    return jsonString
-  }
-
-  static _extractDataToArray (data) {
-    return Object.keys(data)
-      .sort()
-      .filter(value => value[0] === '_')
-      .map(key => data[key])
-  }
-
   static _generateId (object) {
     return crypto
       .createHash('md5')
@@ -825,8 +747,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
   }