vrpc 2.6.0 → 3.0.0

package/vrpc/VrpcAgent.js

@@ -6,6 +6,8 @@ const { ArgumentParser } = require('argparse')
 const VrpcAdapter = require('./VrpcAdapter')
 const EventEmitter = require('events')
 
+const VRPC_PROTOCOL_VERSION = 3
+
 /**
  * Agent capable of making existing code available to remote control by clients.
  *
@@ -138,8 +140,8 @@ class VrpcAgent extends EventEmitter {
     this._baseTopic = `${this._domain}/${this._agent}`
     VrpcAdapter.onCallback(this._handleVrpcCallback.bind(this))
     // maps clientId to instanceId
-    this._unnamedInstances = new Map()
-    this._namedInstances = new Map()
+    this._isolatedInstances = new Map()
+    this._sharedInstances = new Map()
 
     // Handle the internal error event in case the user forgot to implement it
     this.on('error', err => {
@@ -167,7 +169,7 @@ class VrpcAgent extends EventEmitter {
       .createHash('md5')
       .update(this._domain + this._agent)
       .digest('hex')
-      .substr(0, 18)
+      .substr(0, 20)
     let username = this._username
     let password = this._password
     if (this._token) {
@@ -179,7 +181,7 @@ class VrpcAgent extends EventEmitter {
       password,
       keepalive: 30,
       connectTimeout: 10 * 1000,
-      clientId: `vrpca${md5}`,
+      clientId: `va3${md5}`,
       rejectUnauthorized: false,
       will: {
         topic: `${this._baseTopic}/__agentInfo__`,
@@ -274,7 +276,8 @@ class VrpcAgent extends EventEmitter {
     return JSON.stringify({
       status,
       hostname: os.hostname(),
-      version: this._version
+      version: this._version,
+      v: VRPC_PROTOCOL_VERSION
     })
   }
 
@@ -343,23 +346,23 @@ class VrpcAgent extends EventEmitter {
   }
 
   _getClasses () {
-    return VrpcAdapter.getAvailableClasses()
+    return VrpcAdapter._getClassesArray()
   }
 
   _getInstances (className) {
-    return VrpcAdapter.getAvailableInstances(className)
+    return VrpcAdapter._getInstancesArray(className)
   }
 
   _getMemberFunctions (className) {
-    return VrpcAdapter.getAvailableMemberFunctions(className)
+    return VrpcAdapter._getMemberFunctionsArray(className)
   }
 
   _getStaticFunctions (className) {
-    return VrpcAdapter.getAvailableStaticFunctions(className)
+    return VrpcAdapter._getStaticFunctionsArray(className)
   }
 
   _getMetaData (className) {
-    return VrpcAdapter.getAvailableMetaData(className)
+    return VrpcAdapter._getMetaData(className)
   }
 
   async _ensureConnected () {
@@ -372,22 +375,38 @@ class VrpcAgent extends EventEmitter {
     })
   }
 
-  _handleVrpcCallback (jsonString, jsonObject) {
-    const { sender } = jsonObject
+  _handleVrpcCallback (json) {
+    const { s, i, r, e, a } = json
+    const topic = i.startsWith('__e__') ? i.slice(5) : s
     try {
-      this._log.debug(
-        `Forwarding callback to: ${sender} with payload:`,
-        jsonObject
+      this._log.debug(`Forwarding callback to: ${topic} with payload:`, json)
+      this._mqttPublish(
+        topic,
+        VrpcAgent._stringifySafely({ a, r, e, i, v: VRPC_PROTOCOL_VERSION })
       )
-      this._mqttPublish(sender, jsonString)
     } catch (err) {
       this._log.warn(
         err,
-        `Problem publishing vrpc callback to ${sender} because of: ${err.message}`
+        `Problem publishing vrpc callback to ${topic} because of: ${err.message}`
       )
     }
   }
 
+  static _stringifySafely (json) {
+    let str
+    const { c, f } = json
+    try {
+      str = JSON.stringify(json)
+    } catch (err) {
+      this._log.debug(
+        `Failed serialization of return value for: ${c}::${f}, because: ${err.message}`
+      )
+      json.r = '__vrpc::not-serializable__'
+      str = JSON.stringify(json)
+    }
+    return str
+  }
+
   _handleConnect () {
     this._log.info('[OK]')
     if (this._isReconnect) {
@@ -441,7 +460,8 @@ class VrpcAgent extends EventEmitter {
       instances: this._getInstances(className),
       memberFunctions: this._getMemberFunctions(className),
       staticFunctions: this._getStaticFunctions(className),
-      meta: this._getMetaData(className)
+      meta: this._getMetaData(className),
+      v: VRPC_PROTOCOL_VERSION
     }
     try {
       this._mqttPublish(
@@ -494,69 +514,48 @@ class VrpcAgent extends EventEmitter {
       }
 
       // Prepare RPC json
-      json.context = instance === '__static__' ? className : instance
-      json.method = method
+      // SECURITY: take as much as possible params from topic structure as this
+      // can be authorized by the broker. Content can't be checked...
+      json.c = instance === '__static__' ? className : instance
+      json.f = method
 
       // Mutates json and adds return value
-      VrpcAdapter._call(json)
+      const mustTrack = VrpcAdapter._call(json)
+
+      if (mustTrack) {
+        this._mqttSubscribe(`${json.s}/__clientInfo__`)
+      }
 
       // Intersecting life-cycle functions
-      let publishClassInfo = false
       switch (method) {
-        case '__create__': {
+        case '__createIsolated__': {
           // TODO handle instantiation errors
-          const instanceId = json.data.r
+          const instanceId = json.r
           // TODO await this
           this._subscribeToMethodsOfNewInstance(className, instanceId)
-          this._registerUnnamedInstance(instanceId, json.sender)
+          this._registerIsolatedInstance(instanceId, json.s)
           break
         }
-        case '__createNamed__': {
+        case '__createShared__': {
           // TODO handle instantiation errors
-          const instanceId = json.data.r
-          if (!this._hasNamedInstance(instanceId)) {
-            publishClassInfo = true
+          const instanceId = json.r
+          if (!this._hasSharedInstance(instanceId)) {
             this._subscribeToMethodsOfNewInstance(className, instanceId)
+            this._publishClassInfoMessage(className)
           }
-          this._registerNamedInstance(instanceId, json.sender)
-          break
-        }
-        case '__getNamed__': {
-          const {
-            data: { _1, e },
-            sender
-          } = json
-          if (!e) this._registerNamedInstance(_1, sender)
+          this._registerSharedInstance(instanceId, json.s)
           break
         }
         case '__delete__': {
-          const {
-            data: { _1 },
-            sender
-          } = json
           this._unsubscribeMethodsOfDeletedInstance(className, instance)
-          const wasNamed = this._unregisterInstance(_1, sender)
-          if (wasNamed) publishClassInfo = true
+          const wasShared = this._unregisterInstance(json.a[0], json.s)
+          if (wasShared) this._publishClassInfoMessage(className)
           break
         }
       }
-      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)
-      }
-      if (publishClassInfo && method === '__delete__') {
-        this._publishClassInfoMessage(className)
-      }
-      this._mqttPublish(json.sender, jsonString)
-      if (publishClassInfo && method === '__createNamed__') {
-        this._publishClassInfoMessage(className)
-      }
+      const { a, r, e, i, v } = json
+      const res = e ? { a, r, e, i, v } : { a, r, i, v }
+      this._mqttPublish(json.s, VrpcAgent._stringifySafely(res))
     } catch (err) {
       this._log.error(
         err,
@@ -567,80 +566,79 @@ class VrpcAgent extends EventEmitter {
 
   _handleClientInfoMessage (topic, json) {
     // Client went offline
-    const clientId = topic.slice(0, -9)
+    const clientId = topic.slice(0, -15) // /__clientInfo__ = 15
     if (json.status === 'offline') {
-      const entry = this._unnamedInstances.get(clientId)
+      VrpcAdapter._unregisterClient(clientId)
+      const entry = this._isolatedInstances.get(clientId)
       if (entry) {
-        // anonymous
         entry.forEach(instanceId => {
-          const json = { data: { _1: instanceId }, method: '__delete__' }
+          const json = { f: '__delete__', a: [instanceId], r: null }
           VrpcAdapter._call(json)
-          const {
-            data: { r }
-          } = json
-          if (r) this._log.debug(`Deleted unnamed instance: ${instanceId}`)
+          if (json.r) {
+            this._log.debug(`Auto-deleted isolated instance: ${instanceId}`)
+          }
         })
       }
-      VrpcAdapter._unregisterEventListeners(clientId)
       this._mqttUnsubscribe(`${clientId}/__clientInfo__`)
+      this.emit('clientGone', clientId)
     }
   }
 
-  _registerUnnamedInstance (instanceId, clientId) {
-    const entry = this._unnamedInstances.get(clientId)
+  _registerIsolatedInstance (instanceId, clientId) {
+    const entry = this._isolatedInstances.get(clientId)
     if (entry) {
       // already seen
       entry.add(instanceId)
     } else {
       // new instance
-      this._unnamedInstances.set(clientId, new Set([instanceId]))
-      if (!this._namedInstances.has(clientId)) {
+      this._isolatedInstances.set(clientId, new Set([instanceId]))
+      if (!this._sharedInstances.has(clientId)) {
         this._mqttSubscribe(`${clientId}/__clientInfo__`)
       }
       this._log.info(`Tracking lifetime of client: ${clientId}`)
     }
   }
 
-  _registerNamedInstance (instanceId, clientId) {
-    const entry = this._namedInstances.get(clientId)
+  _registerSharedInstance (instanceId, clientId) {
+    const entry = this._sharedInstances.get(clientId)
     if (entry) {
       // already seen
       entry.add(instanceId)
     } else {
       // new instance
-      this._namedInstances.set(clientId, new Set([instanceId]))
-      if (!this._unnamedInstances.has(clientId)) {
+      this._sharedInstances.set(clientId, new Set([instanceId]))
+      if (!this._isolatedInstances.has(clientId)) {
         this._mqttSubscribe(`${clientId}/__clientInfo__`)
       }
       this._log.debug(`Tracking lifetime of client: ${clientId}`)
     }
   }
 
-  _hasNamedInstance (instanceId) {
-    for (const [, instances] of this._namedInstances) {
+  _hasSharedInstance (instanceId) {
+    for (const [, instances] of this._sharedInstances) {
       if (instances.has(instanceId)) return true
     }
     return false
   }
 
   _unregisterInstance (instanceId, clientId) {
-    const entryUnnamed = this._unnamedInstances.get(clientId)
-    if (entryUnnamed && entryUnnamed.has(instanceId)) {
-      entryUnnamed.delete(instanceId)
-      if (entryUnnamed.length === 0) {
-        this._unnamedInstances.delete(clientId)
+    const entryIsolated = this._isolatedInstances.get(clientId)
+    if (entryIsolated && entryIsolated.has(instanceId)) {
+      entryIsolated.delete(instanceId)
+      if (entryIsolated.length === 0) {
+        this._isolatedInstances.delete(clientId)
         this._mqttUnsubscribe(`${clientId}/__clientInfo__`)
         this._log.debug(`Stopped tracking lifetime of client: ${clientId}`)
       }
       return false
     }
     let found = false
-    this._namedInstances.forEach(async v => {
+    this._sharedInstances.forEach(async v => {
       if (v.has(instanceId)) {
         found = true
         v.delete(instanceId)
         if (v.length === 0) {
-          this._namedInstances.delete(clientId)
+          this._sharedInstances.delete(clientId)
           this._mqttUnsubscribe(`${clientId}/__clientInfo__`)
           this._log.debug(`Stopped tracking lifetime of client: ${clientId}`)
         }
@@ -749,4 +747,13 @@ class VrpcAgent extends EventEmitter {
  * @event VrpcAgent#end
  */
 
+/**
+ * Event 'clientGone'
+ *
+ * Emitted when a tracked VRPC client exited.
+ *
+ * @event VrpcAgent#clientGone
+ * @type {String} clientId
+ */
+
 module.exports = VrpcAgent