vrpc 2.5.1 → 3.0.0-alpha.3

package/vrpc/{VrpcRemote.js → VrpcClient.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>.
@@ -39,16 +39,19 @@ SOFTWARE.
 
 const os = require('os')
 const crypto = require('crypto')
+const { nanoid } = require('nanoid')
 const mqtt = require('mqtt')
 const EventEmitter = require('events')
 
+const VRPC_PROTOCOL_VERSION = 3
+
 /**
  * Client capable of creating proxy objects and remotely calling
  * functions as provided through one or more (distributed) agents.
  *
  * @extends EventEmitter
  */
-class VrpcRemote extends EventEmitter {
+class VrpcClient extends EventEmitter {
   /**
    * Constructs a remote client, able to communicate with any distributed agents
    *
@@ -66,7 +69,7 @@ class VrpcRemote extends EventEmitter {
    * @param {Object} [options.log=console] Log object (must support debug, info, warn, and error level)
    * @param {Boolean} [options.bestEffort=false] If true, message will be sent with best effort, i.e. no caching if offline
    * @example
-   * const client = new VrpcRemote({
+   * const client = new VrpcClient({
    *   domain: 'public.vrpc',
    *   broker: 'mqtt://vrpc.io'
    * })
@@ -86,11 +89,15 @@ class VrpcRemote extends EventEmitter {
     // domain sanity check
     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: "+", "/", "#", "*"'
+      )
     }
     // agent sanity check
     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: "+", "/", "#"'
+      )
     }
     this._token = token
     this._username = username
@@ -101,12 +108,13 @@ class VrpcRemote extends EventEmitter {
     this._timeout = timeout
     this._qos = this._qos = bestEffort ? 0 : 1
 
-    this._instance = crypto.randomBytes(2).toString('hex')
+    this._instance = nanoid(8)
     this._mqttClientId = this._createMqttClientId()
     this._vrpcClientId = this._createVrpcClientId()
     this._agents = {}
     this._eventEmitter = new EventEmitter()
     this._invokeId = 0
+    this._proxyId = 0
     this._client = null
     this._cachedSubscriptions = new Map()
     this._proxies = {}
@@ -118,6 +126,15 @@ class VrpcRemote extends EventEmitter {
     }
   }
 
+  /**
+   * Provides a unique id for this client instance
+   *
+   * @returns {String} clientId
+   */
+  getClientId () {
+    return this._vrpcClientId
+  }
+
   /**
    * Actually connects to the MQTT broker.
    *
@@ -154,15 +171,15 @@ class VrpcRemote extends EventEmitter {
     if (password === undefined) delete options.password
     this._client = mqtt.connect(this._broker, options)
 
-    this._client.on('error', (err) => {
+    this._client.on('error', err => {
       this.emit('error', err)
     })
 
-    this._client.stream.on('error', (err) => {
+    this._client.stream.on('error', err => {
       this.emit('error', err)
     })
 
-    this.on('error', (err) => {
+    this.on('error', err => {
       this._log.debug(`Encountered MQTT error: ${err.message}`)
     })
 
@@ -194,7 +211,7 @@ class VrpcRemote extends EventEmitter {
         this._agents[agent].hostname = hostname
         this._agents[agent].version = version
         this.emit('agent', { domain, agent, status, hostname, version })
-      // ClassInfo message
+        // ClassInfo message
       } else if (instance === '__classInfo__') {
         // Json properties: { klass, instances, memberFunctions, staticFunctions }
         const json = JSON.parse(message.toString())
@@ -212,24 +229,23 @@ class VrpcRemote extends EventEmitter {
           staticFunctions,
           meta
         } = json
-        if (removed.length !== 0) this.emit('instanceGone', removed, { domain, agent, className })
-        if (added.length !== 0) this.emit('instanceNew', added, { domain, agent, className })
-        this.emit(
-          'class',
-          {
-            domain,
-            agent,
-            className,
-            instances,
-            memberFunctions,
-            staticFunctions,
-            meta
-          }
-        )
-      // RPC message
+        if (removed.length !== 0)
+          this.emit('instanceGone', removed, { domain, agent, className })
+        if (added.length !== 0)
+          this.emit('instanceNew', added, { domain, agent, className })
+        this.emit('class', {
+          domain,
+          agent,
+          className,
+          instances,
+          memberFunctions,
+          staticFunctions,
+          meta
+        })
+        // RPC message
       } else {
-        const { id, data } = JSON.parse(message.toString())
-        this._eventEmitter.emit(id, data)
+        const { i, a, e, r } = JSON.parse(message.toString())
+        this._eventEmitter.emit(i, { a, e, r })
       }
     })
     await new Promise((resolve, reject) => {
@@ -243,11 +259,6 @@ class VrpcRemote extends EventEmitter {
     })
   }
 
-  async connected () {
-    this._indicateDeprecation('VrpcRemote.connected(): This API usage is deprecated, use `connect()` instead.')
-    return this.connect()
-  }
-
   /**
    * Creates a new remote instance and provides a proxy to it.
    *
@@ -296,23 +307,20 @@ class VrpcRemote extends EventEmitter {
    */
   async create ({
     className,
-    instance,
+    instance = nanoid(8),
     args = [],
     agent = this._agent,
-    cacheProxy = false
+    cacheProxy = false,
+    isIsolated = false
   } = {}) {
     if (agent === '*') throw new Error('Agent must be specified')
-    const data = instance ? { _1: instance } : {}
-    const offset = instance ? 2 : 1
-    args.forEach((value, index) => {
-      data[`_${index + offset}`] = value
-    })
     const json = {
-      context: className,
-      method: instance ? '__createNamed__' : '__create__',
-      id: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
-      sender: `${this._domain}/${os.hostname()}/${this._instance}`,
-      data
+      c: className,
+      f: isIsolated ? '__createIsolated__' : '__createShared__',
+      i: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
+      s: `${this._domain}/${os.hostname()}/${this._instance}`,
+      a: [instance, ...args],
+      v: VRPC_PROTOCOL_VERSION
     }
     const proxy = await this._getProxy(agent, className, json)
     if (instance && cacheProxy) this._proxies[instance] = proxy
@@ -328,36 +336,15 @@ class VrpcRemote extends EventEmitter {
    *
    * @param {String} instance The instance to be retrieved
    * @param {Object} [options] Explicitly define agent and class
-   * @param {String} options.className Name of the instance's class
-   * @param {String} options.agent Agent name. If not provided class default is used
-   * @param {bool} options.noWait If true immediately fail if instance could not be found in local cache
+   * @param {String} [options.className] Name of the instance's class
+   * @param {String} [options.agent] Agent name. If not provided class default is used as priority hit
+   * @param {bool} [options.noWait=false] If true immediately fail if instance could not be found in local cache
    * @returns {Promise<Proxy>} Proxy object reflecting the remotely existing instance
    */
-  async getInstance (instance, options) {
+  async getInstance (instance, options = {}) {
     if (this._proxies[instance]) return this._proxies[instance]
-    if (typeof instance === 'string') {
-      const {
-        agent,
-        className,
-        instance: instanceString
-      } = await this._getInstanceData(instance, options)
-      return this._createProxy(agent, className, instanceString)
-    } else { // deprecate this
-      this._indicateDeprecation(
-        'VrpcRemote.getInstance(): ' +
-        'Using an object as single argument is deprecated, ' +
-        'use "getInstance(instance, options)" instead.'
-      )
-      const fakedOptions = { ...instance }
-      const fakedInstance = fakedOptions.instance
-      delete fakedOptions.instance
-      const {
-        agent,
-        className,
-        instance: instanceString
-      } = await this._getInstanceData(fakedInstance, fakedOptions)
-      return this._createProxy(agent, className, instanceString)
-    }
+    const { agent, className } = await this._getInstanceData(instance, options)
+    return this._createProxy(agent, className, instance)
   }
 
   /**
@@ -369,29 +356,18 @@ class VrpcRemote extends EventEmitter {
    * @param {String} instance The instance to be deleted
    * @param {Object} [options] Explicitly define agent and class
    * @param {String} options.className Name of the instance's class
-   * @param {String} options.agent Agent name. If not provided class default is used
+   * @param {String} options.agent Agent name. If not provided class default is used as priority hit
    * @returns {Promise<Boolean>} true if successful, false otherwise
    */
-  async delete (instance, options) {
-    let instanceData = { agent: this._agent }
-    if (typeof instance === 'string') {
-      instanceData = await this._getInstanceData(instance)
-      if (options) instanceData = { ...options, ...instanceData }
-    } else { // deprecate this
-      this._indicateDeprecation(
-        'VrpcRemote.delete(): ' +
-        'Using an object as single argument is deprecated, ' +
-        'use "delete(instance, options)" instead.'
-      )
-      instanceData = { ...instanceData, ...instance }
-    }
-    const { agent, className, instance: instanceString } = instanceData
+  async delete (instance, options = {}) {
+    const { agent, className } = await this._getInstanceData(instance, options)
     const json = {
-      context: className,
-      method: '__delete__',
-      id: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
-      sender: `${this._domain}/${os.hostname()}/${this._instance}`,
-      data: { _1: instanceString }
+      c: className,
+      f: '__delete__',
+      i: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
+      s: `${this._domain}/${os.hostname()}/${this._instance}`,
+      a: [instance],
+      v: VRPC_PROTOCOL_VERSION
     }
     const topic = `${this._domain}/${agent}/${className}/__static__/__delete__`
     this._mqttPublish(topic, JSON.stringify(json))
@@ -415,12 +391,15 @@ class VrpcRemote extends EventEmitter {
     args = [],
     agent = this._agent
   } = {}) {
+    const wrapped = this._wrapArguments(className, functionName, ...args)
+    if (!wrapped) return // Skipping remote call -> handled locally
     const json = {
-      context: className,
-      method: functionName,
-      id: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
-      sender: this._vrpcClientId,
-      data: this._packData(className, functionName, ...args)
+      c: className,
+      f: functionName,
+      i: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
+      s: this._vrpcClientId,
+      a: wrapped,
+      v: VRPC_PROTOCOL_VERSION
     }
     const topic = `${this._domain}/${agent}/${className}/__static__/${functionName}`
     await this._waitUntilClassIsOnline(agent, className)
@@ -430,19 +409,23 @@ class VrpcRemote extends EventEmitter {
 
   /**
    * Calls the same function on all instances of a given class and returns an
-   * aggregated result.
+   * aggregated result. It as well allows for batch event and callback
+   * registrations. In this case the instanceId of the emitter is injected as
+   * first argument of any event callback.
    *
    * NOTE: When no agent was specified as class default and no agent is
    * specified when calling this function, callAll will act on the requested
-   * class across all available agents. The same is true when explicitly using
-   * a wildcard (*) as agent value.
+   * class across all available agents. The same is true when explicitly using a
+   * wildcard (*) as agent value.
    *
    * @param {Object} options
    * @param {String} options.className Name of the static function's class
-   * @param {Array} [options.args] Positional arguments of the static function call
-   * @param {String} [options.agent] Agent name. If not provided class default is used
-   * @returns {Promise<Object[]>} An array of objects `{ id, val, err }` carrying
-   * the instance id, the return value and potential errors
+   * @param {Array} [options.args] Positional arguments of the static function
+   * call
+   * @param {String} [options.agent] Agent name. If not provided class default
+   * is used
+   * @returns {Promise<Object[]>} An array of objects `{ id, val, err }`
+   * carrying the instance id, the return value and potential errors
    */
   async callAll ({
     className,
@@ -450,20 +433,26 @@ class VrpcRemote extends EventEmitter {
     args = [],
     agent = this._agent
   } = {}) {
-    const data = { _1: functionName }
-    args.forEach((value, index) => (data[`_${index + 2}`] = value))
     const json = {
-      context: className,
-      method: functionName,
-      id: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
-      sender: this._vrpcClientId,
-      data
+      c: className,
+      f: functionName,
+      i: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
+      s: this._vrpcClientId,
+      a: [],
+      v: VRPC_PROTOCOL_VERSION
     }
     if (agent === '*') {
       const result = []
       const agents = this.getAvailableAgents()
       for (const x of agents) {
         const topic = `${this._domain}/${x}/${className}/__static__/__callAll__`
+        const wrapped = this._wrapArguments(
+          `${x}-${className}`,
+          functionName,
+          ...args
+        )
+        if (!wrapped) continue // using cache
+        json.a = [functionName, ...wrapped]
         await this._waitUntilClassIsOnline(x, className)
         this._mqttPublish(topic, JSON.stringify(json))
         const tmp = await this._handleAgentAnswer(json)
@@ -472,41 +461,22 @@ class VrpcRemote extends EventEmitter {
       return result
     }
     const topic = `${this._domain}/${agent}/${className}/__static__/__callAll__`
+    const wrapped = this._wrapArguments(
+      `${agent}-${className}`,
+      functionName,
+      ...args
+    )
+    if (!wrapped) return // using cache
+    json.a = [functionName, ...wrapped]
     await this._waitUntilClassIsOnline(agent, className)
     this._mqttPublish(topic, JSON.stringify(json))
     return this._handleAgentAnswer(json)
   }
 
-  /**
-   * Retrieves all agents, instances, classes, member and static
-   * functions potentially available for remote control.
-   * @deprecated
-  * @returns {Object} SystemInformation
-   * ```ts
-   * type SystemInformation = {
-   *   [domain].agents[agent].status: string, // 'offline' or 'online'
-   *   [domain].agents[agent].hostname: string,
-   *   [domain].agents[agent].version: string,
-   *   [domain].agents[agent].classes[className].instances: string[],
-   *   [domain].agents[agent].classes[className].memberFunctions: string[],
-   *   [domain].agents[agent].classes[className].staticFunctions: string[],
-   *   [domain].agents[agent].classes[className].meta?: MetaData
-   * }
-   * ```
-   */
-  getAvailabilities () {
-    this._indicateDeprecation(
-      'VrpcRemote.getAvailabilities(): ' +
-      'This function is deprecated and will be removed soon, ' +
-      'use `getSystemInformation()` instead.'
-    )
-    return { [this._domain]: { agents: this._agents } }
-  }
-
   /**
    * Retrieves all information about the currently available components.
    *
-  * @returns {Object} SystemInformation
+   * @returns {Object} SystemInformation
    * ```ts
    * type SystemInformation = {
    *   [agent].status: string, // 'offline' or 'online'
@@ -523,21 +493,6 @@ class VrpcRemote extends EventEmitter {
     return this._agents
   }
 
-  /**
-   * Retrieves all domains on which agents can be remote controlled
-   *
-   * @deprecated
-   * @returns {Array} Array of domain names
-   */
-  getAvailableDomains () {
-    this._indicateDeprecation(
-      'VrpcRemote.getAvailableDomains(): ' +
-      'this function will be removed in the next major release, as the client' +
-      'works with a single domain anyways'
-    )
-    return [this._domain]
-  }
-
   /**
    * Retrieves all available agents.
    *
@@ -545,19 +500,7 @@ class VrpcRemote extends EventEmitter {
    * @param {Boolean} [options.mustBeOnline=true] Only retrieve currently online agents
    * @returns {Array} Array of agent names.
    */
-  getAvailableAgents (options = {}) {
-    /// DEPRECATION INFORMATION AND WORKAROUND - TO BE REMOVED IN 3.x
-    // `options = {}` was `domain = this._domain` before
-    if (typeof options === 'string') {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableAgents(): ' +
-        'Providing a domain here has no effect and will be an error in future.'
-      )
-      options = { mustBeOnline: true }
-    }
-    ///
-
-    const { mustBeOnline = true } = options
+  getAvailableAgents ({ mustBeOnline = true } = {}) {
     const agents = []
     if (mustBeOnline) {
       // loop agents
@@ -578,31 +521,7 @@ class VrpcRemote extends EventEmitter {
    * @param {Boolean} [options.mustBeOnline=true] Only retrieve currently online classes
    * @returns {Array} Array of class names.
    */
-  getAvailableClasses (options = { agent: this._agent, mustBeOnline: true }, domain) {
-    /// DEPRECATION INFORMATION AND WORKAROUND - TO BE REMOVED IN 3.x
-    let agent = this._agent
-    let mustBeOnline = true
-    // `options = {}` was `agent = this._agent` before
-    if (typeof options === 'string') {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableClasses(): ' +
-        'setting the agent as string argument is deprecated.`' +
-         'Use `{ agent: <myAgent> }` instead.'
-      )
-      agent = options
-    } else {
-      agent = options.agent
-      mustBeOnline = options.mustBeOnline
-    }
-    // was `domain = this._domain` before
-    if (domain) {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableClasses(): ' +
-        'Providing a domain here has no effect and will be an error in future.'
-      )
-    }
-    ///
-
+  getAvailableClasses ({ agent = this._agent, mustBeOnline = true } = {}) {
     if (agent === '*') throw new Error('Agent must be specified')
     if (!this._agents[agent]) return []
     const { classes, status } = this._agents[agent]
@@ -613,41 +532,17 @@ class VrpcRemote extends EventEmitter {
   /**
    * Retrieves all (named) instances on specific class and agent.
    *
-   * @param {String} className Class name
    * @param {Object} [options]
+   * @param {String} options.className Class name
    * @param {String} [options.agent] Agent name. If not provided class default is used
    * @param {Boolean} [options.mustBeOnline=true] Only retrieve currently online classes
    * @returns {Array} Array of instance names
    */
-  getAvailableInstances (
+  getAvailableInstances ({
     className,
-    options = { agent: this._agent, mustBeOnline: true },
-    domain
-  ) {
-    /// DEPRECATION INFORMATION AND WORKAROUND - TO BE REMOVED IN 3.x
-    let agent = this._agent
-    let mustBeOnline = true
-    // `options = {}` was `agent = this._agent` before
-    if (typeof options === 'string') {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableInstances(): ' +
-        'Setting the agent as string argument is deprecated.`' +
-         'Use `{ agent: <myAgent> }` instead.'
-      )
-      agent = options
-    } else {
-      agent = options.agent
-      mustBeOnline = options.mustBeOnline
-    }
-    // was `domain = this._domain` before
-    if (domain) {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableInstances(): ' +
-        'Providing a domain here has no effect and will be an error in future.'
-      )
-    }
-    ///
-
+    agent = this._agent,
+    mustBeOnline = true
+  } = {}) {
     if (agent === '*') throw new Error('Agent must be specified')
     if (!this._agents[agent]) return []
     const { classes, status } = this._agents[agent]
@@ -658,41 +553,17 @@ class VrpcRemote extends EventEmitter {
   /**
    * Retrieves all member functions of specific class and agent.
    *
-   * @param {String} className Class name
    * @param {Object} [options]
+   * @param {String} options.className Class name
    * @param {String} [options.agent] Agent name. If not provided class default is used
    * @param {Boolean} [options.mustBeOnline=true] Only retrieve currently online classes
    * @returns {Array} Array of member function names
    */
-  getAvailableMemberFunctions (
+  getAvailableMemberFunctions ({
     className,
-    options = { agent: this._agent, mustBeOnline: true },
-    domain
-  ) {
-    /// DEPRECATION INFORMATION AND WORKAROUND - TO BE REMOVED IN 3.x
-    let agent = this._agent
-    let mustBeOnline = true
-    // `options = {}` was `agent = this._agent` before
-    if (typeof options === 'string') {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableMemberFunctions(): ' +
-        'Setting the agent as string argument is deprecated.`' +
-         'Use `{ agent: <myAgent> }` instead.'
-      )
-      agent = options
-    } else {
-      agent = options.agent
-      mustBeOnline = options.mustBeOnline
-    }
-    // was `domain = this._domain` before
-    if (domain) {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableMemberFunctions(): ' +
-        'Providing a domain here has no effect and will be an error in future.'
-      )
-    }
-    ///
-
+    agent = this._agent,
+    mustBeOnline = true
+  } = {}) {
     if (agent === '*') throw new Error('Agent must be specified')
     if (!this._agents[agent]) return []
     const { classes, status } = this._agents[agent]
@@ -705,41 +576,17 @@ class VrpcRemote extends EventEmitter {
   /**
    * Retrieves all static functions of specific class and agent.
    *
-   * @param {String} className Class name
    * @param {Object} [options]
+   * @param {String} options.className Class name
    * @param {String} [options.agent] Agent name. If not provided class default is used
    * @param {Boolean} [options.mustBeOnline=true] Only retrieve currently online classes
    * @returns {Array} Array of static function names
    */
-  getAvailableStaticFunctions (
+  getAvailableStaticFunctions ({
     className,
-    options = { agent: this._agent, mustBeOnline: true },
-    domain
-  ) {
-    /// DEPRECATION INFORMATION AND WORKAROUND - TO BE REMOVED IN 3.x
-    let agent = this._agent
-    let mustBeOnline = true
-    // `options = {}` was `agent = this._agent` before
-    if (typeof options === 'string') {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableStaticFunctions(): ' +
-        'Setting the agent as string argument is deprecated.`' +
-         'Use `{ agent: <myAgent> }` instead.'
-      )
-      agent = options
-    } else {
-      agent = options.agent
-      mustBeOnline = options.mustBeOnline
-    }
-    // was `domain = this._domain` before
-    if (domain) {
-      this._indicateDeprecation(
-        'VrpcRemote.getAvailableStaticFunctions(): ' +
-        'Providing a domain here has no effect and will be an error in future.'
-      )
-    }
-    ///
-
+    agent = this._agent,
+    mustBeOnline = true
+  } = {}) {
     if (agent === '*') throw new Error('Agent must be specified')
     if (!this._agents[agent]) return []
     const { classes, status } = this._agents[agent]
@@ -757,10 +604,7 @@ class VrpcRemote extends EventEmitter {
    * @param {String} options.agent Agent name. If not provided class default is used
    * @returns {Promise} Promise that resolves once re-connected
    */
-  async reconnectWithToken (
-    token,
-    { agent = this._agent } = {}
-  ) {
+  async reconnectWithToken (token, { agent = this._agent } = {}) {
     this._token = token
     this._agent = agent
     this._client.end(() => this.connect())
@@ -799,19 +643,29 @@ class VrpcRemote extends EventEmitter {
   async end () {
     this._mqttPublish(
       `${this._vrpcClientId}/__clientInfo__`,
-      JSON.stringify({ status: 'offline' })
+      JSON.stringify({ status: 'offline', v: VRPC_PROTOCOL_VERSION })
     )
     return new Promise(resolve => this._client.end(false, {}, resolve))
   }
 
   _createMqttClientId () {
-    const clientInfo = os.arch() + JSON.stringify(os.cpus()) + os.homedir() +
-    os.hostname() + JSON.stringify(os.networkInterfaces()) + os.platform() +
-    os.release() + os.totalmem() + os.type()
+    const clientInfo =
+      os.arch() +
+      JSON.stringify(os.cpus()) +
+      os.homedir() +
+      os.hostname() +
+      JSON.stringify(os.networkInterfaces()) +
+      os.platform() +
+      os.release() +
+      os.totalmem() +
+      os.type()
     // console.log('ClientInfo:', clientInfo)
-    const md5 = crypto.createHash('md5').update(clientInfo).digest('hex').substr(0, 13)
-    // FIXME (3.x): use vrpcp -> vrpcc
-    return `vrpcp${this._instance}X${md5}` // 5 + 4 + 1 + 13 = 23 (max clientId)
+    const md5 = crypto
+      .createHash('md5')
+      .update(clientInfo)
+      .digest('hex')
+      .substr(0, 12)
+    return `vc3${this._instance}${md5}` // 3 + 8 + 12 = 23 (max clientId)
   }
 
   _createVrpcClientId () {
@@ -819,29 +673,44 @@ class VrpcRemote 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}`)
+    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}`)
+          }
         }
       }
-    })
+    )
   }
 
   _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}`
+        )
       }
     })
   }
@@ -853,25 +722,22 @@ class VrpcRemote extends EventEmitter {
   }
 
   async _getProxy (agent, className, json) {
-    const { method } = json
-    const topic = `${this._domain}/${agent}/${className}/__static__/${method}`
+    const { f, i } = json
+    const topic = `${this._domain}/${agent}/${className}/__static__/${f}`
     await this._waitUntilClassIsOnline(agent, className)
     this._mqttPublish(topic, JSON.stringify(json))
     return new Promise((resolve, reject) => {
       const msg = `Proxy creation for class "${className}" on agent "${agent}" and domain "${this._domain}" timed out (> ${this._timeout} ms)`
-      const timer = setTimeout(
-        () => {
-          this._eventEmitter.removeAllListeners(json.id)
-          reject(new Error(msg))
-        },
-        this._timeout
-      )
-      this._eventEmitter.once(json.id, data => {
+      const timer = setTimeout(() => {
+        this._eventEmitter.removeAllListeners(i)
+        reject(new Error(msg))
+      }, this._timeout)
+      this._eventEmitter.once(i, ({ e, r }) => {
         clearTimeout(timer)
-        if (data.e) {
-          reject(new Error(data.e))
+        if (e) {
+          reject(new Error(e))
         } else {
-          const proxy = this._createProxy(agent, className, data.r)
+          const proxy = this._createProxy(agent, className, r)
           resolve(proxy)
         }
       })
@@ -891,7 +757,11 @@ class VrpcRemote extends EventEmitter {
       }
       timer = setTimeout(() => {
         this.removeListener('class', checkClass)
-        reject(new Error(`Proxy creation for class "${className}" on agent "${agent}" and domain "${this._domain}" timed out (> ${this._timeout} ms)`))
+        reject(
+          new Error(
+            `Proxy creation for class "${className}" on agent "${agent}" and domain "${this._domain}" timed out (> ${this._timeout} ms)`
+          )
+        )
       }, this._timeout)
       this.on('class', checkClass)
     })
@@ -907,10 +777,11 @@ class VrpcRemote extends EventEmitter {
 
   _createProxy (agent, className, instance) {
     const targetTopic = `${this._domain}/${agent}/${className}/${instance}`
-    const proxyId = crypto.randomBytes(2).toString('hex')
+    const proxyId = `${this._instance}-${this._proxyId++}`
     const proxy = {
-      _targetId: instance,
-      _proxyId: proxyId
+      vrpcClientId: this._vrpcClientId,
+      vrpcInstanceId: instance,
+      vrpcProxyId: proxyId
     }
     let functions = this._agents[agent].classes[className].memberFunctions
     // Strip off argument signature
@@ -924,37 +795,38 @@ class VrpcRemote extends EventEmitter {
     // Build proxy
     uniqueFuncs.forEach(name => {
       proxy[name] = async (...args) => {
+        const wrapped = this._wrapArguments(proxyId, name, ...args)
+        if (!wrapped) return // Skipping remote call -> handled locally
         try {
           const json = {
-            context: instance,
-            method: name,
-            id: `${this._instance}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`,
-            sender: this._vrpcClientId,
-            data: this._packData(proxyId, name, ...args)
+            c: instance,
+            f: name,
+            i: `${this._instance}-${this._invokeId++ %
+              Number.MAX_SAFE_INTEGER}`,
+            s: this._vrpcClientId,
+            a: wrapped,
+            v: VRPC_PROTOCOL_VERSION
           }
-          // Skipping remote call -> handled locally
-          if (json.data === null) return
           this._mqttPublish(`${targetTopic}/${name}`, JSON.stringify(json))
           return this._handleAgentAnswer(json)
         } catch (err) {
-          throw new Error(`Could not remotely call "${name}" because: ${err.message}`)
+          throw new Error(
+            `Could not remotely call "${name}" because: ${err.message}`
+          )
         }
       }
     })
     return proxy
   }
 
-  async _handleAgentAnswer ({ id, context, method }) {
+  async _handleAgentAnswer ({ i, c, f }) {
     return new Promise((resolve, reject) => {
-      const msg = `Function call "${context}::${method}()" timed out (> ${this._timeout} ms)`
-      const timer = setTimeout(
-        () => {
-          this._eventEmitter.removeAllListeners(id)
-          reject(new Error(msg))
-        },
-        this._timeout
-      )
-      this._eventEmitter.once(id, data => {
+      const msg = `Function call "${c}::${f}()" timed out (> ${this._timeout} ms)`
+      const timer = setTimeout(() => {
+        this._eventEmitter.removeAllListeners(i)
+        reject(new Error(msg))
+      }, this._timeout)
+      this._eventEmitter.once(i, data => {
         clearTimeout(timer)
         if (data.e) {
           reject(new Error(data.e))
@@ -976,7 +848,7 @@ class VrpcRemote extends EventEmitter {
 
   async _waitForInstance (instance, options = {}) {
     return new Promise((resolve, reject) => {
-      const handler = (timer) => (instances, { agent, className }) => {
+      const handler = timer => (instances, { agent, className }) => {
         if (instances.includes(instance)) {
           if (options.agent && agent !== options.agent) return
           if (options.className && className !== options.className) return
@@ -985,75 +857,64 @@ class VrpcRemote extends EventEmitter {
           resolve({ agent, className, instance })
         }
       }
-      const timer = setTimeout(
-        () => {
-          this.removeListener('instanceNew', handler(timer))
-          const msg = `Could not find instance: ${instance} (> ${this._timeout} ms)`
-          reject(new Error(msg))
-        },
-        this._timeout
-      )
+      const timer = setTimeout(() => {
+        this.removeListener('instanceNew', handler(timer))
+        const msg = `Could not find instance: ${instance} (> ${this._timeout} ms)`
+        reject(new Error(msg))
+      }, this._timeout)
       this.on('instanceNew', handler(timer))
     })
   }
 
-  _packData (proxyId, functionName, ...args) {
-    const data = {}
+  _wrapArguments (remoteId, functionName, ...args) {
+    const wrapped = []
     let isHandledLocally = false
-    args.forEach((value, index) => {
+    args.forEach((x, i) => {
       // Check whether provided argument is a function
-      if (this._isFunction(value)) {
+      if (this._isFunction(x)) {
         // Check special case of an event emitter registration
         // We test three conditions:
         // 1) functionName must be "on"
         // 2) callback is second argument
         // 3) first argument was string
-        if (functionName === 'on' &&
-          index === 1 &&
-          typeof args[0] === 'string'
-        ) {
-          const id = this._addEventSubscription(proxyId, args[0], value)
+        if (functionName === 'on' && i === 1 && typeof args[0] === 'string') {
+          const id = this._addEventSubscription(remoteId, args[0], x)
           if (!id) isHandledLocally = true
-          data[`_${index + 1}`] = id
+          wrapped.push(id)
         } else if (
           (functionName === 'off' || functionName === 'removeListener') &&
-          index === 1 &&
+          i === 1 &&
           typeof args[0] === 'string'
         ) {
-          const id = this._removeEventSubscription(proxyId, args[0], value)
+          const id = this._removeEventSubscription(remoteId, args[0], x)
           if (!id) isHandledLocally = true
-          data[`_${index + 1}`] = id
-        // Regular function callback
+          wrapped.push(id)
+          // Regular function callback
         } else {
-          const id = `__f__${proxyId}-${functionName}-${index}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`
-          data[`_${index + 1}`] = id
-          this._eventEmitter.once(id, data => {
-            const args = Object.keys(data).sort()
-              .filter(x => x[0] === '_')
-              .map(x => data[x])
-            value.apply(null, args) // This is the actual function call
+          const id = `__f__${remoteId}-${functionName}-${i}-${this._invokeId++ %
+            Number.MAX_SAFE_INTEGER}`
+          wrapped.push(id)
+          this._eventEmitter.once(id, ({ a }) => {
+            x.apply(null, a) // This is the actual function call
           })
         }
-      } else if (this._isEmitter(value)) {
-        const { emitter, event } = value
-        const id = `__f__${proxyId}-${functionName}-${index}-${event}`
-        data[`_${index + 1}`] = id
-        this._eventEmitter.on(id, data => {
-          const args = Object.keys(data).sort()
-            .filter(x => x[0] === '_')
-            .map(x => data[x])
-          emitter.emit(event, ...args)
+      } else if (this._isEmitter(x)) {
+        const { emitter, event } = x
+        const id = `__f__${remoteId}-${functionName}-${i}-${event}`
+        wrapped.push(id)
+        this._eventEmitter.on(id, ({ a }) => {
+          emitter.emit(event, ...a)
         })
       } else {
-        data[`_${index + 1}`] = value
+        wrapped.push(x)
       }
     })
     if (isHandledLocally) return null
-    return data
+    return wrapped
   }
 
-  _addEventSubscription (proxyId, event, callback) {
-    const id = `__f__${proxyId}-${event}`
+  _addEventSubscription (remoteId, event, callback) {
+    const id = `__f__${remoteId}-${event}`
     if (this._cachedSubscriptions.has(id)) {
       this._cachedSubscriptions.get(id).on(id, callback)
       return
@@ -1061,17 +922,14 @@ class VrpcRemote extends EventEmitter {
     const emitter = new EventEmitter()
     emitter.on(id, callback)
     this._cachedSubscriptions.set(id, emitter)
-    this._eventEmitter.on(id, (data) => {
-      const args = Object.keys(data).sort()
-        .filter(x => x[0] === '_')
-        .map(x => data[x])
-      emitter.emit(id, ...args)
+    this._eventEmitter.on(id, ({ a }) => {
+      emitter.emit(id, ...a)
     })
     return id
   }
 
-  _removeEventSubscription (proxyId, event, callback) {
-    const id = `__f__${proxyId}-${event}`
+  _removeEventSubscription (remoteId, event, callback) {
+    const id = `__f__${remoteId}-${event}`
     if (this._cachedSubscriptions.has(id)) {
       const emitter = this._cachedSubscriptions.get(id)
       emitter.removeListener(id, callback)
@@ -1092,8 +950,10 @@ class VrpcRemote extends EventEmitter {
   _isFunction (variable) {
     const getType = {}
     const type = getType.toString.call(variable)
-    return variable &&
+    return (
+      variable &&
       (type === '[object Function]' || type === '[object AsyncFunction]')
+    )
   }
 
   _isEmitter (variable) {
@@ -1106,16 +966,33 @@ class VrpcRemote extends EventEmitter {
     )
   }
 
-  async _getInstanceData (instance, options = {}) {
+  async _getInstanceData (instance, options) {
     const instanceData = this._getInstanceFromCache(instance, options)
     if (!instanceData) {
-      if (options.noWait) throw new Error(`Could not find instance: ${instance}`)
+      if (options.noWait) {
+        throw new Error(`Could not find instance: ${instance}`)
+      }
       return this._waitForInstance(instance, options)
     }
     return instanceData
   }
 
   _getInstanceFromCache (instance, options = {}) {
+    // when no agent is specified, but an explicit class default exists give
+    // such instances priority in being found
+    if (!options.agent && this._agent !== '*') {
+      const { classes, status } = this._agents[this._agent]
+      if (!classes || status === 'offline') {
+        for (const className in classes) {
+          if (options.className && className !== options.className) continue
+          const { instances } = classes[className]
+          if (!instances) continue
+          if (instances.includes(instance)) {
+            return { agent, className, instance }
+          }
+        }
+      }
+    }
     // loop agents
     for (const agent in this._agents) {
       if (options.agent && agent !== options.agent) continue
@@ -1148,7 +1025,7 @@ class VrpcRemote extends EventEmitter {
  * This event is fired whenever an agent is added or removed, or whenever
  * an agent changes its status (switches between online or offline).
  *
- * @event VrpcRemote#agent
+ * @event VrpcClient#agent
  * @param {Object} info
  * @param {String} info.domain - Domain name
  * @param {String} info.agent - Agent name
@@ -1163,7 +1040,7 @@ class VrpcRemote extends EventEmitter {
  * Emitted whenever a class is added or removed, or when instances
  * or functions of this class have changed.
  *
- * @event VrpcRemote#class
+ * @event VrpcClient#class
  * @param {Object} info
  * @param {String} info.domain - Domain name
  * @param {String} info.agent - Agent name
@@ -1175,57 +1052,57 @@ class VrpcRemote extends EventEmitter {
  */
 
 /**
-  * Event 'instanceNew'
-  *
-  * Emitted whenever a new instance was created.
-  *
-  * @event VrpcRemote#instanceNew
-  *
-  * @param {Array.<String>} addedInstances - An array of newly added instances
-  * @param {Object} info
-  * @param {String} info.domain - Domain name
-  * @param {String} info.agent - Agent name
-  * @param {String} info.className - Class name
-  */
+ * Event 'instanceNew'
+ *
+ * Emitted whenever a new instance was created.
+ *
+ * @event VrpcClient#instanceNew
+ *
+ * @param {Array.<String>} addedInstances - An array of newly added instances
+ * @param {Object} info
+ * @param {String} info.domain - Domain name
+ * @param {String} info.agent - Agent name
+ * @param {String} info.className - Class name
+ */
 
 /**
-  * Event 'instanceGone'
-  *
-  * Emitted whenever a new instance was removed.
-  *
-  * @event VrpcRemote#instanceGone
-  *
-  * @param {Array.<String>} removedInstances - An array of removed instances
-  * @param {Object} info
-  * @param {String} info.domain - Domain name
-  * @param {String} info.agent - Agent name
-  * @param {String} info.className - Class name
-  */
+ * Event 'instanceGone'
+ *
+ * Emitted whenever a new instance was removed.
+ *
+ * @event VrpcClient#instanceGone
+ *
+ * @param {Array.<String>} removedInstances - An array of removed instances
+ * @param {Object} info
+ * @param {String} info.domain - Domain name
+ * @param {String} info.agent - Agent name
+ * @param {String} info.className - Class name
+ */
 
 /**
  * Event 'connect'
  *
  * Emitted on successful (re)connection (i.e. connack rc=0).
  *
- * @event VrpcRemote#connect
+ * @event VrpcClient#connect
  * @type {Object}
  * @property {Boolean} sessionPresent - A session from a previous connection is already present
-*/
+ */
 
 /**
  * Event 'reconnect'
  *
  * Emitted when a reconnect starts.
  *
- * @event VrpcRemote#reconnect
-*/
+ * @event VrpcClient#reconnect
+ */
 
 /**
  * Event 'close'
  *
  * Emitted after a disconnection.
  *
- * @event VrpcRemote#close
+ * @event VrpcClient#close
  */
 
 /**
@@ -1233,7 +1110,7 @@ class VrpcRemote extends EventEmitter {
  *
  * Emitted when the client goes offline.
  *
- * @event VrpcRemote#offline
+ * @event VrpcClient#offline
  */
 
 /**
@@ -1248,7 +1125,7 @@ class VrpcRemote extends EventEmitter {
  * - EADDRINUSE
  * - ENOTFOUND
  *
- * @event VrpcRemote#error
+ * @event VrpcClient#error
  * @type {Object} Error
  */
 
@@ -1258,7 +1135,7 @@ class VrpcRemote extends EventEmitter {
  * Emitted when mqtt.Client#end() is called. If a callback was passed to
  * mqtt.Client#end(), this event is emitted once the callback returns.
  *
- * @event VrpcRemote#end
+ * @event VrpcClient#end
  */
 
-module.exports = VrpcRemote
+module.exports = VrpcClient