0.10.0

Better performance for XS >=7.0

packages/xen-api/.gitignore

@@ -1,7 +1,11 @@
-/bower_components/
+/coverage/
 /dist/
+/node_modules/
 
 npm-debug.log
+npm-debug.log.*
+pnpm-debug.log
+pnpm-debug.log.*
+yarn-error.log*
 
-!node_modules/*
-node_modules/*/
+/plot.dat

packages/xen-api/.npmignore

@@ -1,2 +1,24 @@
+/benchmark/
+/benchmarks/
+*.bench.js
+*.bench.js.map
+
+/examples/
+example.js
+example.js.map
+*.example.js
+*.example.js.map
+
+/fixture/
+/fixtures/
+*.fixture.js
+*.fixture.js.map
+*.fixtures.js
+*.fixtures.js.map
+
+/test/
+/tests/
 *.spec.js
 *.spec.js.map
+
+__snapshots__/

packages/xen-api/.travis.yml

@@ -1,5 +1,9 @@
 language: node_js
 node_js:
-  - 'iojs'
-  - '0.12'
-  - '0.10'
+  - stable
+  - 6
+  - 4
+
+# Use containers.
+# http://docs.travis-ci.com/user/workers/container-based-infrastructure/
+sudo: false

packages/xen-api/README.md

@@ -1,7 +1,15 @@
-# xen-api [![Build Status](https://travis-ci.org/js-xen-api.png?branch=master)](https://travis-ci.org/js-xen-api)
+# xen-api [![Build Status](https://travis-ci.org/vatesfr/xen-api.png?branch=master)](https://travis-ci.org/vatesfr/xen-api)
 
 > Connector to the Xen API
 
+Tested with:
+
+- XenServer 7.1
+- XenServer 7
+- XenServer 6.5
+- XenServer 6.2
+- XenServer 5.6
+
 ## Install
 
 Installation of the [npm package](https://npmjs.org/package/xen-api):
@@ -22,9 +30,18 @@ var xapi = createClient({
   auth: {
     user: 'root',
     password: 'important secret password'
-  }
+  },
+  readOnly: false
 })
