feat(xo-server): 5.30.1

Related to #3699

This should improve user experience when changing pages.

.eslintrc.js

@@ -4,12 +4,18 @@ module.exports = {
     __DEV__: true,
     $Dict: true,
     $Diff: true,
+    $ElementType: true,
     $Exact: true,
     $Keys: true,
     $PropertyType: true,
     $Shape: true,
   },
   parser: 'babel-eslint',
+  parserOptions: {
+    ecmaFeatures: {
+      legacyDecorators: true,
+    },
+  },
   rules: {
     'comma-dangle': ['error', 'always-multiline'],
     indent: 'off',

.travis.yml

@@ -2,7 +2,6 @@ language: node_js
 node_js:
   #- stable # disable for now due to an issue of indirect dep upath with Node 9
   - 8
-  - 6
 
 # Use containers.
 # http://docs.travis-ci.com/user/workers/container-based-infrastructure/
@@ -10,9 +9,9 @@ sudo: false
 addons:
   apt:
     packages:
-    - qemu-utils
-    - blktap-utils
-    - vmdk-stream-converter
+      - qemu-utils
+      - blktap-utils
+      - vmdk-stream-converter
 
 before_install:
   - curl -o- -L https://yarnpkg.com/install.sh | bash
@@ -22,5 +21,4 @@ cache:
   yarn: true
 
 script:
-  - yarn run test
-  - yarn run test-integration
+  - yarn run travis-tests

@xen-orchestra/async-map/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

@xen-orchestra/async-map/.npmignore

@@ -0,0 +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__/

@xen-orchestra/async-map/README.md

@@ -0,0 +1,49 @@
+# @xen-orchestra/async-map [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
+
+> ${pkg.description}
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/async-map):
+
+```
+> npm install --save @xen-orchestra/async-map
+```
+
+## Usage
+
+**TODO**
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Vates SAS](https://vates.fr)

@xen-orchestra/async-map/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@xen-orchestra/async-map",
+  "version": "0.0.0",
+  "license": "ISC",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/async-map",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "browserslist": [
+    ">2%"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "dependencies": {
+    "lodash": "^4.17.4"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "clean": "rimraf dist/",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "prebuild": "yarn run clean",
+    "predev": "yarn run prebuild",
+    "prepare": "yarn run build",
+    "prepublishOnly": "yarn run build"
+  }
+}

@xen-orchestra/async-map/src/index.js

@@ -0,0 +1,43 @@
+// type MaybePromise<T> = Promise<T> | T
+//
+// declare export function asyncMap<T1, T2>(
+//   collection: MaybePromise<T1[]>,
+//   (T1, number) => MaybePromise<T2>
+// ): Promise<T2[]>
+// declare export function asyncMap<K, V1, V2>(
+//   collection: MaybePromise<{ [K]: V1 }>,
+//   (V1, K) => MaybePromise<V2>
+// ): Promise<V2[]>
+
+import map from 'lodash/map'
+
+// Similar to map() + Promise.all() but wait for all promises to
+// settle before rejecting (with the first error)
+const asyncMap = (collection, iteratee) => {
+  let then
+  if (collection != null && typeof (then = collection.then) === 'function') {
+    return then.call(collection, collection => asyncMap(collection, iteratee))
+  }
+
+  let errorContainer
+  const onError = error => {
+    if (errorContainer === undefined) {
+      errorContainer = { error }
+    }
+  }
+
+  return Promise.all(
+    map(collection, (item, key, collection) =>
+      new Promise(resolve => {
+        resolve(iteratee(item, key, collection))
+      }).catch(onError)
+    )
+  ).then(values => {
+    if (errorContainer !== undefined) {
+      throw errorContainer.error
+    }
+    return values
+  })
+}
+
+export { asyncMap as default }

@xen-orchestra/babel-config/index.js

@@ -22,18 +22,16 @@ const configs = {
       // loose: true,
 
       shippedProposals: true,
-      targets: __PROD__
-        ? (() => {
-            let node = (pkg.engines || {}).node
-            if (node !== undefined) {
-              const trimChars = '^=>~'
-              while (trimChars.includes(node[0])) {
-                node = node.slice(1)
-              }
-              return { node: node }
-            }
-          })()
-        : { browsers: '', node: 'current' },
+      targets: (() => {
+        let node = (pkg.engines || {}).node
+        if (node !== undefined) {
+          const trimChars = '^=>~'
+          while (trimChars.includes(node[0])) {
+            node = node.slice(1)
+          }
+        }
+        return { browsers: pkg.browserslist, node }
+      })(),
       useBuiltIns: '@babel/polyfill' in (pkg.dependencies || {}) && 'usage',
     }
   },
@@ -44,8 +42,8 @@ const getConfig = (key, ...args) => {
   return config === undefined
     ? {}
     : typeof config === 'function'
-      ? config(...args)
-      : config
+    ? config(...args)
+    : config
 }
 
 module.exports = function (pkg, plugins, presets) {

@xen-orchestra/cr-seed-cli/index.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+const defer = require('golike-defer').default
+const { NULL_REF, Xapi } = require('xen-api')
+
+const pkg = require('./package.json')
+
+Xapi.prototype.getVmDisks = async function (vm) {
+  const disks = { __proto__: null }
+  await Promise.all([
+    ...vm.VBDs.map(async vbdRef => {
+      const vbd = await this.getRecord('VBD', vbdRef)
+      let vdiRef
+      if (vbd.type === 'Disk' && (vdiRef = vbd.VDI) !== NULL_REF) {
+        disks[vbd.userdevice] = await this.getRecord('VDI', vdiRef)
+      }
+    }),
+  ])
+  return disks
+}
+
+defer(async function main ($defer, args) {
+  if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
+    const cliName = Object.keys(pkg.bin)[0]
+    return console.error(
+      '%s',
+      `
+Usage: ${cliName} <source XAPI URL> <source snapshot UUID> <target XAPI URL> <target VM UUID> <backup job id> <backup schedule id>
+
+${cliName} v${pkg.version}
+`
+    )
+  }
+
+  const [
+    srcXapiUrl,
+    srcSnapshotUuid,
+    tgtXapiUrl,
+    tgtVmUuid,
+    jobId,
+    scheduleId,
+  ] = args
+
+  const srcXapi = new Xapi({
+    allowUnauthorized: true,
+    url: srcXapiUrl,
+    watchEvents: false,
+  })
+  await srcXapi.connect()
+  defer.call(srcXapi, 'disconnect')
+
+  const tgtXapi = new Xapi({
+    allowUnauthorized: true,
+    url: tgtXapiUrl,
+    watchEvents: false,
+  })
+  await tgtXapi.connect()
+  defer.call(tgtXapi, 'disconnect')
+
+  const [srcSnapshot, tgtVm] = await Promise.all([
+    srcXapi.getRecordByUuid('VM', srcSnapshotUuid),
+    tgtXapi.getRecordByUuid('VM', tgtVmUuid),
+  ])
+  const srcVm = await srcXapi.getRecord('VM', srcSnapshot.snapshot_of)
+
+  const metadata = {
+    'xo:backup:datetime': srcSnapshot.snapshot_time,
+    'xo:backup:job': jobId,
+    'xo:backup:schedule': scheduleId,
+    'xo:backup:vm': srcVm.uuid,
+  }
+
+  const [srcDisks, tgtDisks] = await Promise.all([
+    srcXapi.getVmDisks(srcSnapshot),
+    tgtXapi.getVmDisks(tgtVm),
+  ])
+  const userDevices = Object.keys(tgtDisks)
+
+  const tgtSr = await tgtXapi.getRecord(
+    'SR',
+    tgtDisks[Object.keys(tgtDisks)[0]].SR
+  )
+
+  await Promise.all([
+    srcXapi.setFieldEntries(srcSnapshot, 'other_config', metadata),
+    srcXapi.setFieldEntries(srcSnapshot, 'other_config', {
+      'xo:backup:exported': 'true',
+    }),
+    tgtXapi.setField(
+      tgtVm,
+      'name_label',
+      `${srcVm.name_label} (${srcSnapshot.snapshot_time})`
+    ),
+    tgtXapi.setFieldEntries(tgtVm, 'other_config', metadata),
+    tgtXapi.setFieldEntries(tgtVm, 'other_config', {
+      'xo:backup:sr': tgtSr.uuid,
+      'xo:copy_of': srcSnapshotUuid,
+    }),
+    tgtXapi.setFieldEntries(tgtVm, 'blocked_operations', {
+      start:
+        'Start operation for this vm is blocked, clone it if you want to use it.',
+    }),
+    Promise.all(
+      userDevices.map(userDevice => {
+        const srcDisk = srcDisks[userDevice]
+        const tgtDisk = tgtDisks[userDevice]
+
+        return tgtXapi.setFieldEntry(
+          tgtDisk,
+          'other_config',
+          'xo:copy_of',
+          srcDisk.uuid
+        )
+      })
+    ),
+  ])
+})(process.argv.slice(2)).catch(console.error.bind(console, 'Fatal error:'))

@xen-orchestra/cr-seed-cli/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@xen-orchestra/cr-seed-cli",
+  "version": "0.2.0",
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/cr-seed-cli",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "engines": {
+    "node": ">=8"
+  },
+  "bin": {
+    "xo-cr-seed": "./index.js"
+  },
+  "dependencies": {
+    "golike-defer": "^0.4.1",
+    "xen-api": "^0.21.0"
+  }
+}

@xen-orchestra/cron/package.json

@@ -41,10 +41,10 @@
     "moment-timezone": "^0.5.14"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
-    "@babel/preset-flow": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
     "cross-env": "^5.1.3",
     "rimraf": "^2.6.2"
   },

@xen-orchestra/cron/src/index.js

