vrpc 2.4.0 → 3.0.0-alpha.1

package/vrpc/VrpcAgent.js

@@ -6,13 +6,14 @@ 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.
  *
  * @extends EventEmitter
  */
 class VrpcAgent extends EventEmitter {
-
   /**
    * Constructs an agent by parsing command line arguments
    *
@@ -41,79 +42,47 @@ class VrpcAgent extends EventEmitter {
       add_help: true,
       description: 'VRPC Node.js Agent'
     })
-    parser.add_argument(
-      '-a',
-      '--agent',
-      {
-        help: 'Agent name',
-        default: agent || VrpcAgent._generateAgentName()
-      }
-    )
-    parser.add_argument(
-      '-d',
-      '--domain',
-      {
-        help: 'Domain name',
-        default: domain || 'public.vrpc'
-      }
-    )
-    parser.add_argument(
-      '-t',
-      '--token',
-      {
-        help: 'access token',
-        default: token
-      }
-    )
-    parser.add_argument(
-      '-b',
-      '--broker',
-      {
-        help: 'Broker url',
-        default: broker || 'mqtts://vrpc.io:8883'
-      }
-    )
-    parser.add_argument(
-      '-u',
-      '--username',
-      {
-        help: 'Username',
-        default: username
-      }
-    )
-    parser.add_argument(
-      '-P',
-      '--password',
-      {
-        help: 'Password',
-        default: password
-      }
-    )
-    parser.add_argument(
-      '--bestEffort',
-      {
-        help: 'Calls function on best-effort. Improves performance but may fail under unstable network connections.',
-        action: 'store_true'
-      }
-    )
-    parser.add_argument(
-      '-V', '-v',
-      '--userVersion',
-      {
-        help: 'User defined agent version. May be checked on the remote side for compatibility checks.',
-        required: false,
-        default: version,
-        dest: 'version'
-      }
-    )
-    parser.add_argument(
-      '--version',
-      {
-        help: 'Returns the VRPC version this client was built with.',
-        action: 'version',
-        version: 'v2.3.2'
-      }
-    )
+    parser.add_argument('-a', '--agent', {
+      help: 'Agent name',
+      default: agent || VrpcAgent._generateAgentName()
+    })
+    parser.add_argument('-d', '--domain', {
+      help: 'Domain name',
+      default: domain || 'public.vrpc'
+    })
+    parser.add_argument('-t', '--token', {
+      help: 'access token',
+      default: token
+    })
+    parser.add_argument('-b', '--broker', {
+      help: 'Broker url',
+      default: broker || 'mqtts://vrpc.io:8883'
+    })
+    parser.add_argument('-u', '--username', {
+      help: 'Username',
+      default: username
+    })
+    parser.add_argument('-P', '--password', {
+      help: 'Password',
+      default: password
+    })
+    parser.add_argument('--bestEffort', {
+      help:
+        'Calls function on best-effort. Improves performance but may fail under unstable network connections.',
+      action: 'store_true'
+    })
+    parser.add_argument('-V', '-v', '--userVersion', {
+      help:
+        'User defined agent version. May be checked on the remote side for compatibility checks.',
+      required: false,
+      default: version,
+      dest: 'version'
+    })
+    parser.add_argument('--version', {
+      help: 'Returns the VRPC version this client was built with.',
+      action: 'version',
+      version: 'v2.3.2'
+    })
     const args = parser.parse_args()
     return new VrpcAgent(args)
   }
@@ -149,8 +118,7 @@ class VrpcAgent extends EventEmitter {
     log = 'console',
     bestEffort = false,
     version = ''
-  } = {}
-  ) {
+  } = {}) {
     super()
     this._validateDomain(domain)
     this._validateAgent(agent)
@@ -172,11 +140,11 @@ 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) => {
+    this.on('error', err => {
       this._log.debug(`Encountered an error: ${err.message}`)
     })
   }
@@ -197,8 +165,11 @@ class VrpcAgent extends EventEmitter {
    * rejects
    */
   async serve () {
-    const md5 = crypto.createHash('md5')
-      .update(this._domain + this._agent).digest('hex').substr(0, 18)
+    const md5 = crypto
+      .createHash('md5')
+      .update(this._domain + this._agent)
+      .digest('hex')
+      .substr(0, 18)
     let username = this._username
     let password = this._password
     if (this._token) {
@@ -225,10 +196,10 @@ class VrpcAgent extends EventEmitter {
     this._log.info('Connecting to MQTT server...')
     const wasEnded = await this._clearPersistedSession()
     if (wasEnded) return
-    this._client = mqtt.connect(
-      this._broker,
-      { ...this._options, clean: false }
-    )
+    this._client = mqtt.connect(this._broker, {
+      ...this._options,
+      clean: false
+    })
     this._client.on('connect', this._handleConnect.bind(this))
     this._client.on('reconnect', this._handleReconnect.bind(this))
     this._client.on('error', this._handleError.bind(this))
@@ -269,30 +240,35 @@ class VrpcAgent extends EventEmitter {
       await new Promise(resolve => this._client.end(false, {}, resolve))
       await this._clearPersistedSession()
     } catch (err) {
-      this._log.error(
-        err,
-        `Problem during disconnecting agent: ${err.message}`
-      )
+      this._log.error(err, `Problem during disconnecting agent: ${err.message}`)
     }
   }
 
   static _generateAgentName () {
     const { username } = os.userInfo()
-    const pathId = crypto.createHash('md5').update(path.resolve()).digest('hex').substr(0, 4)
+    const pathId = crypto
+      .createHash('md5')
+      .update(path.resolve())
+      .digest('hex')
+      .substr(0, 4)
     return `${username}-${pathId}@${os.hostname()}-${os.platform()}-js`
   }
 
   _validateDomain (domain) {
     if (!domain) throw new Error('The domain must be specified')
     if (domain.match(/[+/#*]/)) {
-      throw new Error('The domain must NOT contain any of those characters: "+", "/", "#", "*"')
+      throw new Error(
+        'The domain must NOT contain any of those characters: "+", "/", "#", "*"'
+      )
     }
   }
 
   _validateAgent (agent) {
     if (!agent) throw new Error('The agent must be specified')
     if (agent.match(/[+/#*]/)) {
-      throw new Error('The agent must NOT contain any of those characters: "+", "/", "#", "*"')
+      throw new Error(
+        'The agent must NOT contain any of those characters: "+", "/", "#", "*"'
+      )
     }
   }
 
@@ -300,7 +276,8 @@ class VrpcAgent extends EventEmitter {
     return JSON.stringify({
       status,
       hostname: os.hostname(),
-      version: this._version
+      version: this._version,
+      v: VRPC_PROTOCOL_VERSION
     })
   }
 
@@ -309,11 +286,8 @@ class VrpcAgent extends EventEmitter {
    */
   async _clearPersistedSession () {
     // Clear potentially existing persisted sessions
-    const client = mqtt.connect(
-      this._broker,
-      { ...this._options, clean: true }
-    )
-    client.on('error', (err) => this.emit('error', err))
+    const client = mqtt.connect(this._broker, { ...this._options, clean: true })
+    client.on('error', err => this.emit('error', err))
     client.on('offline', () => this.emit('offline'))
     client.on('reconnect', () => this.emit('reconnect'))
     return new Promise(resolve => {
@@ -329,29 +303,44 @@ class VrpcAgent extends EventEmitter {
   }
 
   _mqttPublish (topic, message, options) {
-    this._client.publish(topic, message, { qos: this._qos, ...options }, (err) => {
-      if (err) {
-        this._log.warn(`Could not publish MQTT message because: ${err.message}`)
+    this._client.publish(
+      topic,
+      message,
+      { qos: this._qos, ...options },
+      err => {
+        if (err) {
+          this._log.warn(
+            `Could not publish MQTT message because: ${err.message}`
+          )
+        }
       }
-    })
+    )
   }
 
   _mqttSubscribe (topic, options) {
-    this._client.subscribe(topic, { qos: this._qos, ...options }, (err, granted) => {
-      if (err) {
-        this._log.warn(`Could not subscribe to topic '${topic}', because: ${err.message}`)
-      } else {
-        if (granted.length === 0) {
-          this._log.debug(`Already subscribed to topic '${topic}'`)
+    this._client.subscribe(
+      topic,
+      { qos: this._qos, ...options },
+      (err, granted) => {
+        if (err) {
+          this._log.warn(
+            `Could not subscribe to topic '${topic}', because: ${err.message}`
+          )
+        } else {
+          if (granted.length === 0) {
+            this._log.debug(`Already subscribed to topic '${topic}'`)
+          }
         }
       }
-    })
+    )
   }
 
   _mqttUnsubscribe (topic, options) {
-    this._client.unsubscribe(topic, options, (err) => {
+    this._client.unsubscribe(topic, options, err => {
       if (err) {
-        this._log.warn(`Could not unsubscribe from topic: ${topic} because: ${err.message}`)
+        this._log.warn(
+          `Could not unsubscribe from topic: ${topic} because: ${err.message}`
+        )
       }
     })
   }
@@ -377,7 +366,7 @@ class VrpcAgent extends EventEmitter {
   }
 
   async _ensureConnected () {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       if (this._client.connected) {
         resolve()
       } else {
@@ -386,11 +375,11 @@ class VrpcAgent extends EventEmitter {
     })
   }
 
-  _handleVrpcCallback (jsonString, jsonObject) {
-    const { sender } = jsonObject
+  _handleVrpcCallback (json) {
+    const { s } = json
     try {
-      this._log.debug(`Forwarding callback to: ${sender} with payload:`, jsonObject)
-      this._mqttPublish(sender, jsonString)
+      this._log.debug(`Forwarding callback to: ${s} with payload:`, json)
+      this._mqttPublish(s, VrpcAgent._stringifySafely(json))
     } catch (err) {
       this._log.warn(
         err,
@@ -399,10 +388,29 @@ class VrpcAgent extends EventEmitter {
     }
   }
 
+  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) {
       this._publishAgentInfoMessage()
+      const classes = this._getClasses()
+      classes.forEach(className => {
+        this._publishClassInfoMessage(className)
+      })
       this.emit('connect')
       this._isReconnect = false
       return
@@ -424,6 +432,13 @@ class VrpcAgent extends EventEmitter {
     classes.forEach(className => {
       this._publishClassInfoMessage(className)
     })
+    // Register all pre-existing instances
+    for (const [
+      instanceId,
+      { className }
+    ] of VrpcAdapter._instances.entries()) {
+      this._subscribeToMethodsOfNewInstance(className, instanceId)
+    }
     this.emit('connect')
   }
 
@@ -441,7 +456,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(
@@ -479,7 +495,7 @@ class VrpcAgent extends EventEmitter {
       const json = JSON.parse(data.toString())
       this._log.debug(`Message arrived with topic: ${topic} and payload:`, json)
       const tokens = topic.split('/')
-      const [,, className, instance, method] = tokens
+      const [, , className, instance, method] = tokens
 
       // Special case: clientInfo message
       if (tokens.length === 4 && tokens[3] === '__clientInfo__') {
@@ -494,142 +510,136 @@ 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)
 
       // 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)
-      }
+      this._mqttPublish(json.s, VrpcAgent._stringifySafely(json))
     } catch (err) {
-      this._log.error(err, `Problem while handling incoming message: ${err.message}`)
+      this._log.error(
+        err,
+        `Problem while handling incoming message: ${err.message}`
+      )
     }
   }
 
   _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)
-      if (entry) { // anonymous
+      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 }
+          // TODO Do not mutate!
           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)
-    if (entry) { // already seen
+  _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)) {
+    } else {
+      // new instance
+      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)
-    if (entry) { // already seen
+  _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)) {
+    } else {
+      // new instance
+      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}`)
         }
       }
     })
     if (!found) {
-      this._log.warn(`Failed un-registering not registered instance: ${instanceId}`)
+      this._log.warn(
+        `Failed un-registering not registered instance: ${instanceId}`
+      )
       return false
     }
     return true
@@ -678,7 +688,7 @@ class VrpcAgent extends EventEmitter {
  * @event VrpcAgent#connect
  * @type {Object}
  * @property {Boolean} sessionPresent - A session from a previous connection is already present
-*/
+ */
 
 /**
  * Event 'reconnect'
@@ -686,7 +696,7 @@ class VrpcAgent extends EventEmitter {
  * Emitted when a reconnect starts.
  *
  * @event VrpcAgent#reconnect
-*/
+ */
 
 /**
  * Event 'close'
@@ -729,4 +739,14 @@ class VrpcAgent extends EventEmitter {
  * @event VrpcAgent#end
  */
 
+/**
+ * Event 'clientGone'
+ *
+ * Emitted when a VRPC client exited that before produced state (e.g. created
+ * an anonymous or named instance).
+ *
+ * @event VrpcAgent#clientGone
+ * @type {String} clientId
+ */
+
 module.exports = VrpcAgent