+```
 
+Options:
+
+- `url`: address of a host in the pool we are trying to connect to
+- `auth`: credentials used to sign in
+- `readOnly = false`: if true, no methods with side-effects can be called
+
+```js
 // Force connection.
 xapi.connect().catch(error => {
   console.error(error)
@@ -36,6 +53,22 @@ xapi.objects.on('add', function (objects) {
 })
 ```
 
+> Note: all objects are frozen and cannot be altered!
+
+Custom fields on objects (hidden − ie. non enumerable):
+- `$type`: the type of the object (`VM`, `task`, …);
+- `$ref`: the (opaque) reference of the object;
+- `$id`: the identifier of this object (its UUID if any, otherwise its reference);
+- `$pool`: the pool object this object belongs to.
+
+Furthermore, any field containing a reference (or references if an
+array) can be resolved by prepending the field name with a `$`:
+
+```javascript
+console.log(xapi.pool.$master.$resident_VMs[0].name_label)
+// vm1
+```
+
 ### CLI
 
 A CLI is provided to help exploration and discovery of the XAPI.
@@ -45,32 +78,36 @@ A CLI is provided to help exploration and discovery of the XAPI.
 Password: ******
 root@xen1.company.net> xapi.status
 'connected'
-root@xen1.company.net> xapi.pool.master.name_label
+root@xen1.company.net> xapi.pool.master
+'OpaqueRef:ec7c5147-8aee-990f-c70b-0de916a8e993'
+root@xen1.company.net> xapi.pool.$master.name_label
 'xen1'
 ```
 
+To ease searches, `find()` and `findAll()` functions are available:
 
+```
+root@xen1.company.net> findAll({ $type: 'vm' }).length
+183
+```
 
 ## Development
 
-### Installing dependencies
-
 ```
+# Install dependencies
 > npm install
-```
 
-### Compilation
+# Run the tests
+> npm test
 
-The sources files are watched and automatically recompiled on changes.
-
-```
+# Continuously compile
 > npm run dev
-```
 
-### Tests
+# Continuously run the tests
+> npm run dev-test
 
-```
-> npm run test-dev
+# Build for production (automatically called by npm install)
+> npm run build
 ```
 
 ## Contributions
@@ -80,7 +117,7 @@ the code.
 
 You may:
 
-- report any [issue](https://github.com/julien-f/js-xen-api/issues)
+- report any [issue](https://github.com/pbdxen-api/issues)
   you've encountered;
 - fork and create a pull request.
 

packages/xen-api/memory-test.gnu

@@ -0,0 +1,4 @@
+set yrange [ 0 : ]
+set grid
+
+plot for [i=2:4] "plot.dat" using 1:i with lines

packages/xen-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xen-api",
-  "version": "0.5.1",
+  "version": "0.10.0",
   "license": "ISC",
   "description": "Connector to the Xen API",
   "keywords": [
@@ -10,11 +10,11 @@
     "xenapi",
     "xapi"
   ],
-  "homepage": "https://github.com/julien-f/js-xen-api",
-  "bugs": "https://github.com/julien-f/js-xen-api/issues",
+  "homepage": "https://github.com/vatesfr/xen-api",
+  "bugs": "https://github.com/vatesfr/xen-api/issues",
   "repository": {
     "type": "git",
-    "url": "https://github.com/julien-f/js-xen-api.git"
+    "url": "https://github.com/vatesfr/xen-api.git"
   },
   "author": {
     "name": "Julien Fontanet",
@@ -28,39 +28,78 @@
   "files": [
     "dist/"
   ],
+  "engines": {
+    "node": ">=4"
+  },
   "dependencies": {
-    "babel-runtime": "^5",
-    "bluebird": "^2.9.21",
-    "debug": "^2.1.3",
-    "event-to-promise": "^0.3.2",
-    "exec-promise": "^0.5.1",
-    "lodash.find": "^3.2.0",
-    "lodash.findkey": "^3.0.1",
-    "lodash.foreach": "^3.0.2",
-    "lodash.size": "^3.0.0",
-    "lodash.startswith": "^3.0.1",
-    "make-error": "^1.0.2",
-    "minimist": "^1.1.1",
+    "babel-polyfill": "^6.22.0",
+    "blocked": "^1.2.1",
+    "debug": "^2.6.1",
+    "event-to-promise": "^0.8.0",
+    "exec-promise": "^0.6.1",
+    "json-rpc-protocol": "^0.11.2",
+    "kindof": "^2.0.0",
+    "lodash": "^4.17.4",
+    "make-error": "^1.2.1",
+    "minimist": "^1.2.0",
+    "ms": "^1.0.0",
+    "promise-toolbox": "^0.8.0",
     "pw": "0.0.4",
-    "xmlrpc": "^1.3.0",
-    "xo-collection": "0.0.1"
+    "superagent": "^3.5.2",
+    "xmlrpc": "^1.3.2",
+    "xo-collection": "^0.4.1"
   },
   "devDependencies": {
-    "babel": "^5",
-    "mocha": "*",
-    "must": "*",
-    "standard": "*"
+    "babel-cli": "^6.22.2",
+    "babel-eslint": "^7.1.1",
+    "babel-plugin-lodash": "^3.2.11",
+    "babel-preset-env": "^1.1.8",
+    "babel-preset-stage-0": "^6.22.0",
+    "cross-env": "^3.1.4",
+    "dependency-check": "^2.8.0",
+    "husky": "^0.13.1",
+    "jest": "^19.0.0",
+    "rimraf": "^2.5.4",
+    "standard": "^9.0.0"
   },
   "scripts": {
-    "build": "mkdir --parents dist && babel --optional=runtime --compact=true --source-maps --out-dir=dist/ src/",
-    "dev": "mkdir --parents dist && babel --watch --optional=runtime --source-maps --out-dir=dist/ src/",
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "commitmsg": "npm test",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "dev-test": "jest --bail --watch",
+    "plot": "gnuplot -p memory-test.gnu",
+    "posttest": "standard && dependency-check ./package.json",
+    "prebuild": "rimraf dist/",
+    "predev": "npm run prebuild",
     "prepublish": "npm run build",
-    "test": "standard && mocha 'dist/**/*.spec.js'",
-    "test-dev": "standard && mocha --watch --reporter=min 'dist/**/*.spec.js'"
+    "test": "jest"
+  },
+  "babel": {
+    "plugins": [
+      "lodash"
+    ],
+    "presets": [
+      [
+        "env",
+        {
+          "targets": {
+            "node": 4
+          }
+        }
+      ],
+      "stage-0"
+    ]
+  },
+  "jest": {
+    "testPathDirs": [
+      "<rootDir>/src"
+    ],
+    "testRegex": "\\.spec\\.js$"
   },
   "standard": {
     "ignore": [
-      "dist/**"
-    ]
+      "dist"
+    ],
+    "parser": "babel-eslint"
   }
 }

packages/xen-api/src/cli.js

@@ -1,22 +1,48 @@
 #!/usr/bin/env node
 
-import Bluebird, {coroutine} from 'bluebird'
+import 'babel-polyfill'
+
+import blocked from 'blocked'
+import createDebug from 'debug'
 import eventToPromise from 'event-to-promise'
 import execPromise from 'exec-promise'
 import minimist from 'minimist'
 import pw from 'pw'
-import {start as createRepl} from 'repl'
+import { asCallback, fromCallback } from 'promise-toolbox'
+import { filter, find } from 'lodash'
+import { start as createRepl } from 'repl'
 
-import {createClient} from './'
+import { createClient } from './'
 
-const usage = `Usage: xen-api <url> <user>`
+// ===================================================================
 
-const main = coroutine(function * (args) {
+function askPassword (prompt = 'Password: ') {
+  if (prompt) {
+    process.stdout.write(prompt)
+  }
+
+  return new Promise(resolve => {
+    pw(resolve)
+  })
+}
+
+function required (name) {
+  throw new Error(`missing required argument ${name}`)
+}
+
+// ===================================================================
+
+const usage = 'Usage: xen-api <url> <user> [<password>]'
+
+const main = async args => {
   const opts = minimist(args, {
-    boolean: ['help'],
+    boolean: ['help', 'read-only', 'verbose'],
 
     alias: {
-      help: 'h'
+      debounce: 'd',
+      help: 'h',
+      'read-only': 'ro',
+      verbose: 'v'
     }
   })
 
@@ -24,29 +50,55 @@ const main = coroutine(function * (args) {
     return usage
   }
 
-  const [url, user] = opts._
-  if (!url || !user) {
-    throw new Error('missing arguments')
+  if (opts.verbose) {
+    // Does not work perfectly.
+    //
+    // https://github.com/visionmedia/debug/pull/156
+    createDebug.enable('xen-api,xen-api:*')
   }
 
-  process.stdout.write('Password: ')
-  const password = yield new Bluebird(resolve => {
-    pw(resolve)
-  })
+  const [
+    url = required('url'),
+    user = required('user'),
+    password = await askPassword()
+  ] = opts._
 
-  const xapi = createClient({url, auth: {user, password}})
-  yield xapi.connect()
+  {
+    const debug = createDebug('xen-api:perf')
+    blocked(ms => {
+      debug('blocked for %sms', ms | 0)
+    })
+  }
+
+  const xapi = createClient({
+    url,
+    auth: { user, password },
+    debounce: opts.debounce != null ? +opts.debounce : null,
+    readOnly: opts.ro
+  })
+  await xapi.connect()
 
   const repl = createRepl({
     prompt: `${xapi._humanId}> `
   })
   repl.context.xapi = xapi
-  yield eventToPromise(repl, 'exit')
+
+  repl.context.find = predicate => find(xapi.objects.all, predicate)
+  repl.context.findAll = predicate => filter(xapi.objects.all, predicate)
+
+  // Make the REPL waits for promise completion.
+  repl.eval = (evaluate => (cmd, context, filename, cb) => {
+    fromCallback(cb => {
+      evaluate.call(repl, cmd, context, filename, cb)
+    })::asCallback(cb)
+  })(repl.eval)
+
+  await eventToPromise(repl, 'exit')
 
   try {
-    yield xapi.disconnect()
+    await xapi.disconnect()
   } catch (error) {}
-})
+}
 export default main
 
 if (!module.parent) {

packages/xen-api/src/index.js

@@ -1,19 +1,38 @@
-import Bluebird, {promisify} from 'bluebird'
 import Collection from 'xo-collection'
 import createDebug from 'debug'
-import forEach from 'lodash.foreach'
-import startsWith from 'lodash.startswith'
-import {BaseError} from 'make-error'
+import kindOf from 'kindof'
+import ms from 'ms'
+import { BaseError } from 'make-error'
+import { EventEmitter } from 'events'
+import { filter, forEach, isArray, isObject, map, startsWith } from 'lodash'
 import {
-  createClient as createXmlRpcClient,
-  createSecureClient as createSecureXmlRpcClient
-} from 'xmlrpc'
-import {EventEmitter} from 'events'
+  catchPlus as pCatch,
+  delay as pDelay
+} from 'promise-toolbox'
+
+import autoTransport from './transports/auto'
 
 const debug = createDebug('xen-api')
 
 // ===================================================================
 
+function invoke (fn) {
+  const n = arguments.length - 1
+  if (!n) {
+    return fn()
+  }
+
+  fn = arguments[n]
+  const args = new Array(n)
+  for (let i = 0; i < n; ++i) {
+    args[i] = arguments[i]
+  }
+
+  return fn.apply(undefined, args)
+}
+
+// ===================================================================
+
 // http://www.gnu.org/software/libc/manual/html_node/Error-Codes.html
 const NETWORK_ERRORS = {
   // Connection has been closed outside of our control.
@@ -35,7 +54,7 @@ const NETWORK_ERRORS = {
   ETIMEDOUT: true
 }
 
-const isNetworkError = (error) => NETWORK_ERRORS[error.code]
+const isNetworkError = ({code}) => NETWORK_ERRORS[code]
 
 // -------------------------------------------------------------------
 
@@ -44,170 +63,270 @@ const XAPI_NETWORK_ERRORS = {
   HOST_HAS_NO_MANAGEMENT_IP: true
 }
 
-const isXapiNetworkError = (error) => XAPI_NETWORK_ERRORS[error.code]
+const isXapiNetworkError = ({code}) => XAPI_NETWORK_ERRORS[code]
 
 // -------------------------------------------------------------------
 
-const areEventsLost = (error) => error.code === 'EVENTS_LOST'
+const areEventsLost = ({code}) => code === 'EVENTS_LOST'
 
-const isHostSlave = (error) => error.code === 'HOST_IS_SLAVE'
+const isHostSlave = ({code}) => code === 'HOST_IS_SLAVE'
 
-const isSessionInvalid = (error) => error.code === 'SESSION_INVALID'
+const isMethodUnknown = ({code}) => code === 'MESSAGE_METHOD_UNKNOWN'
+
+const isSessionInvalid = ({code}) => code === 'SESSION_INVALID'
 
 // -------------------------------------------------------------------
 
 class XapiError extends BaseError {
-  constructor (error) {
-    super(error[0])
+  constructor ([code, ...params]) {
+    super(`${code}(${params.join(', ')})`)
 
-    this.code = error[0]
-    this.params = error.slice(1)
+    this.code = code
+    this.params = params
+
+    // slot than can be assigned later
+    this.method = null
   }
 }
 
+export const wrapError = error => new XapiError(error)
+
 // ===================================================================
 
-const URL_RE = /^(http(s)?:\/\/)?([^/]+?)(?::([0-9]+))?(?:\/.*)?$/
-function parseUrl (url) {
+const URL_RE = /^(?:http(s)?:\/*)?([^/]+?)(?::([0-9]+))?\/?$/
+const parseUrl = url => {
   const matches = URL_RE.exec(url)
   if (!matches) {
     throw new Error('invalid URL: ' + url)
   }
 
-  const [, protocol, , host, port] = matches
-  let [, , isSecure] = matches
-
-  if (!protocol) {
-    isSecure = true
+  url = {
+    hostname: matches[2],
+    port: matches[3],
+    protocol: matches[1] === 's' ? 'https:' : 'http:'
   }
 
-  return {
-    isSecure: Boolean(isSecure),
-    host,
-    port: port !== undefined ?
-      +port :
-      isSecure ? 443 : 80
-  }
+  return url
 }
 
 // -------------------------------------------------------------------
 
-const noop = () => {}
+const {
+  create: createObject,
+  defineProperties,
+  defineProperty,
+  freeze: freezeObject,
+  prototype: { toString }
+} = Object
+
+const isString = invoke(toString.call(''), tag =>
+  value => toString.call(value) === tag
+)
 
 // -------------------------------------------------------------------
 
-const notConnectedPromise = Bluebird.reject(new Error('not connected'))
+const OPAQUE_REF_PREFIX = 'OpaqueRef:'
+const isOpaqueRef = value => isString(value) && startsWith(value, OPAQUE_REF_PREFIX)
 
-// Does nothing but avoid a Bluebird message error.
-notConnectedPromise.catch(noop)
+// -------------------------------------------------------------------
+
+const isReadOnlyCall = invoke(/^[^.]+\.get_/, RE => (method, args) => (
+  args.length === 1 &&
+  isOpaqueRef(args[0]) &&
+  RE.test(method)
+))
+
+// -------------------------------------------------------------------
+
+const getKey = o => o.$id
+
+// -------------------------------------------------------------------
+
+const EMPTY_ARRAY = freezeObject([])
 
 // ===================================================================
 
 const MAX_TRIES = 5
 
+const CONNECTED = 'connected'
+const CONNECTING = 'connecting'
+const DISCONNECTED = 'disconnected'
+
 // -------------------------------------------------------------------
 
 export class Xapi extends EventEmitter {
   constructor (opts) {
     super()
 
-    this._url = parseUrl(opts.url)
     this._auth = opts.auth
-
-    this._sessionId = notConnectedPromise
-
-    this._init()
-
     this._pool = null
-    this._objectsByRefs = Object.create(null)
-    this._objectsByRefs['OpaqueRef:NULL'] = null
-    this._objects = new Collection()
-    this._objects.getId = (object) => object.$id
+    this._readOnly = Boolean(opts.readOnly)
+    this._sessionId = null
+    this._url = parseUrl(opts.url)
 
-    this._fromToken = ''
-    this.on('connected', this._watchEvents)
-    this.on('disconnected', () => {
+    if (opts.watchEvents !== false) {
+      this._debounce = opts.debounce == null
+        ? 200
+        : opts.debounce
       this._fromToken = ''
-      this._objects.clear()
-    })
+
+      // Memoize this function _addObject().
+      this._getPool = () => this._pool
+
+      const objects = this._objects = new Collection()
+      objects.getKey = getKey
+
+      this._objectsByRefs = createObject(null)
+      this._objectsByRefs['OpaqueRef:NULL'] = null
+
+      this.on('connected', this._watchEvents)
+      this.on('disconnected', () => {
+        this._fromToken = ''
+        objects.clear()
+      })
+    }
+  }
+
+  get _url () {
+    return this.__url
+  }
+
+  set _url (url) {
+    this.__url = url
+    this._call = autoTransport({ url })
+  }
+
+  get readOnly () {
+    return this._readOnly
+  }
+
+  set readOnly (ro) {
+    this._readOnly = Boolean(ro)
   }
 
   get sessionId () {
-    if (this.status !== 'connected') {
+    const id = this._sessionId
+
+    if (!id || id === CONNECTING) {
       throw new Error('sessionId is only available when connected')
     }
 
-    return this._sessionId.value()
+    return id
   }
 
   get status () {
-    const {_sessionId: sessionId} = this
+    const id = this._sessionId
 
-    if (sessionId.isFulfilled()) {
-      return 'connected'
-    }
-
-    if (sessionId.isPending()) {
-      return 'connecting'
-    }
-
-    return 'disconnected'
+    return id
+      ? (
+        id === CONNECTING
+          ? CONNECTING
+          : CONNECTED
+      )
+      : DISCONNECTED
   }
 
   get _humanId () {
-    return `${this._auth.user}@${this._url.host}`
+    return `${this._auth.user}@${this._url.hostname}`
   }
 
   connect () {
     const {status} = this
 
-    if (status === 'connected') {
-      return Bluebird.reject(new Error('already connected'))
+    if (status === CONNECTED) {
+      return Promise.reject(new Error('already connected'))
     }
 
-    if (status === 'connecting') {
-      return Bluebird.reject(new Error('already connecting'))
+    if (status === CONNECTING) {
+      return Promise.reject(new Error('already connecting'))
     }
 
-    this._sessionId = this._transportCall('session.login_with_password', [
+    this._sessionId = CONNECTING
+
+    return this._transportCall('session.login_with_password', [
       this._auth.user,
       this._auth.password
-    ])
+    ]).then(
+      sessionId => {
+        this._sessionId = sessionId
 
-    return this._sessionId.then(() => {
-      debug('%s: connected', this._humanId)
+        debug('%s: connected', this._humanId)
 
-      this.emit('connected')
-    })
+        this.emit(CONNECTED)
+      },
+      error => {
+        this._sessionId = null
+
+        throw error
+      }
+    )
   }
 
   disconnect () {
-    const {status} = this
+    return Promise.resolve().then(() => {
+      const { status } = this
 
-    if (status === 'disconnected') {
-      return Bluebird.reject('already disconnected')
-    }
+      if (status === DISCONNECTED) {
+        return Promise.reject(new Error('already disconnected'))
+      }
 
-    if (status === 'connecting') {
-      return this._sessionId.cancel().catch(Bluebird.CancellationError, () => {
-        debug('%s: disconnected', this._humanId)
+      this._sessionId = null
 
-        this.emit('disconnected')
-      })
-    }
-
-    this._sessionId = notConnectedPromise
-
-    return Bluebird.resolve().then(() => {
       debug('%s: disconnected', this._humanId)
 
-      this.emit('disconnected')
+      this.emit(DISCONNECTED)
     })
   }
 
   // High level calls.
   call (method, ...args) {
-    return this._sessionCall(method, args)
+    return this._readOnly && !isReadOnlyCall(method, args)
+      ? Promise.reject(new Error(`cannot call ${method}() in read only mode`))
+      : this._sessionCall(method, args)
+  }
+
+  // Nice getter which returns the object for a given $id (internal to
+  // this lib), UUID (unique identifier that some objects have) or
+  // opaque reference (internal to XAPI).
+  getObject (idOrUuidOrRef, defaultValue) {
+    const object = isString(idOrUuidOrRef)
+      ? (
+        // if there is an UUID, it is also the $id.
+        this._objects.all[idOrUuidOrRef] ||
+        this._objectsByRefs[idOrUuidOrRef]
+      )
+      : this._objects.all[idOrUuidOrRef.$id]
+
+    if (object) return object
+
+    if (arguments.length > 1) return defaultValue
+
+    throw new Error('there is not object can be matched to ' + idOrUuidOrRef)
+  }
+
+  // Returns the object for a given opaque reference (internal to
+  // XAPI).
+  getObjectByRef (ref, defaultValue) {
+    const object = this._objectsByRefs[ref]
+
+    if (object) return object
+
+    if (arguments.length > 1) return defaultValue
+
+    throw new Error('there is no object with the ref ' + ref)
+  }
+
+  // Returns the object for a given UUID (unique identifier that some
+  // objects have).
+  getObjectByUuid (uuid, defaultValue) {
+    // Objects ids are already UUIDs if they have one.
+    const object = this._objects.all[uuid]
+
+    if (object) return object
+
+    if (arguments.length > 1) return defaultValue
+
+    throw new Error('there is no object with the UUID ' + uuid)
   }
 
   get pool () {
@@ -220,31 +339,30 @@ export class Xapi extends EventEmitter {
 
   // Medium level call: handle session errors.
   _sessionCall (method, args) {
-    if (startsWith(method, 'session.')) {
-      return Bluebird.reject(
-        new Error('session.*() methods are disabled from this interface')
-      )
+    try {
+      if (startsWith(method, 'session.')) {
+        throw new Error('session.*() methods are disabled from this interface')
+      }
+
+      return this._transportCall(method, [this.sessionId].concat(args))
+        ::pCatch(isSessionInvalid, () => {
+          // XAPI is sometimes reinitialized and sessions are lost.
+          // Try to login again.
+          debug('%s: the session has been reinitialized', this._humanId)
+
+          this._sessionId = null
+          return this.connect().then(() => this._sessionCall(method, args))
+        })
+    } catch (error) {
+      return Promise.reject(error)
     }
-
-    return this._sessionId.then((sessionId) => {
-      return this._transportCall(method, [sessionId].concat(args))
-    }).catch(isSessionInvalid, () => {
-      // XAPI is sometimes reinitialized and sessions are lost.
-      // Try to login again.
-      debug('%s: the session has been reinitialized', this._humanId)
-
-      this._sessionId = null
-
-      return this._sessionCall(method, args)
-    })
   }
 
   // Low level call: handle transport errors.
-  _transportCall (method, args, tries = 1) {
-    debug('%s: %s(...)', this._humanId, method)
-
-    return this._rawCall(method, args)
-      .catch(isNetworkError, isXapiNetworkError, error => {
+  _transportCall (method, args) {
+    let tries = 1
+    const loop = () => this._rawCall(method, args)
+      ::pCatch(isNetworkError, isXapiNetworkError, error => {
         debug('%s: network error %s', this._humanId, error.code)
 
         if (!(tries < MAX_TRIES)) {
@@ -257,123 +375,254 @@ export class Xapi extends EventEmitter {
         // TODO: ability to force immediate reconnection
         // TODO: implement back-off
 
-        return Bluebird.delay(5e3).then(() => {
+        return pDelay(5e3).then(() => {
           // TODO: handling not responding host.
 
-          return this._transportCall(method, args, tries + 1)
+          return this._transportCall(method, args, startTime, tries + 1)
         })
       })
-      .catch(isHostSlave, ({params: [master]}) => {
+      ::pCatch(isHostSlave, ({params: [master]}) => {
         debug('%s: host is slave, attempting to connect at %s', this._humanId, master)
 
-        this._url.host = master
-        this._init()
+        const newUrl = {
+          ...this._url,
+          hostname: master
+        }
+        this.emit('redirect', newUrl)
+        this._url = newUrl
 
-        return this._transportCall(method, args)
+        return this._transportCall(method, args, startTime)
       })
+
+    const startTime = Date.now()
+    return loop().then(
+      result => {
+        debug(
+          '%s: %s(...) [%s] ==> %s',
+          this._humanId,
+          method,
+          ms(Date.now() - startTime),
+          kindOf(result)
+        )
+        return result
+      },
+      error => {
+        debug(
+          '%s: %s(...) [%s] =!> %s',
+          this._humanId,
+          method,
+          ms(Date.now() - startTime),
+          error
+        )
+        throw error
+      }
+    )
   }
 
   // Lowest level call: do not handle any errors.
   _rawCall (method, args) {
-    return this._xmlRpcCall(method, args)
-      .then(result => {
-        const {Status: status} = result
+    return this._call(method, args).catch(error => {
+      if (isArray(error)) {
+        error = wrapError(error)
+      }
 
-        // Return the plain result if it does not have a valid XAPI
-        // format.
-        if (!status) {
-          return result
-        }
-
-        if (status === 'Success') {
-          return result.Value
-        }
-
-        throw new XapiError(result.ErrorDescription)
-      })
-      .cancellable()
-  }
-
-  _init () {
-    const {isSecure, host, port} = this._url
-
-    const client = (isSecure ?
-      createSecureXmlRpcClient :
-      createXmlRpcClient
-    )({
-      host,
-      port,
-      rejectUnauthorized: false,
-      timeout: 10
+      error.method = method
+      throw error
     })
-
-    this._xmlRpcCall = promisify(client.methodCall, client)
   }
 
-  _normalizeObject (type, ref, object) {
+  _addObject (type, ref, object) {
     const {_objectsByRefs: objectsByRefs} = this
-    const REF_RE = /^OpaqueRef:/
 
-    forEach(object, function resolveIfLink(value, key, object) {
-      if (typeof value === 'string' && REF_RE.test(value)) {
-        Object.defineProperty(object, key, {
-          enumerable: true,
+    const reservedKeys = {
+      id: true,
+      pool: true,
+      ref: true,
+      type: true
+    }
+    const getKey = (key, obj) => reservedKeys[key] && obj === object
+      ? `$$${key}`
+      : `$${key}`
+
+    // Creates resolved properties.
+    forEach(object, function resolveObject (value, key, object) {
+      if (isArray(value)) {
+        if (!value.length) {
+          // If the array is empty, it isn't possible to be sure that
+          // it is not supposed to contain links, therefore, in
+          // benefice of the doubt, a resolved property is defined.
+          defineProperty(object, getKey(key, object), {
+            value: EMPTY_ARRAY
+          })
+
+          // Minor memory optimization, use the same empty array for
+          // everyone.
+          object[key] = EMPTY_ARRAY
+        } else if (isOpaqueRef(value[0])) {
+          // This is an array of refs.
+          defineProperty(object, getKey(key, object), {
+            get: () => freezeObject(map(value, (ref) => objectsByRefs[ref]))
+          })
+
+          freezeObject(value)
+        }
+      } else if (isObject(value)) {
+        forEach(value, resolveObject)
+
+        freezeObject(value)
+      } else if (isOpaqueRef(value)) {
+        defineProperty(object, getKey(key, object), {
           get: () => objectsByRefs[value]
         })
-      } else if (typeof value === 'object') {
-        forEach(value, resolveIfLink)
       }
     })
 
-    object.$id = object.uuid || ref
-    object.$ref = ref
-    object.$type = type
+    // All custom properties are read-only and non enumerable.
+    defineProperties(object, {
+      $id: { value: object.uuid || ref },
+      $pool: { get: this._getPool },
+      $ref: { value: ref },
+      $type: { value: type }
+    })
 
-    Object.defineProperty(object, '$pool', {
-      enumerable: true,
-      get: () => this._pool
+    // Finally freezes the object.
+    freezeObject(object)
+
+    const objects = this._objects
+
+    // An object's UUID can change during its life.
+    const prev = objectsByRefs[ref]
+    let prevUuid
+    if (prev && (prevUuid = prev.uuid) && prevUuid !== object.uuid) {
+      objects.remove(prevUuid)
+    }
+
+    this._objects.set(object)
+    objectsByRefs[ref] = object
+
+    if (type === 'pool') {
+      this._pool = object
+    }
+  }
+
+  _removeObject (ref) {
+    const {_objectsByRefs: objectsByRefs} = this
+
+    const object = objectsByRefs[ref]
+
+    if (object) {
+      this._objects.unset(object.$id)
+      delete objectsByRefs[ref]
+    }
+  }
+
+  _processEvents (events) {
+    forEach(events, event => {
+      const {operation: op} = event
+
+      const {ref} = event
+      if (op === 'del') {
+        this._removeObject(ref)
+      } else {
+        this._addObject(event.class, ref, event.snapshot)
+      }
     })
   }
 
   _watchEvents () {
-    this.call(
-      'event.from', ['*'], this._fromToken, 1e3 + 0.1
-    ).then(({token, events}) => {
+    const loop = () => this.status === CONNECTED && this._sessionCall('event.from', [
+      ['*'],
+      this._fromToken,
+      60 + 0.1 // Force float.
+    ]).then(onSuccess, onFailure)
+
+    const onSuccess = ({token, events}) => {
       this._fromToken = token
+      this._processEvents(events)
 
-      const {
-        _objects: objects,
-        _objectsByRefs: objectsByRefs
-      } = this
+      const debounce = this._debounce
+      return debounce != null
+        ? pDelay(debounce).then(loop)
+        : loop()
+    }
+    const onFailure = error => {
+      if (areEventsLost(error)) {
+        this._fromToken = ''
+        this._objects.clear()
 
-      forEach(events, event => {
-        const {operation: op} = event
+        return loop()
+      }
 
-        const {ref} = event
-        if (op === 'del') {
-          const objects = objectsByRefs[ref]
+      throw error
+    }
 
-          if (objects) {
-            objects.remove(objects.$id)
-            delete objectsByRefs[ref]
-          }
-        } else {
-          const {class: type, snapshot: object} = event
+    return loop()::pCatch(
+      isMethodUnknown,
 
-          this._normalizeObject(type, ref, object)
-          objects.set(object)
-          objectsByRefs[ref] = object
+      // If the server failed, it is probably due to an excessively
+      // large response.
+      // Falling back to legacy events watch should be enough.
+      error => error && error.res && error.res.statusCode === 500,
 
-          if (object.$type === 'pool') {
-            this._pool = object
-          }
-        }
+      () => this._watchEventsLegacy()
+    )
+  }
+
+  // This method watches events using the legacy `event.next` XAPI
+  // methods.
+  //
+  // It also has to manually get all objects first.
+  _watchEventsLegacy () {
+    const getAllObjects = () => {
+      return this._sessionCall('system.listMethods', []).then(methods => {
+        // Uses introspection to determine the methods to use to get
+        // all objects.
+        const getAllRecordsMethods = filter(
+          methods,
+          ::/\.get_all_records$/.test
+        )
+
+        return Promise.all(map(
+          getAllRecordsMethods,
+          method => this._sessionCall(method, []).then(
+            objects => {
+              const type = method.slice(0, method.indexOf('.')).toLowerCase()
+              forEach(objects, (object, ref) => {
+                this._addObject(type, ref, object)
+              })
+            },
+            error => {
+              if (error.code !== 'MESSAGE_REMOVED') {
+                throw error
+              }
+            }
+          )
+        ))
       })
-    }).catch(areEventsLost, () => {
-      this._objects.clear()
-    }).then(() => {
-      this._watchEvents()
-    }).catch(noop)
+    }
+
+    const watchEvents = () => this._sessionCall('event.register', [ ['*'] ]).then(loop)
+
+    const loop = () => this.status === CONNECTED && this._sessionCall('event.next', []).then(onSuccess, onFailure)
+
+    const onSuccess = events => {
+      this._processEvents(events)
+
+      const debounce = this._debounce
+      return debounce == null
+        ? loop()
+        : pDelay(debounce).then(loop)
+    }
+
+    const onFailure = error => {
+      if (areEventsLost(error)) {
+        return this._sessionCall('event.unregister', [ ['*'] ]).then(watchEvents)
+      }
+
+      throw error
+    }
+
+    return getAllObjects().then(watchEvents)
   }
 }
 

packages/xen-api/src/index.spec.js

@@ -1,17 +0,0 @@
-/* eslint-env mocha */
-
-import {createClient, Xapi} from './'
-
-import expect from 'must'
-
-// ===================================================================
-
-describe('createClient()', function () {
-  it('is a function', function () {
-    expect(createClient).to.be.a.function()
-  })
-
-  it.skip('returns an instance of Xapi', function () {
-    expect(createClient('example.org')).to.be.a(Xapi)
-  })
-})

packages/xen-api/src/inject-events.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { delay as pDelay } from 'promise-toolbox'
+
+import { createClient } from './'
+
+const xapi = (() => {
+  const [ , , url, user, password ] = process.argv
+
+  return createClient({
+    auth: { user, password },
+    url,
+    watchEvents: false
+  })
+})()
+
+xapi.connect()
+
+  // Get the pool record's ref.
+  .then(() => xapi.call('pool.get_all'))
+
+  // Injects lots of events.
+  .then(([ poolRef ]) => {
+    const loop = () => xapi.call('event.inject', 'pool', poolRef)
+      ::pDelay(10) // A small delay is required to avoid overloading the Xen API.
+      .then(loop)
+
+    return loop()
+  })

packages/xen-api/src/memory-test.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+import { createClient } from './'
+
+let i = 0
+setInterval(() => {
+  const usage = process.memoryUsage()
+  console.log(
+    '%s %s %s %s',
+    i++,
+    Math.round(usage.rss / 1e6),
+    Math.round(usage.heapTotal / 1e6),
+    Math.round(usage.heapUsed / 1e6)
+  )
+}, 1e2)
+
+const [ , , url, user, password ] = process.argv
+createClient({
+  auth: { user, password },
+  readOnly: true,
+  url
+}).connect()

packages/xen-api/src/transports/auto.js

@@ -0,0 +1,29 @@
+import { InvalidJson } from 'json-rpc-protocol'
+
+import jsonRpc from './json-rpc'
+import xmlRpc from './xml-rpc'
+
+export default opts => {
+  let call = (jsonRpcCall =>
+    (method, args) => jsonRpcCall(method, args).then(
+      result => {
+        // JSON-RPC seems to be working, remove the test
+        call = jsonRpcCall
+
+        return result
+      },
+      error => {
+        if (error instanceof InvalidJson) {
+          // fallback to XML-RPC
+          call = xmlRpc(opts)
+
+          return call(method, args)
+        }
+
+        throw error
+      }
+    )
+  )(jsonRpc(opts))
+
+  return (method, args) => call(method, args)
+}

packages/xen-api/src/transports/json-rpc.js

@@ -0,0 +1,23 @@
+import superagent from 'superagent'
+import { format, parse } from 'json-rpc-protocol'
+
+export default ({ url: { hostname, port, protocol } }) => {
+  const href = `${protocol}//${hostname}${
+    port != null ? `:${port}` : ''
+  }/jsonrpc`
+
+  return (method, args) =>
+    superagent.post(href)
+      .accept('application/json')
+      .parse(superagent.parse.text) // no smart parsing from superagent
+      .send(format.request(0, method, args))
+      .type('application/json')
+      .then(({ text }) => {
+        const response = parse(text)
+        if (response.type === 'response') {
+          return response.result
+        }
+
+        throw response.error
+      })
+}

packages/xen-api/src/transports/xml-rpc.js

@@ -0,0 +1,84 @@
+import { createClient, createSecureClient } from 'xmlrpc'
+import { promisify } from 'promise-toolbox'
+
+const logError = error => {
+  if (error.res) {
+    console.error(
+      'XML-RPC Error: %s (response status %s)',
+      error.message,
+      error.res.statusCode
+    )
+    console.error('%s', error.body)
+  }
+
+  throw error
+}
+
+const SPECIAL_CHARS = {
+  '\r': '\\r',
+  '\t': '\\t'
+}
+const SPECIAL_CHARS_RE = new RegExp(
+  Object.keys(SPECIAL_CHARS).join('|'),
+  'g'
+)
+
+const parseResult = result => {
+  const status = result.Status
+
+  // Return the plain result if it does not have a valid XAPI
+  // format.
+  if (status === undefined) {
+    return result
+  }
+
+  if (status !== 'Success') {
+    throw result.ErrorDescription
+  }
+
+  const value = result.Value
+
+  // XAPI returns an empty string (invalid JSON) for an empty
+  // result.
+  if (value === '') {
+    return ''
+  }
+
+  try {
+    return JSON.parse(value)
+  } catch (error) {
+    // XAPI JSON sometimes contains invalid characters.
+    if (error instanceof SyntaxError) {
+      let replaced
+      const fixedValue = value.replace(SPECIAL_CHARS_RE, match => {
+        replaced = true
+        return SPECIAL_CHARS[match]
+      })
+
+      if (replaced) {
+        return JSON.parse(fixedValue)
+      }
+    }
+
+    throw error
+  }
+}
+
+export default ({ url: { hostname, path, port, protocol } }) => {
+  const client = (
+    protocol === 'https:'
+      ? createSecureClient
+      : createClient
+  )({
+    host: hostname,
+    path: '/json',
+    port,
+    rejectUnauthorized: false
+  })
+  const call = promisify(client.methodCall, client)
+
+  return (method, args) => call(method, args).then(
+    parseResult,
+    logError
+  )
+}