@@ -8,7 +8,12 @@ const MAX_DELAY = 2 ** 31 - 1
 class Job {
   constructor (schedule, fn) {
     const wrapper = () => {
-      const result = fn()
+      let result
+      try {
+        result = fn()
+      } catch (_) {
+        // catch any thrown value to ensure it does not break the job
+      }
       let then
       if (result != null && typeof (then = result.then) === 'function') {
         then.call(result, scheduleNext, scheduleNext)
@@ -45,8 +50,8 @@ class Schedule {
       zone.toLowerCase() === 'utc'
         ? moment.utc
         : zone === 'local'
-          ? moment
-          : () => moment.tz(zone)
+        ? moment
+        : () => moment.tz(zone)
   }
 
   createJob (fn) {

@xen-orchestra/defined/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

@xen-orchestra/defined/.npmignore

@@ -0,0 +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__/

@xen-orchestra/defined/README.md

@@ -0,0 +1,49 @@
+# ${pkg.name} [![Build Status](https://travis-ci.org/${pkg.shortGitHubPath}.png?branch=master)](https://travis-ci.org/${pkg.shortGitHubPath})
+
+> ${pkg.description}
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/${pkg.name}):
+
+```
+> npm install --save ${pkg.name}
+```
+
+## Usage
+
+**TODO**
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](${pkg.bugs})
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+${pkg.license} © [${pkg.author.name}](${pkg.author.url})

@xen-orchestra/defined/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@xen-orchestra/defined",
+  "version": "0.0.0",
+  "license": "ISC",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/defined",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@vates.fr"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "browserslist": [
+    ">2%"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "clean": "rimraf dist/",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "prebuild": "yarn run clean",
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
+  }
+}

@xen-orchestra/defined/src/index.js

@@ -1,3 +1,5 @@
+// @flow
+
 // Usage:
 //
 // ```js
@@ -39,7 +41,7 @@ export default function defined () {
 // const getFriendName = _ => _.friends[0].name
 // const friendName = get(getFriendName, props.user)
 // ```
-export const get = (accessor, arg) => {
+export const get = (accessor: (input: ?any) => any, arg: ?any) => {
   try {
     return accessor(arg)
   } catch (error) {
@@ -58,5 +60,5 @@ export const get = (accessor, arg) => {
 //   _ => new ProxyAgent(_)
 // )
 // ```
-export const ifDef = (value, thenFn) =>
+export const ifDef = (value: ?any, thenFn: (value: any) => any) =>
   value !== undefined ? thenFn(value) : value

@xen-orchestra/emit-async/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

@xen-orchestra/emit-async/.npmignore

@@ -0,0 +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__/

@xen-orchestra/emit-async/README.md

@@ -0,0 +1,71 @@
+# @xen-orchestra/emit-async [![Build Status](https://travis-ci.org/${pkg.shortGitHubPath}.png?branch=master)](https://travis-ci.org/${pkg.shortGitHubPath})
+
+> ${pkg.description}
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/emit-async):
+
+```
+> npm install --save @xen-orchestra/emit-async
+```
+
+## Usage
+
+```js
+import EE from 'events'
+import emitAsync from '@xen-orchestra/emit-async'
+
+const ee = new EE()
+ee.emitAsync = emitAsync
+
+ee.on('start', async function () {
+  // whatever
+})
+
+// similar to EventEmmiter#emit() but returns a promise which resolves when all
+// listeners have resolved
+await ee.emitAsync('start')
+
+// by default, it will rejects as soon as one listener reject, you can customise
+// error handling though:
+await ee.emitAsync({
+  onError (error) {
+    console.warn(error)
+  }
+}, 'start')
+```
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](${pkg.bugs})
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+${pkg.license} © [${pkg.author.name}](${pkg.author.url})

@xen-orchestra/emit-async/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@xen-orchestra/emit-async",
+  "version": "0.0.0",
+  "license": "ISC",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/emit-async",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@vates.fr"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "browserslist": [
+    ">2%"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "clean": "rimraf dist/",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "prebuild": "yarn run clean",
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
+  }
+}

@xen-orchestra/emit-async/src/index.js

@@ -0,0 +1,26 @@
+export default function emitAsync (event) {
+  let opts
+  let i = 1
+
+  // an option object has been passed as first param
+  if (typeof event !== 'string') {
+    opts = event
+    event = arguments[i++]
+  }
+
+  const n = arguments.length - i
+  const args = new Array(n)
+  for (let j = 0; j < n; ++j) {
+    args[j] = arguments[j + i]
+  }
+
+  const onError = opts != null && opts.onError
+
+  return Promise.all(
+    this.listeners(event).map(listener =>
+      new Promise(resolve => {
+        resolve(listener.apply(this, args))
+      }).catch(onError)
+    )
+  )
+}

@xen-orchestra/fs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xen-orchestra/fs",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "license": "AGPL-3.0",
   "description": "The File System for Xen Orchestra backups.",
   "keywords": [],
@@ -20,24 +20,22 @@
     "node": ">=6"
   },
   "dependencies": {
-    "@babel/runtime": "7.0.0-rc.1",
     "@marsaud/smb2": "^0.9.0",
-    "execa": "^0.10.0",
+    "execa": "^1.0.0",
     "fs-extra": "^7.0.0",
     "get-stream": "^4.0.0",
     "lodash": "^4.17.4",
-    "promise-toolbox": "^0.9.5",
-    "through2": "^2.0.3",
+    "promise-toolbox": "^0.11.0",
+    "through2": "^3.0.0",
     "tmp": "^0.0.33",
     "xo-remote-parser": "^0.5.0"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/plugin-proposal-function-bind": "7.0.0-rc.1",
-    "@babel/plugin-transform-runtime": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
-    "@babel/preset-flow": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-proposal-function-bind": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
     "babel-plugin-lodash": "^3.3.2",
     "cross-env": "^5.1.3",
     "index-modules": "^0.3.0",

@xen-orchestra/fs/src/abstract.js

@@ -1,8 +1,9 @@
 // @flow
 
+// $FlowFixMe
 import getStream from 'get-stream'
 import { randomBytes } from 'crypto'
-import { fromCallback, fromEvent, ignoreErrors } from 'promise-toolbox'
+import { fromCallback, fromEvent, ignoreErrors, timeout } from 'promise-toolbox'
 import { type Readable, type Writable } from 'stream'
 import { parse } from 'xo-remote-parser'
 
@@ -17,13 +18,22 @@ type File = FileDescriptor | string
 
 const checksumFile = file => file + '.checksum'
 
+const DEFAULT_TIMEOUT = 6e5 // 10 min
+
 export default class RemoteHandlerAbstract {
   _remote: Object
-  constructor (remote: any) {
-    this._remote = { ...remote, ...parse(remote.url) }
-    if (this._remote.type !== this.type) {
-      throw new Error('Incorrect remote type')
+  _timeout: number
+
+  constructor (remote: any, options: Object = {}) {
+    if (remote.url === 'test://') {
+      this._remote = remote
+    } else {
+      this._remote = { ...remote, ...parse(remote.url) }
+      if (this._remote.type !== this.type) {
+        throw new Error('Incorrect remote type')
+      }
     }
+    ;({ timeout: this._timeout = DEFAULT_TIMEOUT } = options)
   }
 
   get type (): string {
@@ -121,7 +131,7 @@ export default class RemoteHandlerAbstract {
     newPath: string,
     { checksum = false }: Object = {}
   ) {
-    let p = this._rename(oldPath, newPath)
+    let p = timeout.call(this._rename(oldPath, newPath), this._timeout)
     if (checksum) {
       p = Promise.all([
         p,
@@ -142,7 +152,7 @@ export default class RemoteHandlerAbstract {
       prependDir = false,
     }: { filter?: (name: string) => boolean, prependDir?: boolean } = {}
   ): Promise<string[]> {
-    let entries = await this._list(dir)
+    let entries = await timeout.call(this._list(dir), this._timeout)
     if (filter !== undefined) {
       entries = entries.filter(filter)
     }
@@ -165,28 +175,30 @@ export default class RemoteHandlerAbstract {
     { checksum = false, ignoreMissingChecksum = false, ...options }: Object = {}
   ): Promise<LaxReadable> {
     const path = typeof file === 'string' ? file : file.path
-    const streamP = this._createReadStream(file, options).then(stream => {
-      // detect early errors
-      let promise = fromEvent(stream, 'readable')
+    const streamP = timeout
+      .call(this._createReadStream(file, options), this._timeout)
+      .then(stream => {
+        // detect early errors
+        let promise = fromEvent(stream, 'readable')
 
-      // try to add the length prop if missing and not a range stream
-      if (
-        stream.length === undefined &&
-        options.end === undefined &&
-        options.start === undefined
-      ) {
-        promise = Promise.all([
-          promise,
-          ignoreErrors.call(
-            this.getSize(file).then(size => {
-              stream.length = size
-            })
-          ),
-        ])
-      }
+        // try to add the length prop if missing and not a range stream
+        if (
+          stream.length === undefined &&
+          options.end === undefined &&
+          options.start === undefined
+        ) {
+          promise = Promise.all([
+            promise,
+            ignoreErrors.call(
+              this.getSize(file).then(size => {
+                stream.length = size
+              })
+            ),
+          ])
+        }
 
-      return promise.then(() => stream)
-    })
+        return promise.then(() => stream)
+      })
 
     if (!checksum) {
       return streamP
@@ -224,7 +236,10 @@ export default class RemoteHandlerAbstract {
   }
 
   async openFile (path: string, flags?: string): Promise<FileDescriptor> {
-    return { fd: await this._openFile(path, flags), path }
+    return {
+      fd: await timeout.call(this._openFile(path, flags), this._timeout),
+      path,
+    }
   }
 
   async _openFile (path: string, flags?: string): Promise<mixed> {
@@ -232,7 +247,7 @@ export default class RemoteHandlerAbstract {
   }
 
   async closeFile (fd: FileDescriptor): Promise<void> {
-    await this._closeFile(fd.fd)
+    await timeout.call(this._closeFile(fd.fd), this._timeout)
   }
 
   async _closeFile (fd: mixed): Promise<void> {
@@ -252,10 +267,13 @@ export default class RemoteHandlerAbstract {
     { checksum = false, ...options }: Object = {}
   ): Promise<LaxWritable> {
     const path = typeof file === 'string' ? file : file.path
-    const streamP = this._createOutputStream(file, {
-      flags: 'wx',
-      ...options,
-    })
+    const streamP = timeout.call(
+      this._createOutputStream(file, {
+        flags: 'wx',
+        ...options,
+      }),
+      this._timeout
+    )
 
     if (!checksum) {
       return streamP
@@ -290,7 +308,7 @@ export default class RemoteHandlerAbstract {
       ignoreErrors.call(this._unlink(checksumFile(file)))
     }
 
-    await this._unlink(file)
+    await timeout.call(this._unlink(file), this._timeout)
   }
 
   async _unlink (file: mixed): Promise<void> {
@@ -298,7 +316,7 @@ export default class RemoteHandlerAbstract {
   }
 
   async getSize (file: mixed): Promise<number> {
-    return this._getSize(file)
+    return timeout.call(this._getSize(file), this._timeout)
   }
 
   async _getSize (file: mixed): Promise<number> {

@xen-orchestra/fs/src/abstract.spec.js

@@ -0,0 +1,113 @@
+/* eslint-env jest */
+
+import { TimeoutError } from 'promise-toolbox'
+
+import AbstractHandler from './abstract'
+
+const TIMEOUT = 10e3
+
+class TestHandler extends AbstractHandler {
+  constructor (impl) {
+    super({ url: 'test://' }, { timeout: TIMEOUT })
+
+    Object.keys(impl).forEach(method => {
+      this[`_${method}`] = impl[method]
+    })
+  }
+}
+
+describe('rename()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      rename: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.rename('oldPath', 'newPath')
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})
+
+describe('list()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      list: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.list()
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})
+
+describe('createReadStream()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      createReadStream: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.createReadStream('file')
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})
+
+describe('openFile()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      openFile: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.openFile('path')
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})
+
+describe('closeFile()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      closeFile: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.closeFile({ fd: undefined, path: '' })
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})
+
+describe('createOutputStream()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      createOutputStream: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.createOutputStream('File')
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})
+
+describe('unlink()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      unlink: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.unlink('')
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})
+
+describe('getSize()', () => {
+  it(`throws in case of timeout`, async () => {
+    const testHandler = new TestHandler({
+      getSize: () => new Promise(() => {}),
+    })
+
+    const promise = testHandler.getSize('')
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
+  })
+})

@xen-orchestra/fs/src/checksum.js

@@ -1,6 +1,5 @@
 // @flow
 
-// $FlowFixMe
 import through2 from 'through2'
 import { createHash } from 'crypto'
 import { defer, fromEvent } from 'promise-toolbox'

@xen-orchestra/fs/src/fs.integ.spec.js

@@ -2,8 +2,8 @@
 
 import rimraf from 'rimraf'
 import tmp from 'tmp'
+import { pFromCallback } from 'promise-toolbox'
 
-import { fromCallback as pFromCallback } from 'promise-toolbox'
 import { getHandler } from '.'
 
 const initialDir = process.cwd()

@xen-orchestra/fs/src/index.js

@@ -14,7 +14,7 @@ const HANDLERS = {
   nfs: RemoteHandlerNfs,
 }
 
-export const getHandler = (remote: Remote): RemoteHandler => {
+export const getHandler = (remote: Remote, ...rest: any): RemoteHandler => {
   // FIXME: should be done in xo-remote-parser.
   const type = remote.url.split('://')[0]
 
@@ -22,5 +22,5 @@ export const getHandler = (remote: Remote): RemoteHandler => {
   if (!Handler) {
     throw new Error('Unhandled remote type')
   }
-  return new Handler(remote)
+  return new Handler(remote, ...rest)
 }

@xen-orchestra/fs/src/local.js

@@ -27,11 +27,10 @@ export default class LocalHandler extends RemoteHandlerAbstract {
   }
 
   async _sync () {
-    if (this._remote.enabled) {
-      const path = this._getRealPath()
-      await fs.ensureDir(path)
-      await fs.access(path, fs.R_OK | fs.W_OK)
-    }
+    const path = this._getRealPath()
+    await fs.ensureDir(path)
+    await fs.access(path, fs.R_OK | fs.W_OK)
+
     return this._remote
   }
 

@xen-orchestra/fs/src/nfs.js

@@ -1,77 +1,62 @@
 import execa from 'execa'
 import fs from 'fs-extra'
-import { forEach } from 'lodash'
+import { join } from 'path'
+import { tmpdir } from 'os'
 
 import LocalHandler from './local'
 
 const DEFAULT_NFS_OPTIONS = 'vers=3'
 
 export default class NfsHandler extends LocalHandler {
+  constructor (
+    remote,
+    { mountsDir = join(tmpdir(), 'xo-fs-mounts'), ...opts } = {}
+  ) {
+    super(remote, opts)
+
+    this._realPath = join(mountsDir, remote.id)
+  }
+
   get type () {
     return 'nfs'
   }
 
   _getRealPath () {
-    return `/run/xo-server/mounts/${this._remote.id}`
-  }
-
-  async _loadRealMounts () {
-    let stdout
-    const mounted = {}
-    try {
-      stdout = await execa.stdout('findmnt', [
-        '-P',
-        '-t',
-        'nfs,nfs4',
-        '--output',
-        'SOURCE,TARGET',
-        '--noheadings',
-      ])
-      const regex = /^SOURCE="([^:]*):(.*)" TARGET="(.*)"$/
-      forEach(stdout.split('\n'), m => {
-        if (m) {
-          const match = regex.exec(m)
-          mounted[match[3]] = {
-            host: match[1],
-            share: match[2],
-          }
-        }
-      })
-    } catch (exc) {
-      // When no mounts are found, the call pretends to fail...
-      if (exc.stderr !== '') {
-        throw exc
-      }
-    }
-
-    this._realMounts = mounted
-    return mounted
-  }
-
-  _matchesRealMount () {
-    return this._getRealPath() in this._realMounts
+    return this._realPath
   }
 
   async _mount () {
     await fs.ensureDir(this._getRealPath())
     const { host, path, port, options } = this._remote
-    return execa('mount', [
-      '-t',
-      'nfs',
-      '-o',
-      DEFAULT_NFS_OPTIONS + (options !== undefined ? `,${options}` : ''),
-      `${host}${port !== undefined ? ':' + port : ''}:${path}`,
-      this._getRealPath(),
-    ])
+    return execa(
+      'mount',
+      [
+        '-t',
+        'nfs',
+        '-o',
+        DEFAULT_NFS_OPTIONS + (options !== undefined ? `,${options}` : ''),
+        `${host}${port !== undefined ? ':' + port : ''}:${path}`,
+        this._getRealPath(),
+      ],
+      {
+        env: {
+          LANG: 'C',
+        },
+      }
+    ).catch(error => {
+      if (
+        error == null ||
+        typeof error.stderr !== 'string' ||
+        !error.stderr.includes('already mounted')
+      ) {
+        throw error
+      }
+    })
   }
 
   async _sync () {
-    await this._loadRealMounts()
-    if (this._matchesRealMount() && !this._remote.enabled) {
-      await this._umount(this._remote)
-    } else if (!this._matchesRealMount() && this._remote.enabled) {
-      await this._mount()
-    }
+    await this._mount()
+
     return this._remote
   }
 
@@ -83,7 +68,19 @@ export default class NfsHandler extends LocalHandler {
     }
   }
 
-  async _umount (remote) {
-    await execa('umount', ['--force', this._getRealPath()])
+  async _umount () {
+    await execa('umount', ['--force', this._getRealPath()], {
+      env: {
+        LANG: 'C',
+      },
+    }).catch(error => {
+      if (
+        error == null ||
+        typeof error.stderr !== 'string' ||
+        !error.stderr.includes('not mounted')
+      ) {
+        throw error
+      }
+    })
   }
 }

@xen-orchestra/fs/src/smb.js

@@ -1,30 +1,32 @@
 import Smb2 from '@marsaud/smb2'
-import { lastly as pFinally } from 'promise-toolbox'
+import { pFinally } from 'promise-toolbox'
 
 import RemoteHandlerAbstract from './abstract'
 
 const noop = () => {}
 
 // Normalize the error code for file not found.
-const normalizeError = error => {
+class ErrorWrapper extends Error {
+  constructor (error, newCode) {
+    super(error.message)
+    this.cause = error
+    this.code = newCode
+  }
+}
+const normalizeError = (error, shouldBeDirectory) => {
   const { code } = error
 
   return code === 'STATUS_OBJECT_NAME_NOT_FOUND' ||
     code === 'STATUS_OBJECT_PATH_NOT_FOUND'
-    ? Object.create(error, {
-        code: {
-          configurable: true,
-          readable: true,
-          value: 'ENOENT',
-          writable: true,
-        },
-      })
+    ? new ErrorWrapper(error, 'ENOENT')
+    : code === 'STATUS_NOT_SUPPORTED' || code === 'STATUS_INVALID_PARAMETER'
+    ? new ErrorWrapper(error, shouldBeDirectory ? 'ENOTDIR' : 'EISDIR')
     : error
 }
 
 export default class SmbHandler extends RemoteHandlerAbstract {
-  constructor (remote) {
-    super(remote)
+  constructor (remote, opts) {
+    super(remote, opts)
     this._forget = noop
   }
 
@@ -70,10 +72,9 @@ export default class SmbHandler extends RemoteHandlerAbstract {
   }
 
   async _sync () {
-    if (this._remote.enabled) {
-      // Check access (smb2 does not expose connect in public so far...)
-      await this.list()
-    }
+    // Check access (smb2 does not expose connect in public so far...)
+    await this.list()
+
     return this._remote
   }
 
@@ -154,7 +155,7 @@ export default class SmbHandler extends RemoteHandlerAbstract {
         client.disconnect()
       })
     } catch (error) {
-      throw normalizeError(error)
+      throw normalizeError(error, true)
     }
 
     return list

@xen-orchestra/log/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

@xen-orchestra/log/.npmignore

@@ -0,0 +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__/

@xen-orchestra/log/README.md

@@ -0,0 +1,160 @@
+# @xen-orchestra/log [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
+
+> ${pkg.description}
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/log):
+
+```
+> npm install --save @xen-orchestra/log
+```
+
+## Usage
+
+Everywhere something should be logged:
+
+```js
+import createLogger from '@xen-orchestra/log'
+
+const log = createLogger('my-module')
+
+log.debug('only useful for debugging')
+log.info('this information is relevant to the user')
+log.warn('something went wrong but did not prevent current action')
+log.error('something went wrong')
+log.fatal('service/app is going down')
+```
+
+Then, at application level, configure the logs are handled:
+
+```js
+import { configure, catchGlobalErrors } from '@xen-orchestra/log/configure'
+import transportConsole from '@xen-orchestra/log/transports/console'
+import transportEmail from '@xen-orchestra/log/transports/email'
+
+const transport = transportEmail({
+  service: 'gmail',
+  auth: {
+    user: 'jane.smith@gmail.com',
+    pass: 'H&NbECcpXF|pyXe#%ZEb'
+  },
+  from: 'jane.smith@gmail.com',
+  to: [
+    'jane.smith@gmail.com',
+    'sam.doe@yahoo.com'
+  ]
+})
+
+configure([
+  {
+    // if filter is a string, then it is pattern
+    // (https://github.com/visionmedia/debug#wildcards) which is
+    // matched against the namespace of the logs
+    filter: process.env.DEBUG,
+
+    transport: transportConsole()
+  },
+  {
+    // only levels >= warn
+    level: 'warn',
+
+    transport
+  }
+])
+
+// send all global errors (uncaught exceptions, warnings, unhandled rejections)
+// to this transport
+catchGlobalErrors(transport)
+```
+
+### Transports
+
+#### Console
+
+```js
+import transportConsole from '@xen-orchestra/log/transports/console'
+
+configure(transports.console())
+```
+
+#### Email
+
+Optional dependency:
+
+```
+> yarn add nodemailer pretty-format
+```
+
+Configuration:
+
+```js
+import transportEmail from '@xen-orchestra/log/transports/email'
+
+configure(transportEmail({
+  service: 'gmail',
+  auth: {
+    user: 'jane.smith@gmail.com',
+    pass: 'H&NbECcpXF|pyXe#%ZEb'
+  },
+  from: 'jane.smith@gmail.com',
+  to: [
+    'jane.smith@gmail.com',
+    'sam.doe@yahoo.com'
+  ]
+}))
+```
+
+#### Syslog
+
+Optional dependency:
+
+```
+> yarn add split-host syslog-client
+```
+
+Configuration:
+
+```js
+import transportSyslog from '@xen-orchestra/log/transports/syslog'
+
+// By default, log to udp://localhost:514
+configure(transportSyslog())
+
+// But TCP, a different host, or a different port can be used
+configure(transportSyslog('tcp://syslog.company.lan'))
+```
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/vatesfr/xo-web/issues/)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Vates SAS](https://vates.fr)

@xen-orchestra/log/configure.js

@@ -0,0 +1 @@
+module.exports = require('./dist/configure')

@xen-orchestra/log/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@xen-orchestra/log",
+  "version": "0.1.4",
+  "license": "ISC",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/log",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@vates.fr"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "configure.js",
+    "dist/",
+    "transports/"
+  ],
+  "browserslist": [
+    ">2%"
+  ],
+  "engines": {
+    "node": ">=4"
+  },
+  "dependencies": {
+    "lodash": "^4.17.4",
+    "promise-toolbox": "^0.11.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.3",
+    "index-modules": "^0.3.0",
+    "rimraf": "^2.6.2"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "clean": "rimraf dist/",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "prebuild": "yarn run clean",
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
+  }
+}

@xen-orchestra/log/src/configure.js

@@ -0,0 +1,106 @@
+import createConsoleTransport from './transports/console'
+import LEVELS, { resolve } from './levels'
+import { compileGlobPattern } from './utils'
+
+// ===================================================================
+
+const createTransport = config => {
+  if (typeof config === 'function') {
+    return config
+  }
+
+  if (Array.isArray(config)) {
+    const transports = config.map(createTransport)
+    const { length } = transports
+    return function () {
+      for (let i = 0; i < length; ++i) {
+        transports[i].apply(this, arguments)
+      }
+    }
+  }
+
+  let { filter, transport } = config
+  const level = resolve(config.level)
+
+  if (filter !== undefined) {
+    if (typeof filter === 'string') {
+      const re = compileGlobPattern(filter)
+      filter = log => re.test(log.namespace)
+    }
+
+    const orig = transport
+    transport = function (log) {
+      if ((level !== undefined && log.level >= level) || filter(log)) {
+        return orig.apply(this, arguments)
+      }
+    }
+  } else if (level !== undefined) {
+    const orig = transport
+    transport = function (log) {
+      if (log.level >= level) {
+        return orig.apply(this, arguments)
+      }
+    }
+  }
+
+  return transport
+}
+
+const symbol =
+  typeof Symbol !== 'undefined'
+    ? Symbol.for('@xen-orchestra/log')
+    : '@@@xen-orchestra/log'
+
+global[symbol] = createTransport({
+  // display warnings or above, and all that are enabled via DEBUG or
+  // NODE_DEBUG env
+  filter: process.env.DEBUG || process.env.NODE_DEBUG,
+  level: LEVELS.INFO,
+
+  transport: createConsoleTransport(),
+})
+
+export const configure = config => {
+  global[symbol] = createTransport(config)
+}
+
+// -------------------------------------------------------------------
+
+export const catchGlobalErrors = logger => {
+  // patch process
+  const onUncaughtException = error => {
+    logger.error('uncaught exception', { error })
+  }
+  const onUnhandledRejection = error => {
+    logger.warn('possibly unhandled rejection', { error })
+  }
+  const onWarning = error => {
+    logger.warn('Node warning', { error })
+  }
+  process.on('uncaughtException', onUncaughtException)
+  process.on('unhandledRejection', onUnhandledRejection)
+  process.on('warning', onWarning)
+
+  // patch EventEmitter
+  const EventEmitter = require('events')
+  const { prototype } = EventEmitter
+  const { emit } = prototype
+  function patchedEmit (event, error) {
+    if (event === 'error' && this.listenerCount(event) === 0) {
+      logger.error('unhandled error event', { error })
+      return false
+    }
+    return emit.apply(this, arguments)
+  }
+  prototype.emit = patchedEmit
+
+  return () => {
+    process.removeListener('uncaughtException', onUncaughtException)
+    process.removeListener('unhandledRejection', onUnhandledRejection)
+    process.removeListener('warning', onWarning)
+
+    if (prototype.emit === patchedEmit) {
+      prototype.emit = emit
+    }
+  }
+}

@xen-orchestra/log/src/index.js

@@ -0,0 +1,76 @@
+import createTransport from './transports/console'
+import LEVELS from './levels'
+
+const symbol =
+  typeof Symbol !== 'undefined'
+    ? Symbol.for('@xen-orchestra/log')
+    : '@@@xen-orchestra/log'
+if (!(symbol in global)) {
+  // the default behavior, without requiring `configure` is to avoid
+  // logging anything unless it's a real error
+  const transport = createTransport()
+  global[symbol] = log => log.level > LEVELS.WARN && transport(log)
+}
+
+// -------------------------------------------------------------------
+
+function Log (data, level, namespace, message, time) {
+  this.data = data
+  this.level = level
+  this.namespace = namespace
+  this.message = message
+  this.time = time
+}
+
+function Logger (namespace) {
+  this._namespace = namespace
+
+  // bind all logging methods
+  for (const name in LEVELS) {
+    const lowerCase = name.toLowerCase()
+    this[lowerCase] = this[lowerCase].bind(this)
+  }
+}
+
+const { prototype } = Logger
+
+for (const name in LEVELS) {
+  const level = LEVELS[name]
+
+  prototype[name.toLowerCase()] = function (message, data) {
+    if (typeof message !== 'string') {
+      if (message instanceof Error) {
+        data = { error: message }
+        ;({ message = 'an error has occured' } = message)
+      } else {
+        return this.warn('incorrect value passed to logger', {
+          level,
+          value: message,
+        })
+      }
+    }
+    global[symbol](new Log(data, level, this._namespace, message, new Date()))
+  }
+}
+
+prototype.wrap = function (message, fn) {
+  const logger = this
+  const warnAndRethrow = error => {
+    logger.warn(message, { error })
+    throw error
+  }
+  return function () {
+    try {
+      const result = fn.apply(this, arguments)
+      const then = result != null && result.then
+      return typeof then === 'function'
+        ? then.call(result, warnAndRethrow)
+        : result
+    } catch (error) {
+      warnAndRethrow(error)
+    }
+  }
+}
+
+const createLogger = namespace => new Logger(namespace)
+export { createLogger as default }

@xen-orchestra/log/src/levels.js

@@ -0,0 +1,24 @@
+const LEVELS = Object.create(null)
+export { LEVELS as default }
+
+// https://github.com/trentm/node-bunyan#levels
+LEVELS.FATAL = 60 // service/app is going down
+LEVELS.ERROR = 50 // fatal for current action
+LEVELS.WARN = 40 // something went wrong but it's not fatal
+LEVELS.INFO = 30 // detail on unusual but normal operation
+LEVELS.DEBUG = 20
+
+export const NAMES = Object.create(null)
+for (const name in LEVELS) {
+  NAMES[LEVELS[name]] = name
+}
+
+export const resolve = level => {
+  if (typeof level === 'string') {
+    level = LEVELS[level.toUpperCase()]
+  }
+  return level
+}
+
+Object.freeze(LEVELS)
+Object.freeze(NAMES)

@xen-orchestra/log/src/levels.spec.js

@@ -0,0 +1,32 @@
+/* eslint-env jest */
+
+import { forEach, isInteger } from 'lodash'
+
+import LEVELS, { NAMES, resolve } from './levels'
+
+describe('LEVELS', () => {
+  it('maps level names to their integer values', () => {
+    forEach(LEVELS, (value, name) => {
+      expect(isInteger(value)).toBe(true)
+    })
+  })
+})
+
+describe('NAMES', () => {
+  it('maps level values to their names', () => {
+    forEach(LEVELS, (value, name) => {
+      expect(NAMES[value]).toBe(name)
+    })
+  })
+})
+
+describe('resolve()', () => {
+  it('returns level values either from values or names', () => {
+    forEach(LEVELS, value => {
+      expect(resolve(value)).toBe(value)
+    })
+    forEach(NAMES, (name, value) => {
+      expect(resolve(name)).toBe(+value)
+    })
+  })
+})

@xen-orchestra/log/src/transports/console.js

@@ -0,0 +1,24 @@
+import LEVELS, { NAMES } from '../levels'
+
+// Bind console methods (necessary for browsers)
+const debugConsole = console.log.bind(console)
+const infoConsole = console.info.bind(console)
+const warnConsole = console.warn.bind(console)
+const errorConsole = console.error.bind(console)
+
+const { ERROR, INFO, WARN } = LEVELS
+
+const consoleTransport = ({ data, level, namespace, message, time }) => {
+  const fn =
+    level < INFO
+      ? debugConsole
+      : level < WARN
+      ? infoConsole
+      : level < ERROR
+      ? warnConsole
+      : errorConsole
+
+  fn('%s - %s - [%s] %s', time.toISOString(), namespace, NAMES[level], message)
+  data != null && fn(data)
+}
+export default () => consoleTransport

@xen-orchestra/log/src/transports/email.js

@@ -0,0 +1,68 @@
+import fromCallback from 'promise-toolbox/fromCallback'
+import prettyFormat from 'pretty-format' // eslint-disable-line node/no-extraneous-import
+import { createTransport } from 'nodemailer' // eslint-disable-line node/no-extraneous-import
+
+import { evalTemplate, required } from '../utils'
+import { NAMES } from '../levels'
+
+export default ({
+  // transport options (https://nodemailer.com/smtp/)
+  auth,
+  authMethod,
+  host,
+  ignoreTLS,
+  port,
+  proxy,
+  requireTLS,
+  secure,
+  service,
+  tls,
+
+  // message options (https://nodemailer.com/message/)
+  bcc,
+  cc,
+  from = required('from'),
+  to = required('to'),
+  subject = '[{{level}} - {{namespace}}] {{time}} {{message}}',
+}) => {
+  const transporter = createTransport(
+    {
+      auth,
+      authMethod,
+      host,
+      ignoreTLS,
+      port,
+      proxy,
+      requireTLS,
+      secure,
+      service,
+      tls,
+
+      disableFileAccess: true,
+      disableUrlAccess: true,
+    },
+    {
+      bcc,
+      cc,
+      from,
+      to,
+    }
+  )
+
+  return log =>
+    fromCallback(cb =>
+      transporter.sendMail(
+        {
+          subject: evalTemplate(subject, key =>
+            key === 'level'
+              ? NAMES[log.level]
+              : key === 'time'
+              ? log.time.toISOString()
+              : log[key]
+          ),
+          text: prettyFormat(log.data),
+        },
+        cb
+      )
+    )
+}

@xen-orchestra/log/src/transports/memory.js

@@ -0,0 +1,7 @@
+export default () => {
+  const memoryLogger = log => {
+    logs.push(log)
+  }
+  const logs = (memoryLogger.logs = [])
+  return memoryLogger
+}

@xen-orchestra/log/src/transports/syslog.js

@@ -0,0 +1,42 @@
+import fromCallback from 'promise-toolbox/fromCallback'
+import splitHost from 'split-host' // eslint-disable-line node/no-extraneous-import node/no-missing-import
+import startsWith from 'lodash/startsWith'
+import { createClient, Facility, Severity, Transport } from 'syslog-client' // eslint-disable-line node/no-extraneous-import node/no-missing-import
+
+import LEVELS from '../levels'
+
+// https://github.com/paulgrove/node-syslog-client#syslogseverity
+const LEVEL_TO_SEVERITY = {
+  [LEVELS.FATAL]: Severity.Critical,
+  [LEVELS.ERROR]: Severity.Error,
+  [LEVELS.WARN]: Severity.Warning,
+  [LEVELS.INFO]: Severity.Informational,
+  [LEVELS.DEBUG]: Severity.Debug,
+}
+
+const facility = Facility.User
+
+export default target => {
+  const opts = {}
+  if (target !== undefined) {
+    if (startsWith(target, 'tcp://')) {
+      target = target.slice(6)
+      opts.transport = Transport.Tcp
+    } else if (startsWith(target, 'udp://')) {
+      target = target.slice(6)
+      opts.transport = Transport.Udp
+    }
+
+    ;({ host: target, port: opts.port } = splitHost(target))
+  }
+
+  const client = createClient(target, opts)
+
+  return log =>
+    fromCallback(cb =>
+      client.log(log.message, {
+        facility,
+        severity: LEVEL_TO_SEVERITY[log.level],
+      })
+    )
+}

@xen-orchestra/log/src/utils.js

@@ -0,0 +1,62 @@
+import escapeRegExp from 'lodash/escapeRegExp'
+
+// ===================================================================
+
+const TPL_RE = /\{\{(.+?)\}\}/g
+export const evalTemplate = (tpl, data) => {
+  const getData =
+    typeof data === 'function' ? (_, key) => data(key) : (_, key) => data[key]
+
+  return tpl.replace(TPL_RE, getData)
+}
+
+// -------------------------------------------------------------------
+
+const compileGlobPatternFragment = pattern =>
+  pattern
+    .split('*')
+    .map(escapeRegExp)
+    .join('.*')
+
+export const compileGlobPattern = pattern => {
+  const no = []
+  const yes = []
+  pattern.split(/[\s,]+/).forEach(pattern => {
+    if (pattern[0] === '-') {
+      no.push(pattern.slice(1))
+    } else {
+      yes.push(pattern)
+    }
+  })
+
+  const raw = ['^']
+
+  if (no.length !== 0) {
+    raw.push('(?!', no.map(compileGlobPatternFragment).join('|'), ')')
+  }
+
+  if (yes.length !== 0) {
+    raw.push('(?:', yes.map(compileGlobPatternFragment).join('|'), ')')
+  } else {
+    raw.push('.*')
+  }
+
+  raw.push('$')
+
+  return new RegExp(raw.join(''))
+}
+
+// -------------------------------------------------------------------
+
+export const required = name => {
+  throw new Error(`missing required arg ${name}`)
+}
+
+// -------------------------------------------------------------------
+
+export const serializeError = error => ({
+  ...error,
+  message: error.message,
+  name: error.name,
+  stack: error.stack,
+})

@xen-orchestra/log/src/utils.spec.js

@@ -0,0 +1,13 @@
+/* eslint-env jest */
+
+import { compileGlobPattern } from './utils'
+
+describe('compileGlobPattern()', () => {
+  it('works', () => {
+    const re = compileGlobPattern('foo, ba*, -bar')
+    expect(re.test('foo')).toBe(true)
+    expect(re.test('bar')).toBe(false)
+    expect(re.test('baz')).toBe(true)
+    expect(re.test('qux')).toBe(false)
+  })
+})

@xen-orchestra/log/transports/console.js

@@ -0,0 +1 @@
+module.exports = require('../dist/transports/console.js')

@xen-orchestra/log/transports/email.js

@@ -0,0 +1 @@
+module.exports = require('../dist/transports/email.js')

@xen-orchestra/log/transports/memory.js

@@ -0,0 +1 @@
+module.exports = require('../dist/transports/memory.js')

@xen-orchestra/log/transports/syslog.js

@@ -0,0 +1 @@
+module.exports = require('../dist/transports/syslog.js')

@xen-orchestra/mixin/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

@xen-orchestra/mixin/.npmignore

@@ -0,0 +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__/

@xen-orchestra/mixin/README.md

@@ -0,0 +1,49 @@
+# ${pkg.name} [![Build Status](https://travis-ci.org/${pkg.shortGitHubPath}.png?branch=master)](https://travis-ci.org/${pkg.shortGitHubPath})
+
+> ${pkg.description}
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/${pkg.name}):
+
+```
+> npm install --save ${pkg.name}
+```
+
+## Usage
+
+**TODO**
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](${pkg.bugs})
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+${pkg.license} © [${pkg.author.name}](${pkg.author.url})

@xen-orchestra/mixin/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@xen-orchestra/mixin",
+  "version": "0.0.0",
+  "license": "ISC",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/mixin",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@vates.fr"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "browserslist": [
+    ">2%"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "dependencies": {
+    "bind-property-descriptor": "^1.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "babel-plugin-dev": "^1.0.0",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "clean": "rimraf dist/",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "prebuild": "yarn run clean",
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
+  }
+}

@xen-orchestra/mixin/src/index.js

@@ -0,0 +1,130 @@
+import { getBoundPropertyDescriptor } from 'bind-property-descriptor'
+
+// ===================================================================
+
+const { defineProperties, getOwnPropertyDescriptor } = Object
+
+const isIgnoredProperty = name => name[0] === '_' || name === 'constructor'
+
+const IGNORED_STATIC_PROPERTIES = {
+  __proto__: null,
+
+  arguments: true,
+  caller: true,
+  length: true,
+  name: true,
+  prototype: true,
+}
+const isIgnoredStaticProperty = name => name in IGNORED_STATIC_PROPERTIES
+
+const ownKeys =
+  (typeof Reflect !== 'undefined' && Reflect.ownKeys) ||
+  (({ getOwnPropertyNames: names, getOwnPropertySymbols: symbols }) =>
+    symbols !== undefined ? obj => names(obj).concat(symbols(obj)) : names)(
+    Object
+  )
+
+// -------------------------------------------------------------------
+
+const mixin = Mixins => Class => {
+  if (__DEV__ && !Array.isArray(Mixins)) {
+    throw new TypeError('Mixins should be an array')
+  }
+
+  const { name } = Class
+
+  // Copy properties of plain object mix-ins to the prototype.
+  {
+    const allMixins = Mixins
+    Mixins = []
+    const { prototype } = Class
+    const descriptors = { __proto__: null }
+    allMixins.forEach(Mixin => {
+      if (typeof Mixin === 'function') {
+        Mixins.push(Mixin)
+        return
+      }
+
+      for (const prop of ownKeys(Mixin)) {
+        if (__DEV__ && prop in prototype) {
+          throw new Error(`${name}#${prop} is already defined`)
+        }
+
+        ;(descriptors[prop] = getOwnPropertyDescriptor(
+          Mixin,
+          prop
+        )).enumerable = false // Object methods are enumerable but class methods are not.
+      }
+    })
+    defineProperties(prototype, descriptors)
+  }
+
+  const n = Mixins.length
+
+  function DecoratedClass (...args) {
+    const instance = new Class(...args)
+
+    for (let i = 0; i < n; ++i) {
+      const Mixin = Mixins[i]
+      const { prototype } = Mixin
+      const mixinInstance = new Mixin(instance, ...args)
+      const descriptors = { __proto__: null }
+      const props = ownKeys(prototype)
+      for (let j = 0, m = props.length; j < m; ++j) {
+        const prop = props[j]
+
+        if (isIgnoredProperty(prop)) {
+          continue
+        }
+
+        if (prop in instance) {
+          throw new Error(`${name}#${prop} is already defined`)
+        }
+
+        descriptors[prop] = getBoundPropertyDescriptor(
+          prototype,
+          prop,
+          mixinInstance
+        )
+      }
+      defineProperties(instance, descriptors)
+    }
+
+    return instance
+  }
+
+  // Copy original and mixed-in static properties on Decorator class.
+  const descriptors = { __proto__: null }
+  ownKeys(Class).forEach(prop => {
+    let descriptor
+    if (
+      !(
+        isIgnoredStaticProperty(prop) &&
+        // if they already exist...
+        (descriptor = getOwnPropertyDescriptor(DecoratedClass, prop)) !==
+          undefined &&
+        // and are not configurable.
+        !descriptor.configurable
+      )
+    ) {
+      descriptors[prop] = getOwnPropertyDescriptor(Class, prop)
+    }
+  })
+  Mixins.forEach(Mixin => {
+    ownKeys(Mixin).forEach(prop => {
+      if (isIgnoredStaticProperty(prop)) {
+        return
+      }
+
+      if (__DEV__ && prop in descriptors) {
+        throw new Error(`${name}.${prop} is already defined`)
+      }
+
+      descriptors[prop] = getOwnPropertyDescriptor(Mixin, prop)
+    })
+  })
+  defineProperties(DecoratedClass, descriptors)
+
+  return DecoratedClass
+}
+export { mixin as default }

CHANGELOG.md

@@ -8,9 +8,244 @@
 
 ### Released packages
 
+- xo-server v5.31.0
+- xo-web v5.31.0
+
+## **5.28.2** (2018-11-16)
+
+### Enhancements
+
+- [VM] Ability to set nested virtualization in settings [#3619](https://github.com/vatesfr/xen-orchestra/issues/3619) (PR [#3625](https://github.com/vatesfr/xen-orchestra/pull/3625))
+- [Legacy Backup] Restore and File restore functionalities moved to the Backup NG view [#3499](https://github.com/vatesfr/xen-orchestra/issues/3499) (PR [#3610](https://github.com/vatesfr/xen-orchestra/pull/3610))
+- [Backup NG logs] Display warning in case of missing VMs instead of a ghosts VMs tasks (PR [#3647](https://github.com/vatesfr/xen-orchestra/pull/3647))
+- [VM] On migration, automatically selects the host and SR when only one is available [#3502](https://github.com/vatesfr/xen-orchestra/issues/3502) (PR [#3654](https://github.com/vatesfr/xen-orchestra/pull/3654))
+- [VM] Display VGA and video RAM for PVHVM guests [#3576](https://github.com/vatesfr/xen-orchestra/issues/3576) (PR [#3664](https://github.com/vatesfr/xen-orchestra/pull/3664))
+- [Backup NG form] Display a warning to let the user know that the Delta Backup and the Continuous Replication are not supported on XenServer < 6.5 [#3540](https://github.com/vatesfr/xen-orchestra/issues/3540) (PR [#3668](https://github.com/vatesfr/xen-orchestra/pull/3668))
+- [Backup NG form] Omit VMs(Simple Backup)/pools(Smart Backup/Resident on) with XenServer < 6.5 from the selection when the Delta Backup mode or the Continuous Replication mode are selected [#3540](https://github.com/vatesfr/xen-orchestra/issues/3540) (PR [#3668](https://github.com/vatesfr/xen-orchestra/pull/3668))
+- [VM] Allow to switch the Virtualization mode [#2372](https://github.com/vatesfr/xen-orchestra/issues/2372) (PR [#3669](https://github.com/vatesfr/xen-orchestra/pull/3669))
+
+### Bug fixes
+
+- [Backup ng logs] Fix restarting VMs with concurrency issue [#3603](https://github.com/vatesfr/xen-orchestra/issues/3603) (PR [#3634](https://github.com/vatesfr/xen-orchestra/pull/3634))
+- Validate modal containing a confirm text input by pressing the Enter key [#2735](https://github.com/vatesfr/xen-orchestra/issues/2735) (PR [#2890](https://github.com/vatesfr/xen-orchestra/pull/2890))
+- [Patches] Bulk install correctly ignores upgrade patches on licensed hosts (PR [#3651](https://github.com/vatesfr/xen-orchestra/pull/3651))
+- [Backup NG logs] Handle failed restores (PR [#3648](https://github.com/vatesfr/xen-orchestra/pull/3648))
+- [Self/New VM] Incorrect limit computation [#3658](https://github.com/vatesfr/xen-orchestra/issues/3658) (PR [#3666](https://github.com/vatesfr/xen-orchestra/pull/3666))
+- [Plugins] Don't expose credentials in config to users (PR [#3671](https://github.com/vatesfr/xen-orchestra/pull/3671))
+- [Self/New VM] `not enough … available in the set …` error in some cases (PR [#3667](https://github.com/vatesfr/xen-orchestra/pull/3667))
+- [XOSAN] Creation stuck at "Configuring VMs" [#3688](https://github.com/vatesfr/xen-orchestra/issues/3688) (PR [#3689](https://github.com/vatesfr/xen-orchestra/pull/3689))
+- [Backup NG] Errors listing backups on SMB remotes with extraneous files (PR [#3685](https://github.com/vatesfr/xen-orchestra/pull/3685))
+- [Remotes] Don't expose credentials to users [#3682](https://github.com/vatesfr/xen-orchestra/issues/3682) (PR [#3687](https://github.com/vatesfr/xen-orchestra/pull/3687))
+- [VM] Correctly display guest metrics updates (tools, network, etc.) [#3533](https://github.com/vatesfr/xen-orchestra/issues/3533) (PR [#3694](https://github.com/vatesfr/xen-orchestra/pull/3694))
+- [VM Templates] Fix deletion [#3498](https://github.com/vatesfr/xen-orchestra/issues/3498) (PR [#3695](https://github.com/vatesfr/xen-orchestra/pull/3695))
+
+### Released packages
+
+- xen-api v0.21.0
+- xo-common v0.2.0
+- xo-acl-resolver v0.4.0
+- xo-server v5.30.1
+- xo-web v5.30.0
+
+## **5.28.1** (2018-11-05)
+
+### Enhancements
+
+### Bug fixes
+
+- [Backup NG] Increase timeout in stale remotes detection to limit false positives (PR [#3632](https://github.com/vatesfr/xen-orchestra/pull/3632))
+- Fix re-registration issue ([4e35b19ac](https://github.com/vatesfr/xen-orchestra/commit/4e35b19ac56c60f61c0e771cde70a50402797b8a))
+- [Backup NG logs] Fix started jobs filter [#3636](https://github.com/vatesfr/xen-orchestra/issues/3636) (PR [#3641](https://github.com/vatesfr/xen-orchestra/pull/3641))
+- [New VM] CPU and memory user inputs were ignored since previous release [#3644](https://github.com/vatesfr/xen-orchestra/issues/3644) (PR [#3646](https://github.com/vatesfr/xen-orchestra/pull/3646))
+
+### Released packages
+
+- @xen-orchestra/fs v0.4.1
+- xo-server v5.29.4
+- xo-web v5.29.3
+
+## **5.28.0** (2018-10-31)
+
+### Enhancements
+
+- [Usage Report] Add IOPS read/write/total per VM [#3309](https://github.com/vatesfr/xen-orchestra/issues/3309) (PR [#3455](https://github.com/vatesfr/xen-orchestra/pull/3455))
+- [Self service] Sort resource sets by name (PR [#3507](https://github.com/vatesfr/xen-orchestra/pull/3507))
+- [Usage Report] Add top 3 SRs which use the most IOPS read/write/total [#3306](https://github.com/vatesfr/xen-orchestra/issues/3306) (PR [#3508](https://github.com/vatesfr/xen-orchestra/pull/3508))
+- [New VM] Display a warning when the memory is below the template memory static min [#3496](https://github.com/vatesfr/xen-orchestra/issues/3496) (PR [#3513](https://github.com/vatesfr/xen-orchestra/pull/3513))
+- [Backup NG form] Add link to plugins setting [#3457](https://github.com/vatesfr/xen-orchestra/issues/3457) (PR [#3514](https://github.com/vatesfr/xen-orchestra/pull/3514))
+- [Backup reports] Add job and run ID [#3488](https://github.com/vatesfr/xen-orchestra/issues/3488) (PR [#3516](https://github.com/vatesfr/xen-orchestra/pull/3516))
+- [Usage Report] Add top 3 VMs which use the most IOPS read/write/total [#3308](https://github.com/vatesfr/xen-orchestra/issues/3308) (PR [#3463](https://github.com/vatesfr/xen-orchestra/pull/3463))
+- [Settings/logs] Homogenize action buttons in table and enable bulk deletion [#3179](https://github.com/vatesfr/xen-orchestra/issues/3179) (PR [#3528](https://github.com/vatesfr/xen-orchestra/pull/3528))
+- [Settings/acls] Add bulk deletion [#3179](https://github.com/vatesfr/xen-orchestra/issues/3179) (PR [#3536](https://github.com/vatesfr/xen-orchestra/pull/3536))
+- [Home] Improve search usage: raw numbers also match in names [#2906](https://github.com/vatesfr/xen-orchestra/issues/2906) (PR [#3552](https://github.com/vatesfr/xen-orchestra/pull/3552))
+- [Backup NG] Timeout of a job is now in hours [#3550](https://github.com/vatesfr/xen-orchestra/issues/3550) (PR [#3553](https://github.com/vatesfr/xen-orchestra/pull/3553))
+- [Backup NG] Explicit error if a VM is missing [#3434](https://github.com/vatesfr/xen-orchestra/issues/3434) (PR [#3522](https://github.com/vatesfr/xen-orchestra/pull/3522))
+- [Backup NG] Show all advanced settings with non-default values in overview [#3549](https://github.com/vatesfr/xen-orchestra/issues/3549) (PR [#3554](https://github.com/vatesfr/xen-orchestra/pull/3554))
+- [Backup NG] Collapse advanced settings by default [#3551](https://github.com/vatesfr/xen-orchestra/issues/3551) (PR [#3559](https://github.com/vatesfr/xen-orchestra/pull/3559))
+- [Scheduling] Merge selection and interval tabs [#1902](https://github.com/vatesfr/xen-orchestra/issues/1902) (PR [#3519](https://github.com/vatesfr/xen-orchestra/pull/3519))
+- [Backup NG/Restore] The backup selector now also shows the job name [#3366](https://github.com/vatesfr/xen-orchestra/issues/3366) (PR [#3564](https://github.com/vatesfr/xen-orchestra/pull/3564))
+- Sort buttons by criticality in tables [#3168](https://github.com/vatesfr/xen-orchestra/issues/3168) (PR [#3545](https://github.com/vatesfr/xen-orchestra/pull/3545))
+- [Usage Report] Ability to send a daily report [#3544](https://github.com/vatesfr/xen-orchestra/issues/3544) (PR [#3582](https://github.com/vatesfr/xen-orchestra/pull/3582))
+- [Backup NG logs] Disable state filters with no entries [#3438](https://github.com/vatesfr/xen-orchestra/issues/3438) (PR [#3442](https://github.com/vatesfr/xen-orchestra/pull/3442))
+- [ACLs] Global performance improvement on UI for non-admin users [#3578](https://github.com/vatesfr/xen-orchestra/issues/3578) (PR [#3584](https://github.com/vatesfr/xen-orchestra/pull/3584))
+- [Backup NG] Improve the Schedule's view (Replace table by list) [#3491](https://github.com/vatesfr/xen-orchestra/issues/3491) (PR [#3586](https://github.com/vatesfr/xen-orchestra/pull/3586))
+- ([Host/Storage], [Sr/hosts]) add bulk deletion [#3179](https://github.com/vatesfr/xen-orchestra/issues/3179) (PR [#3539](https://github.com/vatesfr/xen-orchestra/pull/3539))
+- [xo-server] Use @xen-orchestra/log for basic logging [#3555](https://github.com/vatesfr/xen-orchestra/issues/3555) (PR [#3579](https://github.com/vatesfr/xen-orchestra/pull/3579))
+- [Backup Report] Log error when job failed [#3458](https://github.com/vatesfr/xen-orchestra/issues/3458) (PR [#3593](https://github.com/vatesfr/xen-orchestra/pull/3593))
+- [Backup NG] Display logs for backup restoration [#2511](https://github.com/vatesfr/xen-orchestra/issues/2511) (PR [#3609](https://github.com/vatesfr/xen-orchestra/pull/3609))
+- [XOA] Display product version and list of all installed packages [#3560](https://github.com/vatesfr/xen-orchestra/issues/3560) (PR [#3621](https://github.com/vatesfr/xen-orchestra/pull/3621))
+
+### Bug fixes
+
+- [Remotes] Fix removal of broken remotes [#3327](https://github.com/vatesfr/xen-orchestra/issues/3327) (PR [#3521](https://github.com/vatesfr/xen-orchestra/pull/3521))
+- [Backups] Fix stuck backups due to broken NFS remotes [#3467](https://github.com/vatesfr/xen-orchestra/issues/3467) (PR [#3534](https://github.com/vatesfr/xen-orchestra/pull/3534))
+- [New VM] Fix missing cloud config when creating multiple VMs at once in some cases [#3532](https://github.com/vatesfr/xen-orchestra/issues/3532) (PR [#3535](https://github.com/vatesfr/xen-orchestra/pull/3535))
+- [VM] Fix an error when an admin tried to add a disk on a Self VM whose resource set had been deleted [#2814](https://github.com/vatesfr/xen-orchestra/issues/2814) (PR [#3530](https://github.com/vatesfr/xen-orchestra/pull/3530))
+- [Self/Create VM] Fix some quotas based on the template instead of the user inputs [#2683](https://github.com/vatesfr/xen-orchestra/issues/2683) (PR [#3546](https://github.com/vatesfr/xen-orchestra/pull/3546))
+- [Self] Ignore DR and CR VMs when computing quotas [#3064](https://github.com/vatesfr/xen-orchestra/issues/3064) (PR [#3561](https://github.com/vatesfr/xen-orchestra/pull/3561))
+- [Patches] Wrongly requiring to eject CDs from halted VMs and snapshots before installing patches (PR [#3611](https://github.com/vatesfr/xen-orchestra/pull/3611))
+- [Jobs] Ensure the scheduling is not interrupted in rare cases (PR [#3617](https://github.com/vatesfr/xen-orchestra/pull/3617))
+- [Home] Fix `server.getAll` error at login when user is not admin [#2335](https://github.com/vatesfr/xen-orchestra/issues/2335) (PR [#3613](https://github.com/vatesfr/xen-orchestra/pull/3613))
+
+### Released packages
+
+- xo-server-backup-reports v0.15.0
+- xo-common v0.1.2
+- @xen-orchestra/log v0.1.0
+- @xen-orchestra/fs v0.4.0
+- complex-matcher v0.5.0
+- vhd-lib v0.4.0
+- xen-api v0.20.0
+- xo-server-usage-report v0.7.0
+- xo-server v5.29.0
+- xo-web v5.29.0
+
+## **5.27.2** (2018-10-05)
+
+### Enhancements
+
+- [Host/Networks] Remove "Add network" button [#3386](https://github.com/vatesfr/xen-orchestra/issues/3386) (PR [#3478](https://github.com/vatesfr/xen-orchestra/pull/3478))
+- [Host/networks] Private networks table [#3387](https://github.com/vatesfr/xen-orchestra/issues/3387) (PR [#3481](https://github.com/vatesfr/xen-orchestra/pull/3481))
+- [Home/pool] Patch count pill now shows the number of unique patches in the pool [#3321](https://github.com/vatesfr/xen-orchestra/issues/3321) (PR [#3483](https://github.com/vatesfr/xen-orchestra/pull/3483))
+- [Patches] Pre-install checks to avoid errors [#3252](https://github.com/vatesfr/xen-orchestra/issues/3252) (PR [#3484](https://github.com/vatesfr/xen-orchestra/pull/3484))
+- [Vm/Snapshots] Allow VM operators to create snapshots and delete those they created [#3443](https://github.com/vatesfr/xen-orchestra/issues/3443) (PR [#3482](https://github.com/vatesfr/xen-orchestra/pull/3482))
+- [VM/clone] Handle ACLs and Self Service [#3139](https://github.com/vatesfr/xen-orchestra/issues/3139) (PR [#3493](https://github.com/vatesfr/xen-orchestra/pull/3493))
+
+### Bug fixes
+
+- [Backup NG] Fix `Cannot read property 'uuid' of undefined` when a disk is removed from a VM to backup (PR [#3479](https://github.com/vatesfr/xen-orchestra/pull/3479))
+- [Backup NG] Fix unexpected full after failure, interruption or basic rolling snapshot (PR [#3485](https://github.com/vatesfr/xen-orchestra/pull/3485))
+- [Usage report] Display top 3 used SRs instead of top 3 biggest SRs [#3307](https://github.com/vatesfr/xen-orchestra/issues/3307) (PR [#3475](https://github.com/vatesfr/xen-orchestra/pull/3475))
+
+### Released packages
+
+- vhd-lib v0.3.2
+- xo-vmdk-to-vhd v0.1.5
+- xo-server-usage-report v0.6.0
+- xo-acl-resolver v0.3.0
+- xo-server v5.28.0
+- xo-web v5.28.0
+
+## **5.27.1** (2018-09-28)
+
+### Enhancements
+
+### Bug fixes
+
+- [OVA Import] Allow import of files bigger than 127GB (PR [#3451](https://github.com/vatesfr/xen-orchestra/pull/3451))
+- [File restore] Fix a path issue when going back to the parent folder (PR [#3446](https://github.com/vatesfr/xen-orchestra/pull/3446))
+- [File restore] Fix a minor issue when showing which selected files are redundant (PR [#3447](https://github.com/vatesfr/xen-orchestra/pull/3447))
+- [Memory] Fix a major leak [#2580](https://github.com/vatesfr/xen-orchestra/issues/2580) [#2820](https://github.com/vatesfr/xen-orchestra/issues/2820) (PR [#3453](https://github.com/vatesfr/xen-orchestra/pull/3453))
+- [NFS Remotes] Fix `already mounted` race condition [#3380](https://github.com/vatesfr/xen-orchestra/issues/3380) (PR [#3460](https://github.com/vatesfr/xen-orchestra/pull/3460))
+- Fix `Cannot read property 'type' of undefined` when deleting a VM (PR [#3465](https://github.com/vatesfr/xen-orchestra/pull/3465))
+
+### Released packages
+
+- @xen-orchestra/fs v0.3.1
+- vhd-lib v0.3.1
+- xo-vmdk-to-vhd v0.1.4
+- xo-server v5.27.2
+- xo-web v5.27.1
+
+## **5.27.0** (2018-09-24)
+
+### Enhancements
+
+- [Remotes] Test the remote automatically on changes [#3323](https://github.com/vatesfr/xen-orchestra/issues/3323) (PR [#3397](https://github.com/vatesfr/xen-orchestra/pull/3397))
+- [Remotes] Use *WORKGROUP* as default domain for new SMB remote (PR [#3398](https://github.com/vatesfr/xen-orchestra/pull/3398))
+- [Backup NG form] Display a tip to encourage users to create vms on a thin-provisioned storage [#3334](https://github.com/vatesfr/xen-orchestra/issues/3334) (PR [#3402](https://github.com/vatesfr/xen-orchestra/pull/3402))
+- [Backup NG form] improve schedule's form [#3138](https://github.com/vatesfr/xen-orchestra/issues/3138) (PR [#3359](https://github.com/vatesfr/xen-orchestra/pull/3359))
+- [Backup NG Overview] Display transferred and merged data size for backup jobs [#3340](https://github.com/vatesfr/xen-orchestra/issues/3340) (PR [#3408](https://github.com/vatesfr/xen-orchestra/pull/3408))
+- [VM] Display the PVHVM status [#3014](https://github.com/vatesfr/xen-orchestra/issues/3014) (PR [#3418](https://github.com/vatesfr/xen-orchestra/pull/3418))
+- [Backup reports] Ability to test the plugin (PR [#3421](https://github.com/vatesfr/xen-orchestra/pull/3421))
+- [Backup NG] Ability to restart failed VMs' backup [#3339](https://github.com/vatesfr/xen-orchestra/issues/3339) (PR [#3420](https://github.com/vatesfr/xen-orchestra/pull/3420))
+- [VM] Ability to change the NIC type [#3423](https://github.com/vatesfr/xen-orchestra/issues/3423) (PR [#3440](https://github.com/vatesfr/xen-orchestra/pull/3440))
+- [Backup NG Overview] Display the schedule's name [#3444](https://github.com/vatesfr/xen-orchestra/issues/3444) (PR [#3445](https://github.com/vatesfr/xen-orchestra/pull/3445))
+
+### Bug fixes
+
+- [Remotes] Rename connect(ed)/disconnect(ed) to enable(d)/disable(d) [#3323](https://github.com/vatesfr/xen-orchestra/issues/3323) (PR [#3396](https://github.com/vatesfr/xen-orchestra/pull/3396))
+- [Remotes] Fix error appears twice on testing (PR [#3399](https://github.com/vatesfr/xen-orchestra/pull/3399))
+- [Backup NG] Don't fail on VMs with empty VBDs (like CDs or floppy disks) (PR [#3410](https://github.com/vatesfr/xen-orchestra/pull/3410))
+- [XOA updater] Fix issue where trial request would fail [#3407](https://github.com/vatesfr/xen-orchestra/issues/3407) (PR [#3412](https://github.com/vatesfr/xen-orchestra/pull/3412))
+- [Backup NG logs] Fix log's value not being updated in the copy and report button [#3273](https://github.com/vatesfr/xen-orchestra/issues/3273) (PR [#3360](https://github.com/vatesfr/xen-orchestra/pull/3360))
+- [Backup NG] Fix issue when *Delete first* was enabled for some of the remotes [#3424](https://github.com/vatesfr/xen-orchestra/issues/3424) (PR [#3427](https://github.com/vatesfr/xen-orchestra/pull/3427))
+- [VM/host consoles] Work around a XenServer/XCP-ng issue which lead to some consoles not working [#3432](https://github.com/vatesfr/xen-orchestra/issues/3432) (PR [#3435](https://github.com/vatesfr/xen-orchestra/pull/3435))
+- [Backup NG] Remove extraneous snapshots in case of multiple schedules [#3132](https://github.com/vatesfr/xen-orchestra/issues/3132) (PR [#3439](https://github.com/vatesfr/xen-orchestra/pull/3439))
+- [Backup NG] Fix page reloaded on creating a schedule [#3461](https://github.com/vatesfr/xen-orchestra/issues/3461) (PR [#3462](https://github.com/vatesfr/xen-orchestra/pull/3462))
+
+### Released packages
+
+- xo-server-backup-reports v0.14.0
+- @xen-orchestra/async-map v0.0.0
+- @xen-orchestra/defined v0.0.0
+- @xen-orchestra/emit-async v0.0.0
+- @xen-orchestra/mixin v0.0.0
+- xo-server v5.27.0
+- xo-web v5.27.0
+
+## **5.26.0** (2018-09-07)
+
+### Enhancements
+
+- [Backup (file) restore] Order backups by date in selector [#3294](https://github.com/vatesfr/xen-orchestra/issues/3294) (PR [#3374](https://github.com/vatesfr/xen-orchestra/pull/3374))
+- [Self] Hide Tasks entry in menu for self users [#3311](https://github.com/vatesfr/xen-orchestra/issues/3311) (PR [#3373](https://github.com/vatesfr/xen-orchestra/pull/3373))
+- [Tasks] Show previous tasks [#3266](https://github.com/vatesfr/xen-orchestra/issues/3266) (PR [#3377](https://github.com/vatesfr/xen-orchestra/pull/3377))
+- [Backup NG] Add job name in names of replicated VMs (PR [#3379](https://github.com/vatesfr/xen-orchestra/pull/3379))
+- [Backup NG] Restore directories [#1924](https://github.com/vatesfr/xen-orchestra/issues/1924) (PR [#3384](https://github.com/vatesfr/xen-orchestra/pull/3384))
+- [VM] Start a VM on a specific host [#3191](https://github.com/vatesfr/xen-orchestra/issues/3191) (PR [#3389](https://github.com/vatesfr/xen-orchestra/pull/3389))
+
+### Bug fixes
+
+- [Self] Fix Self Service quotas not being correctly updated when deleting multiple VMs at a time (PR [#3368](https://github.com/vatesfr/xen-orchestra/pull/3368))
+- [Backup NG] Don't fail listing backups when a remote is broken [#3365](https://github.com/vatesfr/xen-orchestra/issues/3365) (PR [#3367](https://github.com/vatesfr/xen-orchestra/pull/3367))
+- [New XOSAN] Fix error sometimes occurring when selecting the pool (PR [#3370](https://github.com/vatesfr/xen-orchestra/pull/3370))
+- [New VM] Selecting multiple VMs and clicking Create then Cancel used to redirect to Home [#3268](https://github.com/vatesfr/xen-orchestra/issues/3268) (PR [#3371](https://github.com/vatesfr/xen-orchestra/pull/3371))
+- [Remotes] `cannot read 'properties' of undefined` error (PR [#3382](https://github.com/vatesfr/xen-orchestra/pull/3382))
+- [Servers] Various issues when adding a new server [#3385](https://github.com/vatesfr/xen-orchestra/issues/3385) (PR [#3388](https://github.com/vatesfr/xen-orchestra/pull/3388))
+- [Backup NG] Always delete the correct old replications [#3391](https://github.com/vatesfr/xen-orchestra/issues/3391) (PR [#3394](https://github.com/vatesfr/xen-orchestra/pull/3394))
+
+### Released packages
+
 - xo-server v5.26.0
 - xo-web v5.26.0
 
+## **5.25.2** (2018-08-27)
+
+### Enhancements
+
+### Bug fixes
+
+- [Remotes] Fix "undefined" mount option issue [#3361](https://github.com/vatesfr/xen-orchestra/issues/3361) (PR [#3363](https://github.com/vatesfr/xen-orchestra/pull/3363))
+- [Continuous Replication] Don't try to import/export VDIs on halted host [#3354](https://github.com/vatesfr/xen-orchestra/issues/3354) (PR [#3355](https://github.com/vatesfr/xen-orchestra/pull/3355))
+- [Disaster Recovery] Don't try to import/export VMs on halted host (PR [#3364](https://github.com/vatesfr/xen-orchestra/pull/3364))
+- [Backup NG] A successful backup job reported as Interrupted [#3018](https://github.com/vatesfr/xen-orchestra/issues/3018) (PR [#3238](https://github.com/vatesfr/xen-orchestra/pull/3238))
+
+### Released packages
+
+- xo-server v5.25.2
+- xo-web v5.25.1
+
 ## **5.25.0** (2018-08-23)
 
 ### Enhancements
@@ -36,6 +271,8 @@
 - [Remotes] Don't change `enabled` state on errors (PR [#3318](https://github.com/vatesfr/xen-orchestra/pull/3318))
 - [Remotes] Auto-reconnect on use if necessary [#2852](https://github.com/vatesfr/xen-orchestra/issues/2852) (PR [#3320](https://github.com/vatesfr/xen-orchestra/pull/3320))
 - [XO items' select] Fix adding or removing a XO item from a select make the missing XO items disappear [#3322](https://github.com/vatesfr/xen-orchestra/issues/3322) (PR [#3315](https://github.com/vatesfr/xen-orchestra/pull/3315))
+- [New VM / Self] Filter out SRs that are not in the template's pool [#3068](https://github.com/vatesfr/xen-orchestra/issues/3068) (PR [#3070](https://github.com/vatesfr/xen-orchestra/pull/3070))
+- [New VM / Self] Fix 'unknown item' displayed in SR selector [#3267](https://github.com/vatesfr/xen-orchestra/issues/3267) (PR [#3070](https://github.com/vatesfr/xen-orchestra/pull/3070))
 
 ### Released packages
 
@@ -64,8 +301,6 @@
 - [Pools] Filter GPU groups by pool [#3176](https://github.com/vatesfr/xen-orchestra/issues/3176) (PR [#3253](https://github.com/vatesfr/xen-orchestra/pull/3253))
 - [Backup NG] Fix delta backups with SMB remotes [#3224](https://github.com/vatesfr/xen-orchestra/issues/3224) (PR [#3278](https://github.com/vatesfr/xen-orchestra/pull/3278))
 - Fix VM restoration getting stuck on local SRs [#3245](https://github.com/vatesfr/xen-orchestra/issues/3245) (PR [#3243](https://github.com/vatesfr/xen-orchestra/pull/3243))
-- [New VM / Self] Filter out SRs that are not in the template's pool [#3068](https://github.com/vatesfr/xen-orchestra/issues/3068) (PR [#3070](https://github.com/vatesfr/xen-orchestra/pull/3070))
-- [New VM / Self] Fix 'unknown item' displayed in SR selector [#3267](https://github.com/vatesfr/xen-orchestra/issues/3267) (PR [#3070](https://github.com/vatesfr/xen-orchestra/pull/3070))
 
 ### Released packages
 

docs/backup_troubleshooting.md

@@ -39,6 +39,10 @@ You can check if a coalesce job is currently active by running `ps axf | grep vh
 
 If you don't see any running coalesce jobs, and can't find any other reason that XenServer has not started one, you can attempt to make it start a coalesce job by rescanning the SR. This is harmless to try, but will not always result in a coalesce. Visit the problematic SR in the XOA UI, then click the "Rescan All Disks" button towards the top right: it looks like a refresh circle icon. This should begin the coalesce process - if you click the Advanced tab in the SR view, the "disks needing to be coalesced" list should become smaller and smaller.
 
+### Parse Error
+
+This is most likely due to running a backup job that uses Delta functionality (eg: delta backups, or continuous replication) on a version of XenServer older than 6.5. To use delta functionality you must run [XenServer 6.5 or later](https://xen-orchestra.com/docs/supported-version.html).
+
 ### SR_BACKEND_FAILURE_44 (insufficient space)
 
 > This message can be triggered by any backup method.
@@ -72,4 +76,4 @@ To check your free space, enter your XOA and run `xoa check` to check free syste
 
 This is happening when you have a *smart backup job* that doesn't match any VMs. For example: you created a job to backup all running VMs. If no VMs are running on backup schedule, you'll have this message. This could also happen if you lost connection with your pool master (the VMs aren't visible anymore from Xen Orchestra).
 
-Edit your job and try to see matching VMs or check if your pool is connected to XOA.
+Edit your job and try to see matching VMs or check if your pool is connected to XOA.

docs/backups.md

@@ -29,13 +29,19 @@ You also have a filter to search anything related to these logs.
 
 > Logs are not "live" tasks. If you restart XOA during a backup, the log associated with the job will stay in orange (in progress), because it wasn't finished. It will stay forever unfinished because the job was cut in the middle.
 
+## Backups execution
+
+Each backups' job execution is identified by a `runId`. You can find this `runId` in its detailed log.
+
+![](./assets/log-runId.png)
+
 ## Consistent backup (with quiesce snapshots)
 
-All backup rely on snapshots. But what about data consistency? By default, Xen Orchestra will try to make a **quiesce snapshot** every time a snapshot is done (and fallback to normal snapshot if it's not possible).
+All backup types rely on snapshots. But what about data consistency? By default, Xen Orchestra will try to take a **quiesced snapshot** every time a snapshot is done (and fall back to normal snapshots if it's not possible).
 
-All your Windows VMs can be protected (especially MS SQL or Exchange services) after you have installed Xen Tools in your VMs. A quiesce snapshots means the operating system will be notified and the cache will be flushed to disks. This way, your backups will always be consistent.
+Snapshots of Windows VMs can be quiesced (especially MS SQL or Exchange services) after you have installed Xen Tools in your VMs. However, [there is an extra step to install the VSS provider on windows](quiesce). A quiesced snapshot means the operating system will be notified and the cache will be flushed to disks. This way, your backups will always be consistent.
 
-To see if you have quiesced snapshots for a VM, just go into its snapshot tab, the "info" icon means it is a quiesced snapshot:
+To see if you have quiesced snapshots for a VM, just go into its snapshot tab, then the "info" icon means it is a quiesced snapshot:
 
 ![](./assets/quiesced1.png)
 

docs/file_level_restore.md

@@ -1,10 +1,10 @@
 # File level restore
 
-You can also restore individual files inside a VM. It works with all your existing delta backups.
+You can also restore specific files and directories inside a VM. It works with all your existing delta backups.
 
 > You must use the latest XOA release. When you connect with the console, you should see `Build number: 16.12.20`. If you have this or higher (eg `17.*`), it means that's OK! Otherwise, please update your XOA.
 
-> Restoring individual files from an SMB remote is not yet possible, but it's planned for the future!
+> Restoring individual files from an SMB remote is not possible yet, but it's planned for the future!
 
 > File level restore **is only possible on delta backups**
 

docs/from_the_sources.md

@@ -14,13 +14,13 @@ As you may have seen,in other parts of the documentation, XO is composed of two
 
 ### NodeJS
 
-XO needs Node.js. **Please always use the LTS version of Node**.
+XO needs Node.js. **Please use Node 8**.
 
 We'll consider at this point that you've got a working node on your box. E.g:
 
 ```
 $ node -v
-v8.9.1
+v8.12.0
 ```
 
 If not, see [this page](https://nodejs.org/en/download/package-manager/) for instructions on how to install Node.

docs/troubleshooting.md

@@ -101,6 +101,13 @@ memory to xo-server itself:
 + ExecStart=/usr/local/bin/node --max-old-space-size=8192 /usr/local/bin/xo-server
 ```
 
+The last step is to refresh and restart the service:
+
+```
+$ systemctl daemon-reload
+$ systemctl restart xo-server
+```
+
 ### Behind a transparent proxy
 
 If your are behind a transparent proxy, you'll probably have issues with the updater (SSL/TLS issues).

docs/xo-cli.md

@@ -1,4 +1,3 @@
-
 # xo-cli
 
 This is another client of `xo-server` - this time in command line form.
@@ -104,5 +103,6 @@ encoding by prefixing with `json:`:
 ##### VM import
 
  ```
-> xo-cli vm.import host=60a6939e-8b0a-4352-9954-5bde44bcdf7d @=vm.xva
+> xo-cli vm.import sr=60a6939e-8b0a-4352-9954-5bde44bcdf7d @=vm.xva
 ```
+> Note: `xo-cli` only supports the import of XVA files. It will not import OVA files. To import OVA images, you must use the XOA web UI.

package.json

@@ -1,33 +1,39 @@
 {
   "devDependencies": {
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/register": "7.0.0-rc.1",
+    "@babel/core": "^7.0.0",
+    "@babel/register": "^7.0.0",
     "babel-core": "^7.0.0-0",
-    "babel-eslint": "^8.1.2",
+    "babel-eslint": "^10.0.1",
     "babel-jest": "^23.0.1",
     "benchmark": "^2.1.4",
     "eslint": "^5.1.0",
-    "eslint-config-standard": "12.0.0-alpha.0",
-    "eslint-config-standard-jsx": "^5.0.0",
+    "eslint-config-standard": "12.0.0",
+    "eslint-config-standard-jsx": "^6.0.2",
     "eslint-plugin-import": "^2.8.0",
-    "eslint-plugin-node": "^7.0.1",
-    "eslint-plugin-promise": "^3.6.0",
+    "eslint-plugin-node": "^8.0.0",
+    "eslint-plugin-promise": "^4.0.0",
     "eslint-plugin-react": "^7.6.1",
-    "eslint-plugin-standard": "^3.0.1",
+    "eslint-plugin-standard": "^4.0.0",
     "exec-promise": "^0.7.0",
-    "flow-bin": "^0.78.0",
+    "flow-bin": "^0.85.0",
     "globby": "^8.0.0",
-    "husky": "^0.14.3",
+    "husky": "^1.0.0-rc.15",
     "jest": "^23.0.1",
     "lodash": "^4.17.4",
     "prettier": "^1.10.2",
-    "promise-toolbox": "^0.9.5",
+    "promise-toolbox": "^0.11.0",
     "sorted-object": "^2.0.1"
   },
   "engines": {
     "yarn": "^1.7.0"
   },
+  "husky": {
+    "hooks": {
+      "pre-commit": "scripts/lint-staged"
+    }
+  },
   "jest": {
+    "timers": "fake",
     "collectCoverage": true,
     "projects": [
       "<rootDir>"
@@ -49,11 +55,11 @@
     "dev": "scripts/run-script --parallel dev",
     "dev-test": "jest --bail --watch \"^(?!.*\\.integ\\.spec\\.js$)\"",
     "posttest": "scripts/run-script test",
-    "precommit": "scripts/lint-staged",
     "prepare": "scripts/run-script prepare",
     "pretest": "eslint --ignore-path .gitignore .",
     "test": "jest \"^(?!.*\\.integ\\.spec\\.js$)\"",
-    "test-integration": "jest \".integ\\.spec\\.js$\""
+    "test-integration": "jest \".integ\\.spec\\.js$\"",
+    "travis-tests": "scripts/travis-tests"
   },
   "workspaces": [
     "@xen-orchestra/*",

packages/complex-matcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "complex-matcher",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "ISC",
   "description": "",
   "keywords": [],
@@ -30,9 +30,9 @@
     "lodash": "^4.17.4"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
     "babel-plugin-lodash": "^3.3.2",
     "cross-env": "^5.1.1",
     "rimraf": "^2.6.2"

packages/complex-matcher/src/index.fixtures.js

@@ -11,7 +11,7 @@ export const ast = new CM.And([
     new CM.Or([new CM.String('wonderwoman'), new CM.String('batman')])
   ),
   new CM.TruthyProperty('hasCape'),
-  new CM.Property('age', new CM.Number(32)),
+  new CM.Property('age', new CM.NumberOrStringNode('32')),
   new CM.GlobPattern('chi*go'),
   new CM.RegExp('^foo/bar\\.', 'i'),
 ])

packages/complex-matcher/src/index.js

@@ -153,6 +153,34 @@ export class NumberNode extends Node {
 }
 export { NumberNode as Number }
 
+export class NumberOrStringNode extends Node {
+  constructor (value) {
+    super()
+
+    this.value = value
+
+    // should not be enumerable for the tests
+    Object.defineProperty(this, 'match', {
+      value: this.match.bind(this, value.toLowerCase(), +value),
+    })
+  }
+
+  match (lcValue, numValue, value) {
+    return (
+      value === numValue ||
+      (typeof value === 'string'
+        ? value.toLowerCase().indexOf(lcValue) !== -1
+        : (Array.isArray(value) || isPlainObject(value)) &&
+          some(value, this.match))
+    )
+  }
+
+  toString () {
+    return this.value
+  }
+}
+export { NumberOrStringNode as NumberOrString }
+
 export class Property extends Node {
   constructor (name, child) {
     super()
@@ -382,11 +410,10 @@ class P {
 
   static text (text) {
     const { length } = text
-    return new P(
-      (input, pos) =>
-        input.startsWith(text, pos)
-          ? new Success(pos + length, text)
-          : new Failure(pos, `'${text}'`)
+    return new P((input, pos) =>
+      input.startsWith(text, pos)
+        ? new Success(pos + length, text)
+        : new Failure(pos, `'${text}'`)
     )
   }
 
@@ -450,17 +477,16 @@ class P {
   }
 }
 
-P.eof = new P(
-  (input, pos, end) =>
-    pos < end ? new Failure(pos, 'end of input') : new Success(pos)
+P.eof = new P((input, pos, end) =>
+  pos < end ? new Failure(pos, 'end of input') : new Success(pos)
 )
 
 // -------------------------------------------------------------------
 
 const parser = P.grammar({
   default: r =>
-    P.seq(r.ws, r.term.repeat(), P.eof).map(
-      ([, terms]) => (terms.length === 0 ? new Null() : new And(terms))
+    P.seq(r.ws, r.term.repeat(), P.eof).map(([, terms]) =>
+      terms.length === 0 ? new Null() : new And(terms)
     ),
   globPattern: new P((input, pos, end) => {
     let value = ''
@@ -564,7 +590,7 @@ const parser = P.grammar({
         const asNum = +str
         return Number.isNaN(asNum)
           ? new GlobPattern(str)
-          : new NumberNode(asNum)
+          : new NumberOrStringNode(str)
       })
     ),
   ws: P.regex(/\s*/),

packages/complex-matcher/src/index.spec.js

@@ -6,6 +6,7 @@ import {
   GlobPattern,
   Null,
   NumberNode,
+  NumberOrStringNode,
   parse,
   setPropertyClause,
 } from './'
@@ -32,7 +33,7 @@ describe('parse', () => {
 
     node = parse('32')
     expect(node.match(32)).toBe(true)
-    expect(node.match('32')).toBe(false)
+    expect(node.match('32')).toBe(true)
     expect(node.toString()).toBe('32')
 
     node = parse('"32"')
@@ -54,6 +55,12 @@ describe('Number', () => {
   })
 })
 
+describe('NumberOrStringNode', () => {
+  it('match a string', () => {
+    expect(new NumberOrStringNode('123').match([{ foo: '123' }])).toBe(true)
+  })
+})
+
 describe('setPropertyClause', () => {
   it('creates a node if none passed', () => {
     expect(setPropertyClause(undefined, 'foo', 'bar').toString()).toBe(

packages/value-matcher/package.json

@@ -28,10 +28,10 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
-    "@babel/preset-flow": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
     "cross-env": "^5.1.3",
     "rimraf": "^2.6.2"
   },

packages/vhd-cli/package.json

@@ -26,22 +26,21 @@
     "node": ">=6"
   },
   "dependencies": {
-    "@xen-orchestra/fs": "^0.3.0",
+    "@xen-orchestra/fs": "^0.4.1",
     "cli-progress": "^2.0.0",
     "exec-promise": "^0.7.0",
     "struct-fu": "^1.2.0",
-    "vhd-lib": "^0.3.0"
+    "vhd-lib": "^0.4.0"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/plugin-transform-runtime": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
     "babel-plugin-lodash": "^3.3.2",
     "cross-env": "^5.1.3",
-    "execa": "^0.10.0",
+    "execa": "^1.0.0",
     "index-modules": "^0.3.0",
-    "promise-toolbox": "^0.9.5",
+    "promise-toolbox": "^0.11.0",
     "rimraf": "^2.6.1",
     "tmp": "^0.0.33"
   },

packages/vhd-cli/src/commands/synthetize.js

@@ -9,13 +9,12 @@ export default async function main (args) {
   }
 
   const handler = getHandler({ url: 'file:///' })
+  const stream = await createSyntheticStream(handler, path.resolve(args[0]))
   return new Promise((resolve, reject) => {
-    createSyntheticStream(handler, path.resolve(args[0]))
-      .on('error', reject)
-      .pipe(
-        createWriteStream(args[1])
-          .on('error', reject)
-          .on('finish', resolve)
-      )
+    stream.on('error', reject).pipe(
+      createWriteStream(args[1])
+        .on('error', reject)
+        .on('finish', resolve)
+    )
   })
 }

packages/vhd-cli/src/info.integ.spec.js

@@ -3,7 +3,7 @@
 import execa from 'execa'
 import rimraf from 'rimraf'
 import tmp from 'tmp'
-import { fromCallback as pFromCallback } from 'promise-toolbox'
+import { pFromCallback } from 'promise-toolbox'
 
 import command from './commands/info'
 

packages/vhd-lib/merge.integ.spec.js

@@ -5,15 +5,13 @@ import fs from 'fs-extra'
 import getStream from 'get-stream'
 import rimraf from 'rimraf'
 import tmp from 'tmp'
+import { fromEvent, pFromCallback } from 'promise-toolbox'
 import { getHandler } from '@xen-orchestra/fs'
 import { randomBytes } from 'crypto'
-import { fromEvent, fromCallback as pFromCallback } from 'promise-toolbox'
 
-import chainVhd from './chain'
-import createReadStream from './createSyntheticStream'
-import Vhd from './vhd'
-import vhdMerge from './merge'
-import { SECTOR_SIZE } from './_constants'
+import Vhd, { chainVhd, createSyntheticStream, mergeVhd as vhdMerge } from './'
+
+import { SECTOR_SIZE } from './src/_constants'
 
 const initialDir = process.cwd()
 
@@ -270,14 +268,18 @@ test('coalesce works in normal cases', async () => {
 
 test('createSyntheticStream passes vhd-util check', async () => {
   const initalSize = 4
+  const expectedVhdSize = 4197888
   await createRandomFile('randomfile', initalSize)
   await convertFromRawToVhd('randomfile', 'randomfile.vhd')
   const handler = getHandler({ url: 'file://' + process.cwd() })
-  const stream = createReadStream(handler, 'randomfile.vhd')
+  const stream = await createSyntheticStream(handler, 'randomfile.vhd')
+  expect(stream.length).toEqual(expectedVhdSize)
   await fromEvent(
     stream.pipe(await fs.createWriteStream('recovered.vhd')),
     'finish'
   )
   await checkFile('recovered.vhd')
+  const stats = await fs.stat('recovered.vhd')
+  expect(stats.size).toEqual(expectedVhdSize)
   await execa('qemu-img', ['compare', 'recovered.vhd', 'randomfile'])
 })

packages/vhd-lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vhd-lib",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "AGPL-3.0",
   "description": "Primitives for VHD file handling",
   "keywords": [],
@@ -20,25 +20,24 @@
     "node": ">=6"
   },
   "dependencies": {
-    "@babel/runtime": "7.0.0-rc.1",
     "async-iterator-to-stream": "^1.0.2",
+    "core-js": "3.0.0-beta.3",
     "from2": "^2.3.0",
     "fs-extra": "^7.0.0",
     "limit-concurrency-decorator": "^0.4.0",
-    "promise-toolbox": "^0.9.5",
+    "promise-toolbox": "^0.11.0",
     "struct-fu": "^1.2.0",
     "uuid": "^3.0.1"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/plugin-transform-runtime": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
-    "@babel/preset-flow": "7.0.0-rc.1",
-    "@xen-orchestra/fs": "^0.3.0",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
+    "@xen-orchestra/fs": "^0.4.1",
     "babel-plugin-lodash": "^3.3.2",
     "cross-env": "^5.1.3",
-    "execa": "^0.10.0",
+    "execa": "^1.0.0",
     "fs-promise": "^2.0.0",
     "get-stream": "^4.0.0",
     "index-modules": "^0.3.0",

packages/vhd-lib/src/_computeGeometryForSize.js

@@ -1,13 +1,10 @@
 import { SECTOR_SIZE } from './_constants'
 
 export default function computeGeometryForSize (size) {
-  const totalSectors = Math.ceil(size / 512)
+  const totalSectors = Math.min(Math.ceil(size / 512), 65535 * 16 * 255)
   let sectorsPerTrackCylinder
   let heads
   let cylinderTimesHeads
-  if (totalSectors > 65535 * 16 * 255) {
-    throw Error('disk is too big')
-  }
   // straight copypasta from the file spec appendix on CHS Calculation
   if (totalSectors >= 65535 * 16 * 63) {
     sectorsPerTrackCylinder = 255

packages/vhd-lib/src/createReadableSparseStream.js

@@ -17,7 +17,7 @@ import { set as setBitmap } from './_bitmap'
 const VHD_BLOCK_SIZE_SECTORS = VHD_BLOCK_SIZE_BYTES / SECTOR_SIZE
 
 /**
- * @returns {Array} an array of occupation bitmap, each bit mapping an input block size of bytes
+ * @returns currentVhdPositionSector the first free sector after the data
  */
 function createBAT (
   firstBlockPosition,
@@ -36,9 +36,10 @@ function createBAT (
         (bitmapSize + VHD_BLOCK_SIZE_BYTES) / SECTOR_SIZE
     }
   })
+  return currentVhdPositionSector
 }
 
-export default asyncIteratorToStream(async function * (
+export default async function createReadableStream (
   diskSize,
   incomingBlockSize,
   blockAddressList,
@@ -79,7 +80,14 @@ export default asyncIteratorToStream(async function * (
   const bitmapSize =
     Math.ceil(VHD_BLOCK_SIZE_SECTORS / 8 / SECTOR_SIZE) * SECTOR_SIZE
   const bat = Buffer.alloc(tablePhysicalSizeBytes, 0xff)
-  createBAT(firstBlockPosition, blockAddressList, ratio, bat, bitmapSize)
+  const endOfData = createBAT(
+    firstBlockPosition,
+    blockAddressList,
+    ratio,
+    bat,
+    bitmapSize
+  )
+  const fileSize = endOfData * SECTOR_SIZE + FOOTER_SIZE
   let position = 0
   function * yieldAndTrack (buffer, expectedPosition) {
     if (expectedPosition !== undefined) {
@@ -120,9 +128,16 @@ export default asyncIteratorToStream(async function * (
     }
     yield * yieldAndTrack(currentBlockWithBitmap)
   }
-  yield * yieldAndTrack(footer, 0)
-  yield * yieldAndTrack(header, FOOTER_SIZE)
-  yield * yieldAndTrack(bat, FOOTER_SIZE + HEADER_SIZE)
-  yield * generateFileContent(blockIterator, bitmapSize, ratio)
-  yield * yieldAndTrack(footer)
-})
+
+  async function * iterator () {
+    yield * yieldAndTrack(footer, 0)
+    yield * yieldAndTrack(header, FOOTER_SIZE)
+    yield * yieldAndTrack(bat, FOOTER_SIZE + HEADER_SIZE)
+    yield * generateFileContent(blockIterator, bitmapSize, ratio)
+    yield * yieldAndTrack(footer)
+  }
+
+  const stream = asyncIteratorToStream(iterator())
+  stream.length = fileSize
+  return stream
+}

packages/vhd-lib/src/createSyntheticStream.js

@@ -15,18 +15,24 @@ import { test as mapTestBit } from './_bitmap'
 const resolveRelativeFromFile = (file, path) =>
   resolve('/', dirname(file), path).slice(1)
 
-export default asyncIteratorToStream(function * (handler, path) {
+export default async function createSyntheticStream (handler, path) {
   const fds = []
-
+  const cleanup = () => {
+    for (let i = 0, n = fds.length; i < n; ++i) {
+      handler.closeFile(fds[i]).catch(error => {
+        console.warn('createReadStream, closeFd', i, error)
+      })
+    }
+  }
   try {
     const vhds = []
     while (true) {
-      const fd = yield handler.openFile(path, 'r')
+      const fd = await handler.openFile(path, 'r')
       fds.push(fd)
       const vhd = new Vhd(handler, fd)
       vhds.push(vhd)
-      yield vhd.readHeaderAndFooter()
-      yield vhd.readBlockAllocationTable()
+      await vhd.readHeaderAndFooter()
+      await vhd.readBlockAllocationTable()
 
       if (vhd.footer.diskType === DISK_TYPE_DYNAMIC) {
         break
@@ -64,14 +70,8 @@ export default asyncIteratorToStream(function * (handler, path) {
     const nBlocks = Math.ceil(footer.currentSize / header.blockSize)
 
     const blocksOwner = new Array(nBlocks)
-    for (
-      let iBlock = 0,
-        blockOffset = Math.ceil(
-          (header.tableOffset + bat.length) / SECTOR_SIZE
-        );
-      iBlock < nBlocks;
-      ++iBlock
-    ) {
+    let blockOffset = Math.ceil((header.tableOffset + bat.length) / SECTOR_SIZE)
+    for (let iBlock = 0; iBlock < nBlocks; ++iBlock) {
       let blockSector = BLOCK_UNUSED
       for (let i = 0; i < nVhds; ++i) {
         if (vhds[i].containsBlock(iBlock)) {
@@ -83,71 +83,78 @@ export default asyncIteratorToStream(function * (handler, path) {
       }
       bat.writeUInt32BE(blockSector, iBlock * 4)
     }
+    const fileSize = blockOffset * SECTOR_SIZE + FOOTER_SIZE
 
-    footer = fuFooter.pack(footer)
-    checksumStruct(footer, fuFooter)
-    yield footer
+    const iterator = function * () {
+      try {
+        footer = fuFooter.pack(footer)
+        checksumStruct(footer, fuFooter)
+        yield footer
 
-    header = fuHeader.pack(header)
-    checksumStruct(header, fuHeader)
-    yield header
+        header = fuHeader.pack(header)
+        checksumStruct(header, fuHeader)
+        yield header
 
-    yield bat
+        yield bat
 
-    // TODO: for generic usage the bitmap needs to be properly computed for each block
-    const bitmap = Buffer.alloc(vhd.bitmapSize, 0xff)
-    for (let iBlock = 0; iBlock < nBlocks; ++iBlock) {
-      const owner = blocksOwner[iBlock]
-      if (owner === undefined) {
-        continue
-      }
-
-      yield bitmap
-
-      const blocksByVhd = new Map()
-      const emitBlockSectors = function * (iVhd, i, n) {
-        const vhd = vhds[iVhd]
-        const isRootVhd = vhd === rootVhd
-        if (!vhd.containsBlock(iBlock)) {
-          if (isRootVhd) {
-            yield Buffer.alloc((n - i) * SECTOR_SIZE)
-          } else {
-            yield * emitBlockSectors(iVhd + 1, i, n)
+        // TODO: for generic usage the bitmap needs to be properly computed for each block
+        const bitmap = Buffer.alloc(vhd.bitmapSize, 0xff)
+        for (let iBlock = 0; iBlock < nBlocks; ++iBlock) {
+          const owner = blocksOwner[iBlock]
+          if (owner === undefined) {
+            continue
           }
-          return
-        }
-        let block = blocksByVhd.get(vhd)
-        if (block === undefined) {
-          block = yield vhd._readBlock(iBlock)
-          blocksByVhd.set(vhd, block)
-        }
-        const { bitmap, data } = block
-        if (isRootVhd) {
-          yield data.slice(i * SECTOR_SIZE, n * SECTOR_SIZE)
-          return
-        }
-        while (i < n) {
-          const hasData = mapTestBit(bitmap, i)
-          const start = i
-          do {
-            ++i
-          } while (i < n && mapTestBit(bitmap, i) === hasData)
-          if (hasData) {
-            yield data.slice(start * SECTOR_SIZE, i * SECTOR_SIZE)
-          } else {
-            yield * emitBlockSectors(iVhd + 1, start, i)
+
+          yield bitmap
+
+          const blocksByVhd = new Map()
+          const emitBlockSectors = function * (iVhd, i, n) {
+            const vhd = vhds[iVhd]
+            const isRootVhd = vhd === rootVhd
+            if (!vhd.containsBlock(iBlock)) {
+              if (isRootVhd) {
+                yield Buffer.alloc((n - i) * SECTOR_SIZE)
+              } else {
+                yield * emitBlockSectors(iVhd + 1, i, n)
+              }
+              return
+            }
+            let block = blocksByVhd.get(vhd)
+            if (block === undefined) {
+              block = yield vhd._readBlock(iBlock)
+              blocksByVhd.set(vhd, block)
+            }
+            const { bitmap, data } = block
+            if (isRootVhd) {
+              yield data.slice(i * SECTOR_SIZE, n * SECTOR_SIZE)
+              return
+            }
+            while (i < n) {
+              const hasData = mapTestBit(bitmap, i)
+              const start = i
+              do {
+                ++i
+              } while (i < n && mapTestBit(bitmap, i) === hasData)
+              if (hasData) {
+                yield data.slice(start * SECTOR_SIZE, i * SECTOR_SIZE)
+              } else {
+                yield * emitBlockSectors(iVhd + 1, start, i)
+              }
+            }
           }
+          yield * emitBlockSectors(owner, 0, sectorsPerBlockData)
         }
+        yield footer
+      } finally {
+        cleanup()
       }
-      yield * emitBlockSectors(owner, 0, sectorsPerBlockData)
     }
 
-    yield footer
-  } finally {
-    for (let i = 0, n = fds.length; i < n; ++i) {
-      handler.closeFile(fds[i]).catch(error => {
-        console.warn('createReadStream, closeFd', i, error)
-      })
-    }
+    const stream = asyncIteratorToStream(iterator())
+    stream.length = fileSize
+    return stream
+  } catch (e) {
+    cleanup()
+    throw e
   }
-})
+}

packages/vhd-lib/src/index.js

@@ -1,3 +1,6 @@
+// see https://github.com/babel/babel/issues/8450
+import 'core-js/features/symbol/async-iterator'
+
 export { default } from './vhd'
 export { default as chainVhd } from './chain'
 export { default as createContentStream } from './createContentStream'

packages/vhd-lib/src/vhd.js

@@ -228,16 +228,15 @@ export default class Vhd {
     return this._read(
       sectorsToBytes(blockAddr),
       onlyBitmap ? this.bitmapSize : this.fullBlockSize
-    ).then(
-      buf =>
-        onlyBitmap
-          ? { id: blockId, bitmap: buf }
-          : {
-              id: blockId,
-              bitmap: buf.slice(0, this.bitmapSize),
-              data: buf.slice(this.bitmapSize),
-              buffer: buf,
-            }
+    ).then(buf =>
+      onlyBitmap
+        ? { id: blockId, bitmap: buf }
+        : {
+            id: blockId,
+            bitmap: buf.slice(0, this.bitmapSize),
+            data: buf.slice(this.bitmapSize),
+            buffer: buf,
+          }
     )
   }
 

packages/vhd-lib/vhd.integ.spec.js

@@ -3,11 +3,11 @@ import execa from 'execa'
 import rimraf from 'rimraf'
 import tmp from 'tmp'
 import { createWriteStream, readFile } from 'fs-promise'
-import { fromCallback as pFromCallback, fromEvent } from 'promise-toolbox'
+import { fromEvent, pFromCallback } from 'promise-toolbox'
 
-import { createFooter } from './_createFooterHeader'
-import createReadableRawVHDStream from './createReadableRawStream'
-import createReadableSparseVHDStream from './createReadableSparseStream'
+import { createReadableRawStream, createReadableSparseStream } from './'
+
+import { createFooter } from './src/_createFooterHeader'
 
 const initialDir = process.cwd()
 
@@ -54,7 +54,7 @@ test('ReadableRawVHDStream does not crash', async () => {
     },
   }
   const fileSize = 1000
-  const stream = createReadableRawVHDStream(fileSize, mockParser)
+  const stream = createReadableRawStream(fileSize, mockParser)
   const pipe = stream.pipe(createWriteStream('output.vhd'))
   await fromEvent(pipe, 'finish')
   await execa('vhd-util', ['check', '-t', '-i', '-n', 'output.vhd'])
@@ -85,7 +85,7 @@ test('ReadableRawVHDStream detects when blocks are out of order', async () => {
   }
   return expect(
     new Promise((resolve, reject) => {
-      const stream = createReadableRawVHDStream(100000, mockParser)
+      const stream = createReadableRawStream(100000, mockParser)
       stream.on('error', reject)
       const pipe = stream.pipe(createWriteStream('outputStream'))
       pipe.on('finish', resolve)
@@ -107,12 +107,13 @@ test('ReadableSparseVHDStream can handle a sparse file', async () => {
     },
   ]
   const fileSize = blockSize * 110
-  const stream = createReadableSparseVHDStream(
+  const stream = await createReadableSparseStream(
     fileSize,
     blockSize,
     blocks.map(b => b.offsetBytes),
     blocks
   )
+  expect(stream.length).toEqual(4197888)
   const pipe = stream.pipe(createWriteStream('output.vhd'))
   await fromEvent(pipe, 'finish')
   await execa('vhd-util', ['check', '-t', '-i', '-n', 'output.vhd'])

packages/xapi-explore-sr/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

packages/xapi-explore-sr/.npmignore

@@ -0,0 +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/xapi-explore-sr/README.md

@@ -0,0 +1,52 @@
+# xapi-explore-sr [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
+
+> Display the list of VDIs (unmanaged and snapshots included) of a SR
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/xapi-explore-sr):
+
+```
+> npm install --global xapi-explore-sr
+```
+
+## Usage
+
+```
+> xapi-explore-sr
+Usage: xapi-explore-sr [--full] <SR UUID> <XenServer URL> <XenServer user> [<XenServer password>]
+```
+
+## Development
+
+```
+# Install dependencies
+> npm install
+
+# Run the tests
+> npm test
+
+# Continuously compile
+> npm run dev
+
+# Continuously run the tests
+> npm run dev-test
+
+# Build for production (automatically called by npm install)
+> npm run build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Vates SAS](https://vates.fr)

packages/xapi-explore-sr/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "xapi-explore-sr",
+  "version": "0.2.1",
+  "license": "ISC",
+  "description": "Display the list of VDIs (unmanaged and snapshots included) of a SR",
+  "keywords": [
+    "api",
+    "sr",
+    "vdi",
+    "vdis",
+    "xen",
+    "xen-api",
+    "xenapi"
+  ],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/packages/xapi-explore-sr",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net"
+  },
+  "preferGlobal": true,
+  "main": "dist/",
+  "bin": {
+    "xapi-explore-sr": "dist/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=8"
+  },
+  "dependencies": {
+    "archy": "^1.0.0",
+    "chalk": "^2.3.2",
+    "exec-promise": "^0.7.0",
+    "human-format": "^0.10.0",
+    "lodash": "^4.17.4",
+    "pw": "^0.0.4",
+    "xen-api": "^0.21.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.1.5",
+    "@babel/core": "^7.1.5",
+    "@babel/preset-env": "^7.1.5",
+    "babel-plugin-lodash": "^3.2.11",
+    "cross-env": "^5.1.4",
+    "rimraf": "^2.6.1"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "prebuild": "rimraf dist/",
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
+  }
+}

packages/xapi-explore-sr/src/index.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+import archy from 'archy'
+import chalk from 'chalk'
+import execPromise from 'exec-promise'
+import humanFormat from 'human-format'
+import pw from 'pw'
+import { createClient } from 'xen-api'
+import { forEach, map, orderBy } from 'lodash'
+
+// ===================================================================
+
+const askPassword = prompt =>
+  new Promise(resolve => {
+    prompt && process.stderr.write(`${prompt}: `)
+    pw(resolve)
+  })
+
+const formatSize = bytes =>
+  humanFormat(bytes, {
+    prefix: 'Gi',
+    scale: 'binary',
+  })
+
+const required = name => {
+  const e = `missing required argument <${name}>`
+  throw e
+}
+
+// -------------------------------------------------------------------
+
+const STYLES = [
+  [
+    vdi => !vdi.managed,
+    chalk.enabled ? chalk.red : label => `[unmanaged] ${label}`,
+  ],
+  [
+    vdi => vdi.is_a_snapshot,
+    chalk.enabled ? chalk.yellow : label => `[snapshot] ${label}`,
+  ],
+]
+const getStyle = vdi => {
+  for (let i = 0, n = STYLES.length; i < n; ++i) {
+    const entry = STYLES[i]
+    if (entry[0](vdi)) {
+      return entry[1]
+    }
+  }
+}
+
+const mapFilter = (collection, iteratee, results = []) => {
+  forEach(collection, function () {
+    const result = iteratee.apply(this, arguments)
+    if (result !== undefined) {
+      results.push(result)
+    }
+  })
+  return results
+}
+
+// -------------------------------------------------------------------
+
+execPromise(async args => {
+  if (args.length === 0 || args[0] === '-h' || args[0] === '--help') {
+    return `Usage: xapi-explore-sr [--full] <SR UUID> <XenServer URL> <XenServer user> [<XenServer password>]`
+  }
+
+  const full = args[0] === '--full'
+  if (full) {
+    args.shift()
+  }
+
+  const [
+    srUuid = required('SR UUID'),
+    url = required('XenServer URL'),
+    user = required('XenServer user'),
+    password = await askPassword('XenServer password'),
+  ] = args
+
+  const xapi = createClient({
+    allowUnauthorized: true,
+    auth: { user, password },
+    readOnly: true,
+    url,
+    watchEvents: false,
+  })
+  await xapi.connect()
+
+  const srRef = await xapi.call('SR.get_by_uuid', srUuid)
+  const sr = await xapi.call('SR.get_record', srRef)
+
+  const vdisByRef = {}
+  await Promise.all(
+    map(sr.VDIs, async ref => {
+      const vdi = await xapi.call('VDI.get_record', ref)
+      vdisByRef[ref] = vdi
+    })
+  )
+
+  const hasParents = {}
+  const vhdChildrenByUuid = {}
+  forEach(vdisByRef, vdi => {
+    const vhdParent = vdi.sm_config['vhd-parent']
+    if (vhdParent) {
+      ;(
+        vhdChildrenByUuid[vhdParent] || (vhdChildrenByUuid[vhdParent] = [])
+      ).push(vdi)
+    } else if (!(vdi.snapshot_of in vdisByRef)) {
+      return
+    }
+
+    hasParents[vdi.uuid] = true
+  })
+
+  const makeVdiNode = vdi => {
+    const { uuid } = vdi
+
+    let label = `${vdi.name_label} - ${uuid} - ${formatSize(
+      +vdi.physical_utilisation
+    )}`
+    const nodes = []
+
+    const vhdChildren = vhdChildrenByUuid[uuid]
+    if (vhdChildren) {
+      mapFilter(
+        orderBy(vhdChildren, 'is_a_snapshot', 'desc'),
+        makeVdiNode,
+        nodes
+      )
+    }
+
+    mapFilter(
+      vdi.snapshots,
+      ref => {
+        const vdi = vdisByRef[ref]
+        if (full || !vdi.sm_config['vhd-parent']) {
+          return makeVdiNode(vdi)
+        }
+      },
+      nodes
+    )
+
+    const style = getStyle(vdi)
+    if (style) {
+      label = style(label)
+    }
+
+    return { label, nodes }
+  }
+
+  const nodes = mapFilter(orderBy(vdisByRef, ['name_label', 'uuid']), vdi => {
+    if (!hasParents[vdi.uuid]) {
+      return makeVdiNode(vdi)
+    }
+  })
+
+  return archy({
+    label: `${sr.name_label} (${sr.VDIs.length} VDIs)`,
+    nodes,
+  })
+})

packages/xen-api/README.md

@@ -4,6 +4,9 @@
 
 Tested with:
 
+- XenServer 7.6
+- XenServer 7.5
+- XenServer 7.4
 - XenServer 7.3
 - XenServer 7.2
 - XenServer 7.1

packages/xen-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xen-api",
-  "version": "0.18.0",
+  "version": "0.21.0",
   "license": "ISC",
   "description": "Connector to the Xen API",
   "keywords": [
@@ -33,28 +33,28 @@
   },
   "dependencies": {
     "blocked": "^1.2.1",
-    "debug": "^3.1.0",
+    "debug": "^4.0.1",
     "event-to-promise": "^0.8.0",
     "exec-promise": "^0.7.0",
-    "http-request-plus": "^0.5.0",
+    "http-request-plus": "^0.6.0",
     "iterable-backoff": "^0.0.0",
     "jest-diff": "^23.5.0",
-    "json-rpc-protocol": "^0.12.0",
+    "json-rpc-protocol": "^0.13.1",
     "kindof": "^2.0.0",
     "lodash": "^4.17.4",
     "make-error": "^1.3.0",
     "minimist": "^1.2.0",
     "ms": "^2.1.1",
-    "promise-toolbox": "^0.9.5",
+    "promise-toolbox": "^0.11.0",
     "pw": "0.0.4",
     "xmlrpc": "^1.3.2",
     "xo-collection": "^0.4.1"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/plugin-proposal-decorators": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-proposal-decorators": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
     "babel-plugin-lodash": "^3.3.2",
     "cross-env": "^5.1.3",
     "rimraf": "^2.6.1"

packages/xen-api/src/_replaceSensitiveValues.js

@@ -0,0 +1,17 @@
+import mapValues from 'lodash/mapValues'
+
+export default function replaceSensitiveValues (value, replacement) {
+  function helper (value, name) {
+    if (name === 'password' && typeof value === 'string') {
+      return replacement
+    }
+
+    if (typeof value !== 'object' || value === null) {
+      return value
+    }
+
+    return Array.isArray(value) ? value.map(helper) : mapValues(value, helper)
+  }
+
+  return helper(value)
+}

packages/xen-api/src/index.js

@@ -11,7 +11,6 @@ import {
   forEach,
   isArray,
   isInteger,
-  isObject,
   map,
   noop,
   omit,
@@ -21,16 +20,17 @@ import {
 import {
   Cancel,
   cancelable,
-  catchPlus as pCatch,
   defer,
-  delay as pDelay,
   fromEvents,
-  lastly,
-  timeout as pTimeout,
+  pCatch,
+  pDelay,
+  pFinally,
+  pTimeout,
   TimeoutError,
 } from 'promise-toolbox'
 
 import autoTransport from './transports/auto'
+import replaceSensitiveValues from './_replaceSensitiveValues'
 
 const debug = createDebug('xen-api')
 
@@ -94,7 +94,7 @@ class XapiError extends BaseError {
     this.params = params
 
     // slots than can be assigned later
-    this.method = undefined
+    this.call = undefined
     this.url = undefined
     this.task = undefined
   }
@@ -137,8 +137,8 @@ const parseUrl = url => {
 const {
   create: createObject,
   defineProperties,
-  defineProperty,
   freeze: freezeObject,
+  keys: getKeys,
 } = Object
 
 // -------------------------------------------------------------------
@@ -190,10 +190,6 @@ const getKey = o => o.$id
 
 // -------------------------------------------------------------------
 
-const EMPTY_ARRAY = freezeObject([])
-
-// -------------------------------------------------------------------
-
 const getTaskResult = task => {
   const { status } = task
   if (status === 'cancelled') {
@@ -215,6 +211,15 @@ const getTaskResult = task => {
 
 // -------------------------------------------------------------------
 
+const RESERVED_FIELDS = {
+  id: true,
+  pool: true,
+  ref: true,
+  type: true,
+}
+
+// -------------------------------------------------------------------
+
 const CONNECTED = 'connected'
 const CONNECTING = 'connecting'
 const DISCONNECTED = 'disconnected'
@@ -229,6 +234,7 @@ export class Xapi extends EventEmitter {
     this._auth = opts.auth
     this._pool = null
     this._readOnly = Boolean(opts.readOnly)
+    this._RecordsByType = createObject(null)
     this._sessionId = null
     const url = (this._url = parseUrl(opts.url))
 
@@ -259,8 +265,8 @@ export class Xapi extends EventEmitter {
       const objects = (this._objects = new Collection())
       objects.getKey = getKey
 
-      this._objectsByRefs = createObject(null)
-      this._objectsByRefs[NULL_REF] = undefined
+      this._objectsByRef = createObject(null)
+      this._objectsByRef[NULL_REF] = undefined
 
       this._taskWatchers = Object.create(null)
 
@@ -428,7 +434,7 @@ export class Xapi extends EventEmitter {
             this._sessionCall('task.cancel', [taskRef]).catch(noop)
           })
 
-          return lastly.call(this.watchTask(taskRef), () => {
+          return pFinally.call(this.watchTask(taskRef), () => {
             this._sessionCall('task.destroy', [taskRef]).catch(noop)
           })
         })
@@ -462,7 +468,7 @@ export class Xapi extends EventEmitter {
     }
 
     const object =
-      this._objects.all[idOrUuidOrRef] || this._objectsByRefs[idOrUuidOrRef]
+      this._objects.all[idOrUuidOrRef] || this._objectsByRef[idOrUuidOrRef]
 
     if (object !== undefined) return object
 
@@ -474,7 +480,7 @@ export class Xapi extends EventEmitter {
   // Returns the object for a given opaque reference (internal to
   // XAPI).
   getObjectByRef (ref, defaultValue) {
-    const object = this._objectsByRefs[ref]
+    const object = this._objectsByRef[ref]
 
     if (object !== undefined) return object
 
@@ -497,16 +503,9 @@ export class Xapi extends EventEmitter {
   }
 
   async getRecord (type, ref) {
-    const record = await this._sessionCall(`${type}.get_record`, [ref])
-
-    // All custom properties are read-only and non enumerable.
-    defineProperties(record, {
-      $id: { value: record.uuid || ref },
-      $ref: { value: ref },
-      $type: { value: type },
-    })
-
-    return record
+    return this._wrapRecord(
+      await this._sessionCall(`${type}.get_record`, [ref])
+    )
   }
 
   async getRecordByUuid (type, uuid) {
@@ -669,7 +668,7 @@ export class Xapi extends EventEmitter {
 
   setFieldEntries (record, field, entries) {
     return Promise.all(
-      Object.keys(entries).map(entry => {
+      getKeys(entries).map(entry => {
         const value = entries[entry]
         if (value !== undefined) {
           return value === null
@@ -710,7 +709,7 @@ export class Xapi extends EventEmitter {
     let watcher = watchers[ref]
     if (watcher === undefined) {
       // sync check if the task is already settled
-      const task = this._objectsByRefs[ref]
+      const task = this._objectsByRef[ref]
       if (task !== undefined) {
         const result = getTaskResult(task)
         if (result !== undefined) {
@@ -775,78 +774,29 @@ export class Xapi extends EventEmitter {
   }
 
   _addObject (type, ref, object) {
-    const { _objectsByRefs: objectsByRefs } = this
-
-    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],
-        })
-      }
-    })
-
-    // 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 = this._wrapRecord(type, ref, object)
 
     // Finally freezes the object.
     freezeObject(object)
 
     const objects = this._objects
+    const objectsByRef = this._objectsByRef
 
     // An object's UUID can change during its life.
-    const prev = objectsByRefs[ref]
+    const prev = objectsByRef[ref]
     let prevUuid
     if (prev && (prevUuid = prev.uuid) && prevUuid !== object.uuid) {
       objects.remove(prevUuid)
     }
 
     this._objects.set(object)
-    objectsByRefs[ref] = object
+    objectsByRef[ref] = object
 
     if (type === 'pool') {
       this._pool = object
 
       const eventWatchers = this._eventWatchers
-      Object.keys(object.other_config).forEach(key => {
+      getKeys(object.other_config).forEach(key => {
         const eventWatcher = eventWatchers[key]
         if (eventWatcher !== undefined) {
           delete eventWatchers[key]
@@ -871,7 +821,7 @@ export class Xapi extends EventEmitter {
   }
 
   _removeObject (type, ref) {
-    const byRefs = this._objectsByRefs
+    const byRefs = this._objectsByRef
     const object = byRefs[ref]
     if (object !== undefined) {
       this._objects.unset(object.$id)
@@ -1028,6 +978,90 @@ export class Xapi extends EventEmitter {
 
     return getAllObjects().then(watchEvents)
   }
+
+  _wrapRecord (type, ref, data) {
+    const RecordsByType = this._RecordsByType
+    let Record = RecordsByType[type]
+    if (Record === undefined) {
+      const fields = getKeys(data)
+      const nFields = fields.length
+      const xapi = this
+
+      const objectsByRef = this._objectsByRef
+      const getObjectByRef = ref => objectsByRef[ref]
+
+      Record = function (ref, data) {
+        defineProperties(this, {
+          $id: { value: data.uuid || ref },
+          $ref: { value: ref },
+        })
+        for (let i = 0; i < nFields; ++i) {
+          const field = fields[i]
+          this[field] = data[field]
+        }
+      }
+
+      const getters = { $pool: this._getPool }
+      const props = { $type: type }
+      fields.forEach(field => {
+        props[`set_${field}`] = function (value) {
+          return xapi.setField(this, field, value)
+        }
+
+        const $field = (field in RESERVED_FIELDS ? '$$' : '$') + field
+
+        const value = data[field]
+        if (isArray(value)) {
+          if (value.length === 0 || isOpaqueRef(value[0])) {
+            getters[$field] = function () {
+              const value = this[field]
+              return value.length === 0 ? value : value.map(getObjectByRef)
+            }
+          }
+
+          props[`add_to_${field}`] = function (...values) {
+            return xapi
+              .call(`${type}.add_${field}`, this.$ref, values)
+              .then(noop)
+          }
+        } else if (value !== null && typeof value === 'object') {
+          getters[$field] = function () {
+            const value = this[field]
+            const result = {}
+            getKeys(value).forEach(key => {
+              result[key] = objectsByRef[value[key]]
+            })
+            return result
+          }
+          props[`update_${field}`] = function (entries) {
+            return xapi.setFieldEntries(this, field, entries)
+          }
+        } else if (isOpaqueRef(value)) {
+          getters[$field] = function () {
+            return objectsByRef[this[field]]
+          }
+        }
+      })
+      const descriptors = {}
+      getKeys(getters).forEach(key => {
+        descriptors[key] = {
+          configurable: true,
+          get: getters[key],
+        }
+      })
+      getKeys(props).forEach(key => {
+        descriptors[key] = {
+          configurable: true,
+          value: props[key],
+          writable: true,
+        }
+      })
+      defineProperties(Record.prototype, descriptors)
+
+      RecordsByType[type] = Record
+    }
+    return new Record(ref, data)
+  }
 }
 
 Xapi.prototype._transportCall = reduce(
@@ -1038,7 +1072,10 @@ Xapi.prototype._transportCall = reduce(
           error = wrapError(error)
         }
 
-        error.method = method
+        error.call = {
+          method,
+          params: replaceSensitiveValues(args, '* obfuscated *'),
+        }
         throw error
       })
     },

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { delay as pDelay } from 'promise-toolbox'
+import { pDelay } from 'promise-toolbox'
 
 import { createClient } from './'
 

packages/xo-acl-resolver/index.js

@@ -1,5 +1,9 @@
 'use strict'
 
+const { unauthorized } = require('xo-common/api-errors')
+
+// ===================================================================
+
 // These global variables are not a problem because the algorithm is
 // synchronous.
 let permissionsByObject
@@ -86,7 +90,7 @@ const checkAuthorizationByTypes = {
 
   'VM-controller': checkMember('$container'),
 
-  'VM-snapshot': checkMember('$snapshot_of'),
+  'VM-snapshot': or(checkSelf, checkMember('$snapshot_of')),
 
   'VM-template': or(checkSelf, checkMember('$pool')),
 }
@@ -105,23 +109,26 @@ function checkAuthorization (objectId, permission) {
 
 // -------------------------------------------------------------------
 
-module.exports = (
+function assertPermissions (
   permissionsByObject_,
   getObject_,
   permissions,
   permission
-) => {
+) {
   // Assign global variables.
   permissionsByObject = permissionsByObject_
   getObject = getObject_
 
   try {
-    if (permission) {
-      return checkAuthorization(permissions, permission)
+    if (permission !== undefined) {
+      const objectId = permissions
+      if (!checkAuthorization(objectId, permission)) {
+        throw unauthorized(permission, objectId)
+      }
     } else {
       for (const [objectId, permission] of permissions) {
         if (!checkAuthorization(objectId, permission)) {
-          return false
+          throw unauthorized(permission, objectId)
         }
       }
     }
@@ -132,3 +139,16 @@ module.exports = (
     permissionsByObject = getObject = null
   }
 }
+exports.assert = assertPermissions
+
+exports.check = function checkPermissions () {
+  try {
+    assertPermissions.apply(undefined, arguments)
+    return true
+  } catch (error) {
+    if (unauthorized.is(error)) {
+      return false
+    }
+    throw error
+  }
+}

packages/xo-acl-resolver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xo-acl-resolver",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "license": "ISC",
   "description": "Xen-Orchestra internal: do ACLs resolution",
   "keywords": [],
@@ -21,5 +21,8 @@
   ],
   "engines": {
     "node": ">=6"
+  },
+  "dependencies": {
+    "xo-common": "^0.2.0"
   }
 }

packages/xo-cli/README.md

@@ -120,7 +120,7 @@ encoding by prefixing with `json:`:
 ##### VM import
 
  ```
-> xo-cli vm.import host=60a6939e-8b0a-4352-9954-5bde44bcdf7d @=vm.xva
+> xo-cli vm.import sr=60a6939e-8b0a-4352-9954-5bde44bcdf7d @=vm.xva
 ```
 
 ## Development

packages/xo-cli/package.json

@@ -28,31 +28,32 @@
     "node": ">=6"
   },
   "dependencies": {
-    "@babel/polyfill": "7.0.0-rc.1",
+    "@babel/polyfill": "^7.0.0",
     "bluebird": "^3.5.1",
     "chalk": "^2.2.0",
-    "event-to-promise": "^0.8.0",
     "exec-promise": "^0.7.0",
     "fs-promise": "^2.0.3",
-    "got": "^8.0.1",
+    "http-request-plus": "^0.6.0",
     "human-format": "^0.10.0",
     "l33teral": "^3.0.3",
     "lodash": "^4.17.4",
     "micromatch": "^3.1.3",
     "mkdirp": "^0.5.1",
     "nice-pipe": "0.0.0",
-    "pretty-ms": "^3.0.1",
+    "pretty-ms": "^4.0.0",
     "progress-stream": "^2.0.0",
+    "promise-toolbox": "^0.11.0",
+    "pump": "^3.0.0",
     "pw": "^0.0.4",
     "strip-indent": "^2.0.0",
     "xdg-basedir": "^3.0.0",
     "xo-lib": "^0.9.0"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
-    "@babel/preset-flow": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
     "babel-plugin-lodash": "^3.3.2",
     "cross-env": "^5.1.3",
     "rimraf": "^2.6.2"

packages/xo-cli/src/index.js

@@ -11,10 +11,10 @@ const resolveUrl = require('url').resolve
 const stat = require('fs-promise').stat
 
 const chalk = require('chalk')
-const eventToPromise = require('event-to-promise')
 const forEach = require('lodash/forEach')
+const fromCallback = require('promise-toolbox/fromCallback')
 const getKeys = require('lodash/keys')
-const got = require('got')
+const hrp = require('http-request-plus').default
 const humanFormat = require('human-format')
 const identity = require('lodash/identity')
 const isArray = require('lodash/isArray')
@@ -23,6 +23,7 @@ const micromatch = require('micromatch')
 const nicePipe = require('nice-pipe')
 const pairs = require('lodash/toPairs')
 const pick = require('lodash/pick')
+const pump = require('pump')
 const startsWith = require('lodash/startsWith')
 const prettyMs = require('pretty-ms')
 const progressStream = require('progress-stream')
@@ -362,50 +363,43 @@ async function call (args) {
       ensurePathParam(method, file)
       url = resolveUrl(baseUrl, result[key])
       const output = createWriteStream(file)
+      const response = await hrp(url)
 
-      const progress = progressStream({ time: 1e3 }, printProgress)
-
-      return eventToPromise(
-        nicePipe([
-          got.stream(url).on('response', function (response) {
-            const length = response.headers['content-length']
-            if (length !== undefined) {
-              progress.length(length)
-            }
-          }),
-          progress,
-          output,
-        ]),
-        'finish'
+      const progress = progressStream(
+        {
+          length: response.headers['content-length'],
+          time: 1e3,
+        },
+        printProgress
       )
+
+      return fromCallback(cb => pump(response, progress, output, cb))
     }
 
     if (key === '$sendTo') {
       ensurePathParam(method, file)
       url = resolveUrl(baseUrl, result[key])
 
-      const stats = await stat(file)
-      const length = stats.size
-
+      const { size: length } = await stat(file)
       const input = nicePipe([
         createReadStream(file),
         progressStream(
           {
-            length: length,
+            length,
             time: 1e3,
           },
           printProgress
         ),
       ])
 
-      const response = await got.post(url, {
-        body: input,
-        headers: {
-          'content-length': length,
-        },
-        method: 'POST',
-      })
-      return response.body
+      return hrp
+        .post(url, {
+          body: input,
+          headers: {
+            'content-length': length,
+          },
+        })
+        .readAll('utf-8')
     }
   }
 

packages/xo-collection/package.json

@@ -25,16 +25,14 @@
     "node": ">=6"
   },
   "dependencies": {
-    "@babel/runtime": "7.0.0-rc.1",
     "kindof": "^2.0.0",
     "lodash": "^4.17.2",
     "make-error": "^1.0.2"
   },
   "devDependencies": {
-    "@babel/cli": "7.0.0-rc.1",
-    "@babel/core": "7.0.0-rc.1",
-    "@babel/plugin-transform-runtime": "7.0.0-rc.1",
-    "@babel/preset-env": "7.0.0-rc.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
     "cross-env": "^5.1.3",
     "event-to-promise": "^0.8.0",
     "rimraf": "^2.6.1"

packages/xo-common/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

packages/xo-common/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xo-common",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "AGPL-3.0",
   "description": "Code shared between [XO](https://xen-orchestra.com) server and clients",
   "keywords": [],
@@ -20,20 +20,21 @@
     "dist/",
     "*.js"
   ],
+  "browserslist": [
+    "> 1%"
+  ],
   "engines": {
     "node": ">=6"
   },
   "dependencies": {
-    "babel-runtime": "^6.18.0",
     "lodash": "^4.16.6",
     "make-error": "^1.2.1"
   },
   "devDependencies": {
-    "babel-cli": "^6.24.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
     "babel-plugin-lodash": "^3.3.2",
-    "babel-plugin-transform-runtime": "^6.23.0",
-    "babel-preset-env": "^1.5.2",
-    "babel-preset-stage-3": "^6.24.1",
     "cross-env": "^5.1.3",
     "rimraf": "^2.6.1"
   },
@@ -44,22 +45,5 @@
     "prebuild": "yarn run clean",
     "predev": "yarn run prebuild",
     "prepublishOnly": "yarn run build"
-  },
-  "babel": {
-    "plugins": [
-      "lodash"
-    ],
-    "presets": [
-      [
-        "env",
-        {
-          "targets": {
-            "browsers": "> 1%",
-            "node": 4
-          }
-        }
-      ],
-      "stage-3"
-    ]
   }
 }

packages/xo-common/src/api-errors.js

@@ -20,7 +20,8 @@ class XoError extends BaseError {
 const create = (code, getProps) => {
   const factory = (...args) => new XoError({ ...getProps(...args), code })
   factory.is = (error, predicate) =>
-    error.code === code && iteratee(predicate)(error)
+    error.code === code &&
+    (predicate === undefined || iteratee(predicate)(error))
 
   return factory
 }
@@ -33,11 +34,18 @@ export const notImplemented = create(0, () => ({
 
 export const noSuchObject = create(1, (id, type) => ({
   data: { id, type },
-  message: 'no such object',
+  message: `no such ${type || 'object'} ${id}`,
 }))
 
-export const unauthorized = create(2, () => ({
-  message: 'not authenticated or not enough permissions',
+export const unauthorized = create(2, (permission, objectId, objectType) => ({
+  data: {
+    permission,
+    object: {
+      id: objectId,
+      type: objectType,
+    },
+  },
+  message: 'not enough permissions',
 }))
 
 export const invalidCredentials = create(3, () => ({

packages/xo-import-servers-csv/.npmignore

@@ -0,0 +1,10 @@
+/examples/
+example.js
+example.js.map
+*.example.js
+*.example.js.map
+
+/test/
+/tests/
+*.spec.js
+*.spec.js.map