fix: remove root need for openVhd.integ.spec.js and merge.integ.spec.js

.eslintrc.js

@@ -1,7 +1,5 @@
-'use strict'
-
 module.exports = {
-  extends: ['plugin:eslint-comments/recommended', 'plugin:n/recommended', 'standard', 'standard-jsx', 'prettier'],
+  extends: ['plugin:eslint-comments/recommended', 'standard', 'standard-jsx', 'prettier'],
   globals: {
     __DEV__: true,
     $Dict: true,
@@ -17,40 +15,11 @@ module.exports = {
     {
       files: ['cli.{,c,m}js', '*-cli.{,c,m}js', '**/*cli*/**/*.{,c,m}js'],
       rules: {
-        'n/no-process-exit': 'off',
         'no-console': 'off',
       },
     },
-    {
-      files: ['*.mjs'],
-      parserOptions: {
-        sourceType: 'module',
-      },
-    },
-    {
-      files: ['*.spec.{,c,m}js'],
-      rules: {
-        'n/no-unsupported-features/node-builtins': [
-          'error',
-          {
-            version: '>=16',
-          },
-        ],
-        'n/no-unsupported-features/es-syntax': [
-          'error',
-          {
-            version: '>=16',
-          },
-        ],
-      },
-    },
   ],
 
-  parserOptions: {
-    ecmaVersion: 13,
-    sourceType: 'script',
-  },
-
   rules: {
     // disabled because XAPI objects are using camel case
     camelcase: ['off'],
@@ -65,7 +34,5 @@ module.exports = {
     'lines-between-class-members': 'off',
 
     'no-console': ['error', { allow: ['warn', 'error'] }],
-
-    strict: 'error',
   },
 }

.flowconfig

@@ -0,0 +1,16 @@
+[ignore]
+<PROJECT_ROOT>/node_modules/.*
+
+[include]
+
+[libs]
+
+[lints]
+
+[options]
+esproposal.decorators=ignore
+esproposal.optional_chaining=enable
+include_warnings=true
+module.use_strict=true
+
+[strict]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -4,26 +4,14 @@ about: Create a report to help us improve
 title: ''
 labels: 'status: triaging :triangular_flag_on_post:, type: bug :bug:'
 assignees: ''
+
 ---
 
-**XOA or XO from the sources?**
-
-If XOA:
-
-- which release channel? (`stable` vs `latest`)
-- please consider creating a support ticket in [your dedicated support area](https://xen-orchestra.com/#!/member/support)
-
-If XO from the sources:
-
-- Don't forget to [read this first](https://xen-orchestra.com/docs/community.html)
-- As well as follow [this guide](https://xen-orchestra.com/docs/community.html#report-a-bug)
-
 **Describe the bug**
 A clear and concise description of what the bug is.
 
 **To Reproduce**
 Steps to reproduce the behavior:
-
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'
@@ -35,12 +23,11 @@ A clear and concise description of what you expected to happen.
 **Screenshots**
 If applicable, add screenshots to help explain your problem.
 
-**Environment (please provide the following information):**
-
-- Node: [e.g. 16.12.1]
-- xo-server: [e.g. 5.82.3]
-- xo-web: [e.g. 5.87.0]
-- hypervisor: [e.g. XCP-ng 8.2.0]
+**Desktop (please complete the following information):**
+ - Node: [e.g. 16.12.1]
+ - xo-server: [e.g. 5.82.3]
+ - xo-web: [e.g. 5.87.0]
+ - hypervisor: [e.g. XCP-ng 8.2.0]
 
 **Additional context**
 Add any other context about the problem here.

.github/workflows/push.yml

@@ -1,13 +0,0 @@
-name: CI
-on: [push]
-jobs:
-  build:
-    name: Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: satackey/action-docker-layer-caching@v0.0.11
-      # Ignore the failure of a step and avoid terminating the job.
-        continue-on-error: true
-      - run: docker-compose  -f docker/docker-compose.dev.yml build
-      - run: docker-compose  -f docker/docker-compose.dev.yml up

.gitignore

@@ -1,4 +1,5 @@
 /_book/
+/coverage/
 /node_modules/
 /lerna-debug.log
 /lerna-debug.log.*
@@ -10,6 +11,8 @@
 /packages/*/dist/
 /packages/*/node_modules/
 
+/@xen-orchestra/proxy/src/app/mixins/index.mjs
+
 /packages/vhd-cli/src/commands/index.js
 
 /packages/xen-api/examples/node_modules/
@@ -32,7 +35,3 @@ pnpm-debug.log.*
 yarn-error.log
 yarn-error.log.*
 .env
-
-# code coverage
-.nyc_output/
-coverage/

.travis.yml

@@ -0,0 +1,23 @@
+language: node_js
+node_js:
+  - 14
+
+# Use containers.
+# http://docs.travis-ci.com/user/workers/container-based-infrastructure/
+sudo: false
+addons:
+  apt:
+    packages:
+      - qemu-utils
+      - blktap-utils
+      - vmdk-stream-converter
+
+before_install:
+  - curl -o- -L https://yarnpkg.com/install.sh | bash
+  - export PATH="$HOME/.yarn/bin:$PATH"
+
+cache:
+  yarn: true
+
+script:
+  - yarn run travis-tests

@vates/async-each/.USAGE.md

@@ -1,35 +0,0 @@
-### `asyncEach(iterable, iteratee, [opts])`
-
-Executes `iteratee` in order for each value yielded by `iterable`.
-
-Returns a promise wich rejects as soon as a call to `iteratee` throws or a promise returned by it rejects, and which resolves when all promises returned by `iteratee` have resolved.
-
-`iterable` must be an iterable or async iterable.
-
-`iteratee` is called with the same `this` value as `asyncEach`, and with the following arguments:
-
-- `value`: the value yielded by `iterable`
-- `index`: the 0-based index for this value
-- `iterable`: the iterable itself
-
-`opts` is an object that can contains the following options:
-
-- `concurrency`: a number which indicates the maximum number of parallel call to `iteratee`, defaults to `1`
-- `signal`: an abort signal to stop the iteration
-- `stopOnError`: wether to stop iteration of first error, or wait for all calls to finish and throw an `AggregateError`, defaults to `true`
-
-```js
-import { asyncEach } from '@vates/async-each'
-
-const contents = []
-await asyncEach(
-  ['foo.txt', 'bar.txt', 'baz.txt'],
-  async function (filename, i) {
-    contents[i] = await readFile(filename)
-  },
-  {
-    // reads two files at a time
-    concurrency: 2,
-  }
-)
-```

@vates/async-each/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/async-each/README.md

@@ -1,68 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/async-each
-
-[![Package Version](https://badgen.net/npm/v/@vates/async-each)](https://npmjs.org/package/@vates/async-each) ![License](https://badgen.net/npm/license/@vates/async-each) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/async-each)](https://bundlephobia.com/result?p=@vates/async-each) [![Node compatibility](https://badgen.net/npm/node/@vates/async-each)](https://npmjs.org/package/@vates/async-each)
-
-> Run async fn for each item in (async) iterable
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/async-each):
-
-```
-> npm install --save @vates/async-each
-```
-
-## Usage
-
-### `asyncEach(iterable, iteratee, [opts])`
-
-Executes `iteratee` in order for each value yielded by `iterable`.
-
-Returns a promise wich rejects as soon as a call to `iteratee` throws or a promise returned by it rejects, and which resolves when all promises returned by `iteratee` have resolved.
-
-`iterable` must be an iterable or async iterable.
-
-`iteratee` is called with the same `this` value as `asyncEach`, and with the following arguments:
-
-- `value`: the value yielded by `iterable`
-- `index`: the 0-based index for this value
-- `iterable`: the iterable itself
-
-`opts` is an object that can contains the following options:
-
-- `concurrency`: a number which indicates the maximum number of parallel call to `iteratee`, defaults to `1`
-- `signal`: an abort signal to stop the iteration
-- `stopOnError`: wether to stop iteration of first error, or wait for all calls to finish and throw an `AggregateError`, defaults to `true`
-
-```js
-import { asyncEach } from '@vates/async-each'
-
-const contents = []
-await asyncEach(
-  ['foo.txt', 'bar.txt', 'baz.txt'],
-  async function (filename, i) {
-    contents[i] = await readFile(filename)
-  },
-  {
-    // reads two files at a time
-    concurrency: 2,
-  }
-)
-```
-
-## 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](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/async-each/index.js

@@ -1,99 +0,0 @@
-'use strict'
-
-const noop = Function.prototype
-
-class AggregateError extends Error {
-  constructor(errors, message) {
-    super(message)
-    this.errors = errors
-  }
-}
-
-exports.asyncEach = function asyncEach(iterable, iteratee, { concurrency = 1, signal, stopOnError = true } = {}) {
-  return new Promise((resolve, reject) => {
-    const it = (iterable[Symbol.iterator] || iterable[Symbol.asyncIterator]).call(iterable)
-    const errors = []
-    let running = 0
-    let index = 0
-
-    let onAbort
-    if (signal !== undefined) {
-      onAbort = () => {
-        onRejectedWrapper(new Error('asyncEach aborted'))
-      }
-      signal.addEventListener('abort', onAbort)
-    }
-
-    const clean = () => {
-      onFulfilled = onRejected = noop
-      if (onAbort !== undefined) {
-        signal.removeEventListener('abort', onAbort)
-      }
-    }
-
-    resolve = (resolve =>
-      function resolveAndClean(value) {
-        resolve(value)
-        clean()
-      })(resolve)
-    reject = (reject =>
-      function rejectAndClean(reason) {
-        reject(reason)
-        clean()
-      })(reject)
-
-    let onFulfilled = value => {
-      --running
-      next()
-    }
-    const onFulfilledWrapper = value => onFulfilled(value)
-
-    let onRejected = stopOnError
-      ? reject
-      : error => {
-          --running
-          errors.push(error)
-          next()
-        }
-    const onRejectedWrapper = reason => onRejected(reason)
-
-    let nextIsRunning = false
-    let next = async () => {
-      if (nextIsRunning) {
-        return
-      }
-      nextIsRunning = true
-      if (running < concurrency) {
-        const cursor = await it.next()
-        if (cursor.done) {
-          next = () => {
-            if (running === 0) {
-              if (errors.length === 0) {
-                resolve()
-              } else {
-                reject(new AggregateError(errors))
-              }
-            }
-          }
-        } else {
-          ++running
-          try {
-            const result = iteratee.call(this, cursor.value, index++, iterable)
-            let then
-            if (result != null && typeof result === 'object' && typeof (then = result.then) === 'function') {
-              then.call(result, onFulfilledWrapper, onRejectedWrapper)
-            } else {
-              onFulfilled(result)
-            }
-          } catch (error) {
-            onRejected(error)
-          }
-        }
-        nextIsRunning = false
-        return next()
-      }
-      nextIsRunning = false
-    }
-    next()
-  })
-}

@vates/async-each/index.spec.js

@@ -1,99 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { asyncEach } = require('./')
-
-const randomDelay = (max = 10) =>
-  new Promise(resolve => {
-    setTimeout(resolve, Math.floor(Math.random() * max + 1))
-  })
-
-const rejectionOf = p =>
-  new Promise((resolve, reject) => {
-    p.then(reject, resolve)
-  })
-
-describe('asyncEach', () => {
-  const thisArg = 'qux'
-  const values = ['foo', 'bar', 'baz']
-
-  Object.entries({
-    'sync iterable': () => values,
-    'async iterable': async function* () {
-      for (const value of values) {
-        await randomDelay()
-        yield value
-      }
-    },
-  }).forEach(([what, getIterable]) =>
-    describe('with ' + what, () => {
-      let iterable
-      beforeEach(() => {
-        iterable = getIterable()
-      })
-
-      it('works', async () => {
-        const iteratee = jest.fn(async () => {})
-
-        await asyncEach.call(thisArg, iterable, iteratee)
-
-        expect(iteratee.mock.instances).toEqual(Array.from(values, () => thisArg))
-        expect(iteratee.mock.calls).toEqual(Array.from(values, (value, index) => [value, index, iterable]))
-      })
-      ;[1, 2, 4].forEach(concurrency => {
-        it('respects a concurrency of ' + concurrency, async () => {
-          let running = 0
-
-          await asyncEach(
-            values,
-            async () => {
-              ++running
-              expect(running).toBeLessThanOrEqual(concurrency)
-              await randomDelay()
-              --running
-            },
-            { concurrency }
-          )
-        })
-      })
-
-      it('stops on first error when stopOnError is true', async () => {
-        const error = new Error()
-        const iteratee = jest.fn((_, i) => {
-          if (i === 1) {
-            throw error
-          }
-        })
-
-        expect(await rejectionOf(asyncEach(iterable, iteratee, { stopOnError: true }))).toBe(error)
-        expect(iteratee).toHaveBeenCalledTimes(2)
-      })
-
-      it('rejects AggregateError when stopOnError is false', async () => {
-        const errors = []
-        const iteratee = jest.fn(() => {
-          const error = new Error()
-          errors.push(error)
-          throw error
-        })
-
-        const error = await rejectionOf(asyncEach(iterable, iteratee, { stopOnError: false }))
-        expect(error.errors).toEqual(errors)
-        expect(iteratee.mock.calls).toEqual(Array.from(values, (value, index) => [value, index, iterable]))
-      })
-
-      it('can be interrupted with an AbortSignal', async () => {
-        const ac = new AbortController()
-        const iteratee = jest.fn((_, i) => {
-          if (i === 1) {
-            ac.abort()
-          }
-        })
-
-        await expect(asyncEach(iterable, iteratee, { signal: ac.signal })).rejects.toThrow('asyncEach aborted')
-        expect(iteratee).toHaveBeenCalledTimes(2)
-      })
-    })
-  )
-})

@vates/async-each/package.json

@@ -1,34 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/async-each",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/async-each",
-  "description": "Run async fn for each item in (async) iterable",
-  "keywords": [
-    "array",
-    "async",
-    "collection",
-    "each",
-    "for",
-    "foreach",
-    "iterable",
-    "iterator"
-  ],
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/async-each",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "0.1.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/cached-dns.lookup/.USAGE.md

@@ -1,30 +0,0 @@
-Node does not cache queries to `dns.lookup`, which can lead application doing a lot of connections to have perf issues and to saturate Node threads pool.
-
-This library attempts to mitigate these problems by providing a version of this function with a version short cache, applied on both errors and results.
-
-> Limitation: `verbatim: false` option is not supported.
-
-It has exactly the same API as the native method and can be used directly:
-
-```js
-import { createCachedLookup } from '@vates/cached-dns.lookup'
-
-const lookup = createCachedLookup()
-
-lookup('example.net', { all: true, family: 0 }, (error, result) => {
-  if (error != null) {
-    return console.warn(error)
-  }
-  console.log(result)
-})
-```
-
-Or it can be used to replace the native implementation and speed up the whole app:
-
-```js
-// assign our cached implementation to dns.lookup
-const restore = createCachedLookup().patchGlobal()
-
-// to restore the previous implementation
-restore()
-```

@vates/cached-dns.lookup/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/cached-dns.lookup/README.md

@@ -1,63 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/cached-dns.lookup
-
-[![Package Version](https://badgen.net/npm/v/@vates/cached-dns.lookup)](https://npmjs.org/package/@vates/cached-dns.lookup) ![License](https://badgen.net/npm/license/@vates/cached-dns.lookup) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/cached-dns.lookup)](https://bundlephobia.com/result?p=@vates/cached-dns.lookup) [![Node compatibility](https://badgen.net/npm/node/@vates/cached-dns.lookup)](https://npmjs.org/package/@vates/cached-dns.lookup)
-
-> Cached implementation of dns.lookup
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/cached-dns.lookup):
-
-```
-> npm install --save @vates/cached-dns.lookup
-```
-
-## Usage
-
-Node does not cache queries to `dns.lookup`, which can lead application doing a lot of connections to have perf issues and to saturate Node threads pool.
-
-This library attempts to mitigate these problems by providing a version of this function with a version short cache, applied on both errors and results.
-
-> Limitation: `verbatim: false` option is not supported.
-
-It has exactly the same API as the native method and can be used directly:
-
-```js
-import { createCachedLookup } from '@vates/cached-dns.lookup'
-
-const lookup = createCachedLookup()
-
-lookup('example.net', { all: true, family: 0 }, (error, result) => {
-  if (error != null) {
-    return console.warn(error)
-  }
-  console.log(result)
-})
-```
-
-Or it can be used to replace the native implementation and speed up the whole app:
-
-```js
-// assign our cached implementation to dns.lookup
-const restore = createCachedLookup().patchGlobal()
-
-// to restore the previous implementation
-restore()
-```
-
-## 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](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/cached-dns.lookup/index.js

@@ -1,72 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const dns = require('dns')
-const LRU = require('lru-cache')
-
-function reportResults(all, results, callback) {
-  if (all) {
-    callback(null, results)
-  } else {
-    const first = results[0]
-    callback(null, first.address, first.family)
-  }
-}
-
-exports.createCachedLookup = function createCachedLookup({ lookup = dns.lookup } = {}) {
-  const cache = new LRU({
-    max: 500,
-
-    // 1 minute: long enough to be effective, short enough so there is no need to bother with DNS TTLs
-    ttl: 60e3,
-  })
-
-  function cachedLookup(hostname, options, callback) {
-    let all = false
-    let family = 0
-    if (typeof options === 'function') {
-      callback = options
-    } else if (typeof options === 'number') {
-      family = options
-    } else if (options != null) {
-      assert.notStrictEqual(options.verbatim, false, 'not supported by this implementation')
-      ;({ all = all, family = family } = options)
-    }
-
-    // cache by family option because there will be an error if there is no
-    // entries for the requestion family so we cannot easily cache all families
-    // and filter on reporting back
-    const key = hostname + '/' + family
-
-    const result = cache.get(key)
-    if (result !== undefined) {
-      setImmediate(reportResults, all, result, callback)
-    } else {
-      lookup(hostname, { all: true, family, verbatim: true }, function onLookup(error, results) {
-        // errors are not cached because this will delay recovery after DNS/network issues
-        //
-        // there are no reliable way to detect if the error is real or simply
-        // that there are no results for the requested hostname
-        //
-        // there should be much fewer errors than success, therefore it should
-        // not be a big deal to not cache them
-        if (error != null) {
-          return callback(error)
-        }
-
-        cache.set(key, results)
-        reportResults(all, results, callback)
-      })
-    }
-  }
-  cachedLookup.patchGlobal = function patchGlobal() {
-    const previous = dns.lookup
-    dns.lookup = cachedLookup
-    return function restoreGlobal() {
-      assert.strictEqual(dns.lookup, cachedLookup)
-      dns.lookup = previous
-    }
-  }
-
-  return cachedLookup
-}

@vates/cached-dns.lookup/package.json

@@ -1,32 +0,0 @@
-{
-  "engines": {
-    "node": ">=8"
-  },
-  "dependencies": {
-    "lru-cache": "^7.0.4"
-  },
-  "private": false,
-  "name": "@vates/cached-dns.lookup",
-  "description": "Cached implementation of dns.lookup",
-  "keywords": [
-    "cache",
-    "dns",
-    "lookup"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/cached-dns.lookup",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/cached-dns.lookup",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.0",
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/coalesce-calls/index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 exports.coalesceCalls = function (fn) {
   let promise
   const clean = () => {

@vates/coalesce-calls/index.spec.js

@@ -1,5 +1,3 @@
-'use strict'
-
 /* eslint-env jest */
 
 const { coalesceCalls } = require('./')

@vates/compose/README.md

@@ -65,23 +65,6 @@ const f = compose(
 )
 ```
 
-Functions can receive extra parameters:
-
-```js
-const isIn = (value, min, max) => min <= value && value <= max
-
-// Only compatible when `fns` is passed as an array!
-const f = compose([
-  [add, 2],
-  [isIn, 3, 10],
-])
-
-console.log(f(1))
-// → true
-```
-
-> Note: if the first function is defined with extra parameters, it will only receive the first value passed to the composed function, instead of all the parameters.
-
 ## Contributions
 
 Contributions are _very_ welcomed, either on the documentation or on

@vates/compose/USAGE.md

@@ -46,20 +46,3 @@ const f = compose(
   [add2, mul3]
 )
 ```
-
-Functions can receive extra parameters:
-
-```js
-const isIn = (value, min, max) => min <= value && value <= max
-
-// Only compatible when `fns` is passed as an array!
-const f = compose([
-  [add, 2],
-  [isIn, 3, 10],
-])
-
-console.log(f(1))
-// → true
-```
-
-> Note: if the first function is defined with extra parameters, it will only receive the first value passed to the composed function, instead of all the parameters.

@vates/compose/index.js

@@ -4,13 +4,11 @@ const defaultOpts = { async: false, right: false }
 
 exports.compose = function compose(opts, fns) {
   if (Array.isArray(opts)) {
-    fns = opts.slice() // don't mutate passed array
+    fns = opts
     opts = defaultOpts
   } else if (typeof opts === 'object') {
     opts = Object.assign({}, defaultOpts, opts)
-    if (Array.isArray(fns)) {
-      fns = fns.slice() // don't mutate passed array
-    } else {
+    if (!Array.isArray(fns)) {
       fns = Array.prototype.slice.call(arguments, 1)
     }
   } else {
@@ -22,24 +20,6 @@ exports.compose = function compose(opts, fns) {
   if (n === 0) {
     throw new TypeError('at least one function must be passed')
   }
-
-  for (let i = 0; i < n; ++i) {
-    const entry = fns[i]
-    if (Array.isArray(entry)) {
-      const fn = entry[0]
-      const args = entry.slice()
-      args[0] = undefined
-      fns[i] = function composeWithArgs(value) {
-        args[0] = value
-        try {
-          return fn.apply(this, args)
-        } finally {
-          args[0] = undefined
-        }
-      }
-    }
-  }
-
   if (n === 1) {
     return fns[0]
   }

@vates/compose/index.spec.js

@@ -1,5 +1,3 @@
-'use strict'
-
 /* eslint-env jest */
 
 const { compose } = require('./')

@vates/compose/package.json

@@ -14,7 +14,7 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "2.1.0",
+  "version": "2.0.0",
   "engines": {
     "node": ">=7.6"
   },

@vates/decorate-with/.USAGE.md

@@ -1,86 +0,0 @@
-### `decorateWith(fn, ...args)`
-
-Creates a new ([legacy](https://babeljs.io/docs/en/babel-plugin-syntax-decorators#legacy)) method decorator from a function decorator, for instance, allows using Lodash's functions as decorators:
-
-```js
-import { decorateWith } from '@vates/decorate-with'
-
-class Foo {
-  @decorateWith(lodash.debounce, 150)
-  bar() {
-    // body
-  }
-}
-```
-
-### `decorateClass(class, map)`
-
-Decorates a number of accessors and methods directly, without using the decorator syntax:
-
-```js
-import { decorateClass } from '@vates/decorate-with'
-
-class Foo {
-  get bar() {
-    // body
-  }
-
-  set bar(value) {
-    // body
-  }
-
-  baz() {
-    // body
-  }
-}
-
-decorateClass(Foo, {
-  // getter and/or setter
-  bar: {
-    // without arguments
-    get: lodash.memoize,
-
-    // with arguments
-    set: [lodash.debounce, 150],
-  },
-
-  // method (with or without arguments)
-  baz: lodash.curry,
-})
-```
-
-The decorated class is returned, so you can export it directly.
-
-To apply multiple transforms to an accessor/method, you can either call `decorateClass` multiple times or use [`@vates/compose`](https://www.npmjs.com/package/@vates/compose):
-
-```js
-decorateClass(Foo, {
-  baz: compose([
-    [lodash.debounce, 150]
-    lodash.curry,
-  ])
-})
-```
-
-### `perInstance(fn, ...args)`
-
-Helper to decorate the method by instance instead of for the whole class.
-
-This is often necessary for caching or deduplicating calls.
-
-```js
-import { perInstance } from '@vates/decorateWith'
-
-class Foo {
-  @decorateWith(perInstance, lodash.memoize)
-  bar() {
-    // body
-  }
-}
-```
-
-Because it's a normal function, it can also be used with `decorateClass`, with `compose` or even by itself.
-
-### `decorateMethodsWith(class, map)`
-
-> Deprecated alias for [`decorateClass(class, map)`](#decorateclassclass-map).

@vates/decorate-with/README.md

@@ -31,19 +31,15 @@ class Foo {
 }
 ```
 
-### `decorateClass(class, map)`
+### `decorateMethodsWith(class, map)`
 
-Decorates a number of accessors and methods directly, without using the decorator syntax:
+Decorates a number of methods directly, without using the decorator syntax:
 
 ```js
-import { decorateClass } from '@vates/decorate-with'
+import { decorateMethodsWith } from '@vates/decorate-with'
 
 class Foo {
-  get bar() {
-    // body
-  }
-
-  set bar(value) {
+  bar() {
     // body
   }
 
@@ -52,57 +48,17 @@ class Foo {
   }
 }
 
-decorateClass(Foo, {
-  // getter and/or setter
-  bar: {
-    // without arguments
-    get: lodash.memoize,
+decorateMethodsWith(Foo, {
+  // without arguments
+  bar: lodash.curry,
 
-    // with arguments
-    set: [lodash.debounce, 150],
-  },
-
-  // method (with or without arguments)
-  baz: lodash.curry,
+  // with arguments
+  baz: [lodash.debounce, 150],
 })
 ```
 
 The decorated class is returned, so you can export it directly.
 
-To apply multiple transforms to an accessor/method, you can either call `decorateClass` multiple times or use [`@vates/compose`](https://www.npmjs.com/package/@vates/compose):
-
-```js
-decorateClass(Foo, {
-  baz: compose([
-    [lodash.debounce, 150]
-    lodash.curry,
-  ])
-})
-```
-
-### `perInstance(fn, ...args)`
-
-Helper to decorate the method by instance instead of for the whole class.
-
-This is often necessary for caching or deduplicating calls.
-
-```js
-import { perInstance } from '@vates/decorateWith'
-
-class Foo {
-  @decorateWith(perInstance, lodash.memoize)
-  bar() {
-    // body
-  }
-}
-```
-
-Because it's a normal function, it can also be used with `decorateClass`, with `compose` or even by itself.
-
-### `decorateMethodsWith(class, map)`
-
-> Deprecated alias for [`decorateClass(class, map)`](#decorateclassclass-map).
-
 ## Contributions
 
 Contributions are _very_ welcomed, either on the documentation or on

@vates/decorate-with/USAGE.md

@@ -0,0 +1,42 @@
+### `decorateWith(fn, ...args)`
+
+Creates a new ([legacy](https://babeljs.io/docs/en/babel-plugin-syntax-decorators#legacy)) method decorator from a function decorator, for instance, allows using Lodash's functions as decorators:
+
+```js
+import { decorateWith } from '@vates/decorate-with'
+
+class Foo {
+  @decorateWith(lodash.debounce, 150)
+  bar() {
+    // body
+  }
+}
+```
+
+### `decorateMethodsWith(class, map)`
+
+Decorates a number of methods directly, without using the decorator syntax:
+
+```js
+import { decorateMethodsWith } from '@vates/decorate-with'
+
+class Foo {
+  bar() {
+    // body
+  }
+
+  baz() {
+    // body
+  }
+}
+
+decorateMethodsWith(Foo, {
+  // without arguments
+  bar: lodash.curry,
+
+  // with arguments
+  baz: [lodash.debounce, 150],
+})
+```
+
+The decorated class is returned, so you can export it directly.

@vates/decorate-with/index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 exports.decorateWith = function decorateWith(fn, ...args) {
   return (target, name, descriptor) => ({
     ...descriptor,
@@ -9,40 +7,15 @@ exports.decorateWith = function decorateWith(fn, ...args) {
 
 const { getOwnPropertyDescriptor, defineProperty } = Object
 
-function applyDecorator(decorator, value) {
-  return typeof decorator === 'function' ? decorator(value) : decorator[0](value, ...decorator.slice(1))
-}
-
-exports.decorateClass = exports.decorateMethodsWith = function decorateClass(klass, map) {
+exports.decorateMethodsWith = function decorateMethodsWith(klass, map) {
   const { prototype } = klass
   for (const name of Object.keys(map)) {
-    const decorator = map[name]
     const descriptor = getOwnPropertyDescriptor(prototype, name)
-    if (typeof decorator === 'function' || Array.isArray(decorator)) {
-      descriptor.value = applyDecorator(decorator, descriptor.value)
-    } else {
-      const { get, set } = decorator
-      if (get !== undefined) {
-        descriptor.get = applyDecorator(get, descriptor.get)
-      }
-      if (set !== undefined) {
-        descriptor.set = applyDecorator(set, descriptor.set)
-      }
-    }
+    const { value } = descriptor
 
+    const decorator = map[name]
+    descriptor.value = typeof decorator === 'function' ? decorator(value) : decorator[0](value, ...decorator.slice(1))
     defineProperty(prototype, name, descriptor)
   }
   return klass
 }
-
-exports.perInstance = function perInstance(fn, decorator, ...args) {
-  const map = new WeakMap()
-  return function () {
-    let decorated = map.get(this)
-    if (decorated === undefined) {
-      decorated = decorator(fn, ...args)
-      map.set(this, decorated)
-    }
-    return decorated.apply(this, arguments)
-  }
-}

@vates/decorate-with/index.spec.js

@@ -1,152 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const { describe, it } = require('tap').mocha
-
-const { decorateClass, decorateWith, decorateMethodsWith, perInstance } = require('./')
-
-const identity = _ => _
-
-describe('decorateWith', () => {
-  it('works', () => {
-    const expectedArgs = [Math.random(), Math.random()]
-    const expectedFn = Function.prototype
-    const newFn = () => {}
-
-    const decorator = decorateWith(function wrapper(fn, ...args) {
-      assert.deepStrictEqual(fn, expectedFn)
-      assert.deepStrictEqual(args, expectedArgs)
-
-      return newFn
-    }, ...expectedArgs)
-
-    const descriptor = {
-      configurable: true,
-      enumerable: false,
-      value: expectedFn,
-      writable: true,
-    }
-    assert.deepStrictEqual(decorator({}, 'foo', descriptor), {
-      ...descriptor,
-      value: newFn,
-    })
-  })
-})
-
-describe('decorateClass', () => {
-  it('works', () => {
-    class C {
-      foo() {}
-      bar() {}
-      get baz() {}
-      // eslint-disable-next-line accessor-pairs
-      set qux(_) {}
-    }
-
-    const expectedArgs = [Math.random(), Math.random()]
-    const P = C.prototype
-
-    const descriptors = Object.getOwnPropertyDescriptors(P)
-
-    const newFoo = () => {}
-    const newBar = () => {}
-    const newGetBaz = () => {}
-    const newSetQux = _ => {}
-
-    decorateClass(C, {
-      foo(fn) {
-        assert.strictEqual(arguments.length, 1)
-        assert.strictEqual(fn, P.foo)
-        return newFoo
-      },
-      bar: [
-        function (fn, ...args) {
-          assert.strictEqual(fn, P.bar)
-          assert.deepStrictEqual(args, expectedArgs)
-          return newBar
-        },
-        ...expectedArgs,
-      ],
-      baz: {
-        get(fn) {
-          assert.strictEqual(arguments.length, 1)
-          assert.strictEqual(fn, descriptors.baz.get)
-          return newGetBaz
-        },
-      },
-      qux: {
-        set: [
-          function (fn, ...args) {
-            assert.strictEqual(fn, descriptors.qux.set)
-            assert.deepStrictEqual(args, expectedArgs)
-            return newSetQux
-          },
-          ...expectedArgs,
-        ],
-      },
-    })
-
-    const newDescriptors = Object.getOwnPropertyDescriptors(P)
-    assert.deepStrictEqual(newDescriptors.foo, { ...descriptors.foo, value: newFoo })
-    assert.deepStrictEqual(newDescriptors.bar, { ...descriptors.bar, value: newBar })
-    assert.deepStrictEqual(newDescriptors.baz, { ...descriptors.baz, get: newGetBaz })
-    assert.deepStrictEqual(newDescriptors.qux, { ...descriptors.qux, set: newSetQux })
-  })
-
-  it('throws if using an accessor decorator for a method', function () {
-    assert.throws(() =>
-      decorateClass(
-        class {
-          foo() {}
-        },
-        { foo: { get: identity, set: identity } }
-      )
-    )
-  })
-
-  it('throws if using a method decorator for an accessor', function () {
-    assert.throws(() =>
-      decorateClass(
-        class {
-          get foo() {}
-        },
-        { foo: identity }
-      )
-    )
-  })
-})
-
-it('decorateMethodsWith is an alias of decorateClass', function () {
-  assert.strictEqual(decorateMethodsWith, decorateClass)
-})
-
-describe('perInstance', () => {
-  it('works', () => {
-    let calls = 0
-
-    const expectedArgs = [Math.random(), Math.random()]
-    const expectedFn = Function.prototype
-    function wrapper(fn, ...args) {
-      assert.strictEqual(fn, expectedFn)
-      assert.deepStrictEqual(args, expectedArgs)
-      const i = ++calls
-      return () => i
-    }
-
-    const wrapped = perInstance(expectedFn, wrapper, ...expectedArgs)
-
-    // decorator is not called before decorated called
-    assert.strictEqual(calls, 0)
-
-    const o1 = {}
-    const o2 = {}
-
-    assert.strictEqual(wrapped.call(o1), 1)
-
-    // the same decorated function is returned for the same instance
-    assert.strictEqual(wrapped.call(o1), 1)
-
-    // a new decorated function is returned for another instance
-    assert.strictEqual(wrapped.call(o2), 2)
-  })
-})

@vates/decorate-with/package.json

@@ -20,15 +20,11 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "2.0.0",
+  "version": "0.1.0",
   "engines": {
     "node": ">=8.10"
   },
   "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "tap"
-  },
-  "devDependencies": {
-    "tap": "^16.0.1"
+    "postversion": "npm publish --access public"
   }
 }

@vates/disposable/debounceResource.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { asyncMap } = require('@xen-orchestra/async-map')
 const { createLogger } = require('@xen-orchestra/log')
 

@vates/disposable/debounceResource.spec.js

@@ -1,5 +1,3 @@
-'use strict'
-
 /* eslint-env jest */
 
 const { createDebounceResource } = require('./debounceResource')

@vates/disposable/deduped.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const ensureArray = require('ensure-array')
 const { MultiKeyMap } = require('@vates/multi-key-map')
 

@vates/disposable/deduped.spec.js

@@ -1,5 +1,3 @@
-'use strict'
-
 /* eslint-env jest */
 
 const { deduped } = require('./deduped')

@vates/event-listeners-manager/.USAGE.md

@@ -1,50 +0,0 @@
-> This library is compatible with Node's `EventEmitter` and web browsers' `EventTarget` APIs.
-
-### API
-
-```js
-import { EventListenersManager } from '@vates/event-listeners-manager'
-
-const events = new EventListenersManager(emitter)
-
-// adding listeners
-events.add('foo', onFoo).add('bar', onBar).on('baz', onBaz)
-
-// removing a specific listener
-events.remove('foo', onFoo)
-
-// removing all listeners for a specific event
-events.removeAll('foo')
-
-// removing all listeners
-events.removeAll()
-```
-
-### Typical use case
-
-> Removing all listeners when no longer necessary.
-
-Manually:
-
-```js
-const onFoo = () => {}
-const onBar = () => {}
-const onBaz = () => {}
-emitter.on('foo', onFoo).on('bar', onBar).on('baz', onBaz)
-
-// CODE LOGIC
-
-emitter.off('foo', onFoo).off('bar', onBar).off('baz', onBaz)
-```
-
-With this library:
-
-```js
-const events = new EventListenersManager(emitter)
-
-events.add('foo', () => {})).add('bar', () => {})).add('baz', () => {}))
-
-// CODE LOGIC
-
-events.removeAll()
-```

@vates/event-listeners-manager/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/event-listeners-manager/README.md

@@ -1,81 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/event-listeners-manager
-
-[![Package Version](https://badgen.net/npm/v/@vates/event-listeners-manager)](https://npmjs.org/package/@vates/event-listeners-manager) ![License](https://badgen.net/npm/license/@vates/event-listeners-manager) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/event-listeners-manager)](https://bundlephobia.com/result?p=@vates/event-listeners-manager) [![Node compatibility](https://badgen.net/npm/node/@vates/event-listeners-manager)](https://npmjs.org/package/@vates/event-listeners-manager)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/event-listeners-manager):
-
-```
-> npm install --save @vates/event-listeners-manager
-```
-
-## Usage
-
-> This library is compatible with Node's `EventEmitter` and web browsers' `EventTarget` APIs.
-
-### API
-
-```js
-import { EventListenersManager } from '@vates/event-listeners-manager'
-
-const events = new EventListenersManager(emitter)
-
-// adding listeners
-events.add('foo', onFoo).add('bar', onBar).on('baz', onBaz)
-
-// removing a specific listener
-events.remove('foo', onFoo)
-
-// removing all listeners for a specific event
-events.removeAll('foo')
-
-// removing all listeners
-events.removeAll()
-```
-
-### Typical use case
-
-> Removing all listeners when no longer necessary.
-
-Manually:
-
-```js
-const onFoo = () => {}
-const onBar = () => {}
-const onBaz = () => {}
-emitter.on('foo', onFoo).on('bar', onBar).on('baz', onBaz)
-
-// CODE LOGIC
-
-emitter.off('foo', onFoo).off('bar', onBar).off('baz', onBaz)
-```
-
-With this library:
-
-```js
-const events = new EventListenersManager(emitter)
-
-events.add('foo', () => {})).add('bar', () => {})).add('baz', () => {}))
-
-// CODE LOGIC
-
-events.removeAll()
-```
-
-## 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](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/event-listeners-manager/index.js

@@ -1,56 +0,0 @@
-'use strict'
-
-exports.EventListenersManager = class EventListenersManager {
-  constructor(emitter) {
-    this._listeners = new Map()
-
-    this._add = (emitter.addListener || emitter.addEventListener).bind(emitter)
-    this._remove = (emitter.removeListener || emitter.removeEventListener).bind(emitter)
-  }
-
-  add(type, listener) {
-    let listeners = this._listeners[type]
-    if (listeners === undefined) {
-      listeners = new Set()
-      this._listeners.set(type, listeners)
-    }
-
-    // don't add the same listener multiple times (allowed on Node.js)
-    if (!listeners.has(listener)) {
-      listeners.add(listener)
-      this._add(type, listener)
-    }
-
-    return this
-  }
-
-  remove(type, listener) {
-    const allListeners = this._listeners
-    const listeners = allListeners.get(type)
-    if (listeners !== undefined && listeners.delete(listener)) {
-      this._remove(type, listener)
-      if (listeners.size === 0) {
-        allListeners.delete(type)
-      }
-    }
-
-    return this
-  }
-
-  removeAll(type) {
-    const allListeners = this._listeners
-    const remove = this._remove
-    const types = type !== undefined ? [type] : allListeners.keys()
-    for (const type of types) {
-      const listeners = allListeners.get(type)
-      if (listeners !== undefined) {
-        allListeners.delete(type)
-        for (const listener of listeners) {
-          remove(type, listener)
-        }
-      }
-    }
-
-    return this
-  }
-}

@vates/event-listeners-manager/package.json

@@ -1,42 +0,0 @@
-{
-  "engines": {
-    "node": ">=6"
-  },
-  "private": false,
-  "name": "@vates/event-listeners-manager",
-  "descriptions": "Easy way to clean up event listeners",
-  "keywords": [
-    "add",
-    "addEventListener",
-    "addListener",
-    "browser",
-    "clear",
-    "DOM",
-    "emitter",
-    "event",
-    "EventEmitter",
-    "EventTarget",
-    "management",
-    "manager",
-    "node",
-    "remove",
-    "removeEventListener",
-    "removeListener"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/event-listeners-manager",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/event-listeners-manager",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.0",
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/multi-key-map/index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 class Node {
   constructor(value) {
     this.children = new Map()

@vates/multi-key-map/index.spec.js

@@ -1,5 +1,3 @@
-'use strict'
-
 /* eslint-env jest */
 
 const { MultiKeyMap } = require('./')

@vates/parse-duration/index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const ms = require('ms')
 
 exports.parseDuration = value => {

@vates/predicates/.USAGE.md

@@ -1,57 +0,0 @@
-`undefined` predicates are ignored and `undefined` is returned if all predicates are `undefined`, this permits the most efficient composition:
-
-```js
-const compositePredicate = every(undefined, some(predicate2, undefined))
-
-// ends up as
-
-const compositePredicate = predicate2
-```
-
-Predicates can also be passed wrapped in an array:
-
-```js
-const compositePredicate = every([predicate1, some([predicate2, predicate3])])
-```
-
-`this` and all arguments are passed to the nested predicates.
-
-### `every(predicates)`
-
-> Returns a predicate that returns `true` iff every predicate returns `true`.
-
-```js
-const isBetween3And7 = every(
-  n => n >= 3,
-  n => n <= 7
-)
-
-isBetween3And10(0)
-// → false
-
-isBetween3And10(5)
-// → true
-
-isBetween3And10(10)
-// → false
-```
-
-### `some(predicates)`
-
-> Returns a predicate that returns `true` iff some predicate returns `true`.
-
-```js
-const isAliceOrBob = some(
-  name => name === 'Alice',
-  name => name === 'Bob'
-)
-
-isAliceOrBob('Alice')
-// → true
-
-isAliceOrBob('Bob')
-// → true
-
-isAliceOrBob('Oscar')
-// → false
-```

@vates/predicates/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/predicates/README.md

@@ -1,90 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/predicates
-
-[![Package Version](https://badgen.net/npm/v/@vates/predicates)](https://npmjs.org/package/@vates/predicates) ![License](https://badgen.net/npm/license/@vates/predicates) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/predicates)](https://bundlephobia.com/result?p=@vates/predicates) [![Node compatibility](https://badgen.net/npm/node/@vates/predicates)](https://npmjs.org/package/@vates/predicates)
-
-> Utilities to compose predicates
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/predicates):
-
-```
-> npm install --save @vates/predicates
-```
-
-## Usage
-
-`undefined` predicates are ignored and `undefined` is returned if all predicates are `undefined`, this permits the most efficient composition:
-
-```js
-const compositePredicate = every(undefined, some(predicate2, undefined))
-
-// ends up as
-
-const compositePredicate = predicate2
-```
-
-Predicates can also be passed wrapped in an array:
-
-```js
-const compositePredicate = every([predicate1, some([predicate2, predicate3])])
-```
-
-`this` and all arguments are passed to the nested predicates.
-
-### `every(predicates)`
-
-> Returns a predicate that returns `true` iff every predicate returns `true`.
-
-```js
-const isBetween3And7 = every(
-  n => n >= 3,
-  n => n <= 7
-)
-
-isBetween3And10(0)
-// → false
-
-isBetween3And10(5)
-// → true
-
-isBetween3And10(10)
-// → false
-```
-
-### `some(predicates)`
-
-> Returns a predicate that returns `true` iff some predicate returns `true`.
-
-```js
-const isAliceOrBob = some(
-  name => name === 'Alice',
-  name => name === 'Bob'
-)
-
-isAliceOrBob('Alice')
-// → true
-
-isAliceOrBob('Bob')
-// → true
-
-isAliceOrBob('Oscar')
-// → false
-```
-
-## 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](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/predicates/index.js

@@ -1,71 +0,0 @@
-'use strict'
-
-const {
-  isArray,
-  prototype: { filter },
-} = Array
-
-class InvalidPredicate extends TypeError {
-  constructor(value) {
-    super('not a valid predicate')
-    this.value = value
-  }
-}
-
-function isDefinedPredicate(value) {
-  if (value === undefined) {
-    return false
-  }
-
-  if (typeof value !== 'function') {
-    throw new InvalidPredicate(value)
-  }
-
-  return true
-}
-
-function handleArgs() {
-  let predicates
-  if (!(arguments.length === 1 && isArray((predicates = arguments[0])))) {
-    predicates = arguments
-  }
-  return filter.call(predicates, isDefinedPredicate)
-}
-
-exports.every = function every() {
-  const predicates = handleArgs.apply(this, arguments)
-  const n = predicates.length
-  if (n === 0) {
-    return
-  }
-  if (n === 1) {
-    return predicates[0]
-  }
-  return function everyPredicate() {
-    for (let i = 0; i < n; ++i) {
-      if (!predicates[i].apply(this, arguments)) {
-        return false
-      }
-    }
-    return true
-  }
-}
-
-exports.some = function some() {
-  const predicates = handleArgs.apply(this, arguments)
-  const n = predicates.length
-  if (n === 0) {
-    return
-  }
-  if (n === 1) {
-    return predicates[0]
-  }
-  return function somePredicate() {
-    for (let i = 0; i < n; ++i) {
-      if (predicates[i].apply(this, arguments)) {
-        return true
-      }
-    }
-    return false
-  }
-}

@vates/predicates/index.spec.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const assert = require('assert/strict')
-const { describe, it } = require('tap').mocha
-
-const { every, some } = require('./')
-
-const T = () => true
-const F = () => false
-
-const testArgsHandling = fn => {
-  it('returns undefined if all predicates are undefined', () => {
-    assert.equal(fn(undefined), undefined)
-    assert.equal(fn([undefined]), undefined)
-  })
-
-  it('returns the predicate if only a single one is passed', () => {
-    assert.equal(fn(undefined, T), T)
-    assert.equal(fn([undefined, T]), T)
-  })
-
-  it('throws if it receives a non-predicate', () => {
-    const error = new TypeError('not a valid predicate')
-    error.value = 3
-    assert.throws(() => fn(3), error)
-  })
-
-  it('forwards this and arguments to predicates', () => {
-    const thisArg = 'qux'
-    const args = ['foo', 'bar', 'baz']
-    const predicate = function () {
-      assert.equal(this, thisArg)
-      assert.deepEqual(Array.from(arguments), args)
-    }
-    fn(predicate, predicate).apply(thisArg, args)
-  })
-}
-
-const runTests = (fn, truthTable) =>
-  it('works', () => {
-    truthTable.forEach(([result, ...predicates]) => {
-      assert.equal(fn(...predicates)(), result)
-      assert.equal(fn(predicates)(), result)
-    })
-  })
-
-describe('every', () => {
-  testArgsHandling(every)
-  runTests(every, [
-    [true, T, T],
-    [false, T, F],
-    [false, F, T],
-    [false, F, F],
-  ])
-})
-
-describe('some', () => {
-  testArgsHandling(some)
-  runTests(some, [
-    [true, T, T],
-    [true, T, F],
-    [true, F, T],
-    [false, F, F],
-  ])
-})

@vates/predicates/package.json

@@ -1,40 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/predicates",
-  "description": "Utilities to compose predicates",
-  "keywords": [
-    "and",
-    "combine",
-    "compose",
-    "every",
-    "function",
-    "functions",
-    "or",
-    "predicate",
-    "predicates",
-    "some"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/predicates",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/predicates",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.0",
-  "engines": {
-    "node": ">=6"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "tap"
-  },
-  "devDependencies": {
-    "tap": "^16.0.1"
-  }
-}

@vates/read-chunk/index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const readChunk = (stream, size) =>
   size === 0
     ? Promise.resolve(Buffer.alloc(0))

@vates/read-chunk/index.spec.js

@@ -1,5 +1,3 @@
-'use strict'
-
 /* eslint-env jest */
 
 const { Readable } = require('stream')

@vates/toggle-scripts/index.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 
-'use strict'
-
 const fs = require('fs')
 
 const mapKeys = (object, iteratee) => {

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

@@ -1,5 +1,3 @@
-'use strict'
-
 const wrapCall = (fn, arg, thisArg) => {
   try {
     return Promise.resolve(fn.call(thisArg, arg))

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

@@ -1,5 +1,3 @@
-'use strict'
-
 /* eslint-env jest */
 
 const { asyncMapSettled } = require('./')

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

@@ -1,5 +1,3 @@
-'use strict'
-
 // type MaybePromise<T> = Promise<T> | T
 //
 // declare export function asyncMap<T1, T2>(

@xen-orchestra/audit-core/.babelrc.js

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

@xen-orchestra/audit-core/package.json

@@ -9,14 +9,28 @@
   },
   "version": "0.2.0",
   "engines": {
-    "node": ">=14"
+    "node": ">=10"
   },
+  "main": "dist/",
   "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/",
     "postversion": "npm publish --access public",
-    "test": "tap --lines 67 --functions 92 --branches 52 --statements 67"
+    "prebuild": "rimraf dist/",
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.7.4",
+    "@babel/core": "^7.7.4",
+    "@babel/plugin-proposal-decorators": "^7.8.0",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.8.0",
+    "@babel/preset-env": "^7.7.4",
+    "cross-env": "^7.0.2",
+    "rimraf": "^3.0.0"
   },
   "dependencies": {
-    "@vates/decorate-with": "^2.0.0",
+    "@vates/decorate-with": "^0.1.0",
     "@xen-orchestra/log": "^0.3.0",
     "golike-defer": "^0.5.1",
     "object-hash": "^2.0.1"
@@ -26,8 +40,5 @@
   "author": {
     "name": "Vates SAS",
     "url": "https://vates.fr"
-  },
-  "devDependencies": {
-    "tap": "^16.0.1"
   }
 }

@xen-orchestra/audit-core/src/index.js

@@ -1,14 +1,12 @@
-'use strict'
-
-const assert = require('assert')
-const hash = require('object-hash')
-const { createLogger } = require('@xen-orchestra/log')
-const { decorateClass } = require('@vates/decorate-with')
-const { defer } = require('golike-defer')
+import assert from 'assert'
+import hash from 'object-hash'
+import { createLogger } from '@xen-orchestra/log'
+import { decorateWith } from '@vates/decorate-with'
+import { defer } from 'golike-defer'
 
 const log = createLogger('xo:audit-core')
 
-exports.Storage = class Storage {
+export class Storage {
   constructor() {
     this._lock = Promise.resolve()
   }
@@ -31,7 +29,7 @@ const ID_TO_ALGORITHM = {
   5: 'sha256',
 }
 
-class AlteredRecordError extends Error {
+export class AlteredRecordError extends Error {
   constructor(id, nValid, record) {
     super('altered record')
 
@@ -40,9 +38,8 @@ class AlteredRecordError extends Error {
     this.record = record
   }
 }
-exports.AlteredRecordError = AlteredRecordError
 
-class MissingRecordError extends Error {
+export class MissingRecordError extends Error {
   constructor(id, nValid) {
     super('missing record')
 
@@ -50,10 +47,8 @@ class MissingRecordError extends Error {
     this.nValid = nValid
   }
 }
-exports.MissingRecordError = MissingRecordError
 
-const NULL_ID = 'nullId'
-exports.NULL_ID = NULL_ID
+export const NULL_ID = 'nullId'
 
 const HASH_ALGORITHM_ID = '5'
 const createHash = (data, algorithmId = HASH_ALGORITHM_ID) =>
@@ -62,12 +57,13 @@ const createHash = (data, algorithmId = HASH_ALGORITHM_ID) =>
     excludeKeys: key => key === 'id',
   })}`
 
-class AuditCore {
+export class AuditCore {
   constructor(storage) {
     assert.notStrictEqual(storage, undefined)
     this._storage = storage
   }
 
+  @decorateWith(defer)
   async add($defer, subject, event, data) {
     const time = Date.now()
     $defer(await this._storage.acquireLock())
@@ -152,6 +148,7 @@ class AuditCore {
     }
   }
 
+  @decorateWith(defer)
   async deleteRangeAndRewrite($defer, newest, oldest) {
     assert.notStrictEqual(newest, undefined)
     assert.notStrictEqual(oldest, undefined)
@@ -192,9 +189,3 @@ class AuditCore {
     }
   }
 }
-exports.AuditCore = AuditCore
-
-decorateClass(AuditCore, {
-  add: defer,
-  deleteRangeAndRewrite: defer,
-})

@xen-orchestra/audit-core/src/index.spec.js

@@ -1,9 +1,6 @@
-'use strict'
+/* eslint-env jest */
 
-const assert = require('assert/strict')
-const { afterEach, describe, it } = require('tap').mocha
-
-const { AlteredRecordError, AuditCore, MissingRecordError, NULL_ID, Storage } = require('.')
+import { AlteredRecordError, AuditCore, MissingRecordError, NULL_ID, Storage } from '.'
 
 const asyncIteratorToArray = async asyncIterator => {
   const array = []
@@ -75,7 +72,7 @@ const auditCore = new AuditCore(db)
 const storeAuditRecords = async () => {
   await Promise.all(DATA.map(data => auditCore.add(...data)))
   const records = await asyncIteratorToArray(auditCore.getFrom())
-  assert.equal(records.length, DATA.length)
+  expect(records.length).toBe(DATA.length)
   return records
 }
 
@@ -86,11 +83,10 @@ describe('auditCore', () => {
     const [newestRecord, deletedRecord] = await storeAuditRecords()
 
     const nValidRecords = await auditCore.checkIntegrity(NULL_ID, newestRecord.id)
-    assert.equal(nValidRecords, DATA.length)
+    expect(nValidRecords).toBe(DATA.length)
 
     await db.del(deletedRecord.id)
-    await assert.rejects(
-      auditCore.checkIntegrity(NULL_ID, newestRecord.id),
+    await expect(auditCore.checkIntegrity(NULL_ID, newestRecord.id)).rejects.toEqual(
       new MissingRecordError(deletedRecord.id, 1)
     )
   })
@@ -101,8 +97,7 @@ describe('auditCore', () => {
     alteredRecord.event = ''
     await db.put(alteredRecord)
 
-    await assert.rejects(
-      auditCore.checkIntegrity(NULL_ID, newestRecord.id),
+    await expect(auditCore.checkIntegrity(NULL_ID, newestRecord.id)).rejects.toEqual(
       new AlteredRecordError(alteredRecord.id, 1, alteredRecord)
     )
   })
@@ -112,8 +107,8 @@ describe('auditCore', () => {
 
     await auditCore.deleteFrom(secondRecord.id)
 
-    assert.equal(await db.get(firstRecord.id), undefined)
-    assert.equal(await db.get(secondRecord.id), undefined)
+    expect(await db.get(firstRecord.id)).toBe(undefined)
+    expect(await db.get(secondRecord.id)).toBe(undefined)
 
     await auditCore.checkIntegrity(secondRecord.id, thirdRecord.id)
   })

@xen-orchestra/babel-config/package.json

@@ -10,7 +10,7 @@
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
   "engines": {
-    "node": ">=8.3"
+    "node": ">=6"
   },
   "license": "AGPL-3.0-or-later",
   "author": {

@xen-orchestra/backups-cli/_composeCommands.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const getopts = require('getopts')
 
 const { version } = require('./package.json')

@xen-orchestra/backups-cli/_fs.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { dirname } = require('path')
 
 const fs = require('promise-toolbox/promisifyAll')(require('fs'))

@xen-orchestra/backups-cli/commands/clean-vms.js

@@ -1,4 +1,4 @@
-'use strict'
+#!/usr/bin/env node
 
 // -----------------------------------------------------------------------------
 

@xen-orchestra/backups-cli/commands/create-symlink-index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const filenamify = require('filenamify')
 const get = require('lodash/get')
 const { asyncMap } = require('@xen-orchestra/async-map')

@xen-orchestra/backups-cli/commands/info.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const groupBy = require('lodash/groupBy')
 const { asyncMap } = require('@xen-orchestra/async-map')
 const { createHash } = require('crypto')

@xen-orchestra/backups-cli/index.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 
-'use strict'
-
 require('./_composeCommands')({
   'clean-vms': {
     get main() {

@xen-orchestra/backups-cli/package.json

@@ -7,12 +7,12 @@
   "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
   "dependencies": {
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/backups": "^0.22.0",
-    "@xen-orchestra/fs": "^1.0.1",
+    "@xen-orchestra/backups": "^0.15.1",
+    "@xen-orchestra/fs": "^0.18.0",
     "filenamify": "^4.1.0",
     "getopts": "^2.2.5",
     "lodash": "^4.17.15",
-    "promise-toolbox": "^0.21.0"
+    "promise-toolbox": "^0.20.0"
   },
   "engines": {
     "node": ">=7.10.1"
@@ -27,7 +27,7 @@
   "scripts": {
     "postversion": "npm publish --access public"
   },
-  "version": "0.7.1",
+  "version": "0.6.0",
   "license": "AGPL-3.0-or-later",
   "author": {
     "name": "Vates SAS",

@xen-orchestra/backups/Backup.js

@@ -1,8 +1,6 @@
-'use strict'
-
 const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
-const Disposable = require('promise-toolbox/Disposable')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
+const Disposable = require('promise-toolbox/Disposable.js')
+const ignoreErrors = require('promise-toolbox/ignoreErrors.js')
 const { compileTemplate } = require('@xen-orchestra/template')
 const { limitConcurrency } = require('limit-concurrency-decorator')
 

@xen-orchestra/backups/DurablePartition.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { asyncMap } = require('@xen-orchestra/async-map')
 
 exports.DurablePartition = class DurablePartition {

@xen-orchestra/backups/ImportVmBackup.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const assert = require('assert')
 
 const { formatFilenameDate } = require('./_filenameDate.js')
@@ -8,9 +6,9 @@ const { Task } = require('./Task.js')
 const { watchStreamSize } = require('./_watchStreamSize.js')
 
 exports.ImportVmBackup = class ImportVmBackup {
-  constructor({ adapter, metadata, srUuid, xapi, settings: { newMacAddresses, mapVdisSrs = {} } = {} }) {
+  constructor({ adapter, metadata, srUuid, xapi, settings: { newMacAddresses } = {} }) {
     this._adapter = adapter
-    this._importDeltaVmSettings = { newMacAddresses, mapVdisSrs }
+    this._importDeltaVmSettings = { newMacAddresses }
     this._metadata = metadata
     this._srUuid = srUuid
     this._xapi = xapi
@@ -30,12 +28,7 @@ exports.ImportVmBackup = class ImportVmBackup {
     } else {
       assert.strictEqual(metadata.mode, 'delta')
 
-      const ignoredVdis = new Set(
-        Object.entries(this._importDeltaVmSettings.mapVdisSrs)
-          .filter(([_, srUuid]) => srUuid === null)
-          .map(([vdiUuid]) => vdiUuid)
-      )
-      backup = await adapter.readDeltaVmBackup(metadata, ignoredVdis)
+      backup = await adapter.readDeltaVmBackup(metadata)
       Object.values(backup.streams).forEach(stream => watchStreamSize(stream, sizeContainer))
     }
 

@xen-orchestra/backups/RemoteAdapter.js

@@ -1,27 +1,21 @@
-'use strict'
-
 const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
-const Disposable = require('promise-toolbox/Disposable')
-const fromCallback = require('promise-toolbox/fromCallback')
-const fromEvent = require('promise-toolbox/fromEvent')
-const pDefer = require('promise-toolbox/defer')
-const groupBy = require('lodash/groupBy.js')
-const pickBy = require('lodash/pickBy.js')
-const { dirname, join, normalize, resolve } = require('path')
+const Disposable = require('promise-toolbox/Disposable.js')
+const fromCallback = require('promise-toolbox/fromCallback.js')
+const fromEvent = require('promise-toolbox/fromEvent.js')
+const pDefer = require('promise-toolbox/defer.js')
+const pump = require('pump')
+const { basename, dirname, join, normalize, resolve } = require('path')
 const { createLogger } = require('@xen-orchestra/log')
-const { Constants, createVhdDirectoryFromStream, openVhd, VhdAbstract, VhdDirectory, VhdSynthetic } = require('vhd-lib')
+const { createSyntheticStream, mergeVhd, VhdFile } = require('vhd-lib')
 const { deduped } = require('@vates/disposable/deduped.js')
-const { decorateMethodsWith } = require('@vates/decorate-with')
-const { compose } = require('@vates/compose')
 const { execFile } = require('child_process')
 const { readdir, stat } = require('fs-extra')
-const { v4: uuidv4 } = require('uuid')
 const { ZipFile } = require('yazl')
 
 const { BACKUP_DIR } = require('./_getVmBackupDir.js')
 const { cleanVm } = require('./_cleanVm.js')
 const { getTmpDir } = require('./_getTmpDir.js')
-const { isMetadataFile } = require('./_backupType.js')
+const { isMetadataFile, isVhdFile } = require('./_backupType.js')
 const { isValidXva } = require('./_isValidXva.js')
 const { listPartitions, LVM_PARTITION_TYPE } = require('./_listPartitions.js')
 const { lvs, pvs } = require('./_lvm.js')
@@ -32,7 +26,7 @@ exports.DIR_XO_CONFIG_BACKUPS = DIR_XO_CONFIG_BACKUPS
 const DIR_XO_POOL_METADATA_BACKUPS = 'xo-pool-metadata-backups'
 exports.DIR_XO_POOL_METADATA_BACKUPS = DIR_XO_POOL_METADATA_BACKUPS
 
-const { debug, warn } = createLogger('xo:backups:RemoteAdapter')
+const { warn } = createLogger('xo:backups:RemoteAdapter')
 
 const compareTimestamp = (a, b) => a.timestamp - b.timestamp
 
@@ -73,17 +67,58 @@ const debounceResourceFactory = factory =>
   }
 
 class RemoteAdapter {
-  constructor(handler, { debounceResource = res => res, dirMode, vhdDirectoryCompression } = {}) {
+  constructor(handler, { debounceResource = res => res, dirMode } = {}) {
     this._debounceResource = debounceResource
     this._dirMode = dirMode
     this._handler = handler
-    this._vhdDirectoryCompression = vhdDirectoryCompression
   }
 
   get handler() {
     return this._handler
   }
 
+  async _deleteVhd(path) {
+    const handler = this._handler
+    const vhds = await asyncMapSettled(
+      await handler.list(dirname(path), {
+        filter: isVhdFile,
+        prependDir: true,
+      }),
+      async path => {
+        try {
+          const vhd = new VhdFile(handler, path)
+          await vhd.readHeaderAndFooter()
+          return {
+            footer: vhd.footer,
+            header: vhd.header,
+            path,
+          }
+        } catch (error) {
+          // Do not fail on corrupted VHDs (usually uncleaned temporary files),
+          // they are probably inconsequent to the backup process and should not
+          // fail it.
+          warn(`BackupNg#_deleteVhd ${path}`, { error })
+        }
+      }
+    )
+    const base = basename(path)
+    const child = vhds.find(_ => _ !== undefined && _.header.parentUnicodeName === base)
+    if (child === undefined) {
+      await handler.unlink(path)
+      return 0
+    }
+
+    try {
+      const childPath = child.path
+      const mergedDataSize = await mergeVhd(handler, path, handler, childPath)
+      await handler.rename(path, childPath)
+      return mergedDataSize
+    } catch (error) {
+      handler.unlink(path).catch(warn)
+      throw error
+    }
+  }
+
   async _findPartition(devicePath, partitionId) {
     const partitions = await listPartitions(devicePath)
     const partition = partitions.find(_ => _.id === partitionId)
@@ -93,6 +128,9 @@ class RemoteAdapter {
     return partition
   }
 
+  _getLvmLogicalVolumes = Disposable.factory(this._getLvmLogicalVolumes)
+  _getLvmLogicalVolumes = deduped(this._getLvmLogicalVolumes, (devicePath, pvId, vgName) => [devicePath, pvId, vgName])
+  _getLvmLogicalVolumes = debounceResourceFactory(this._getLvmLogicalVolumes)
   async *_getLvmLogicalVolumes(devicePath, pvId, vgName) {
     yield this._getLvmPhysicalVolume(devicePath, pvId && (await this._findPartition(devicePath, pvId)))
 
@@ -104,6 +142,9 @@ class RemoteAdapter {
     }
   }
 
+  _getLvmPhysicalVolume = Disposable.factory(this._getLvmPhysicalVolume)
+  _getLvmPhysicalVolume = deduped(this._getLvmPhysicalVolume, (devicePath, partition) => [devicePath, partition?.id])
+  _getLvmPhysicalVolume = debounceResourceFactory(this._getLvmPhysicalVolume)
   async *_getLvmPhysicalVolume(devicePath, partition) {
     const args = []
     if (partition !== undefined) {
@@ -124,6 +165,9 @@ class RemoteAdapter {
     }
   }
 
+  _getPartition = Disposable.factory(this._getPartition)
+  _getPartition = deduped(this._getPartition, (devicePath, partition) => [devicePath, partition?.id])
+  _getPartition = debounceResourceFactory(this._getPartition)
   async *_getPartition(devicePath, partition) {
     const options = ['loop', 'ro']
 
@@ -176,6 +220,7 @@ class RemoteAdapter {
     })
   }
 
+  _usePartitionFiles = Disposable.factory(this._usePartitionFiles)
   async *_usePartitionFiles(diskId, partitionId, paths) {
     const path = yield this.getPartition(diskId, partitionId)
 
@@ -187,22 +232,6 @@ class RemoteAdapter {
     return files
   }
 
-  // check if we will be allowed to merge a a vhd created in this adapter
-  // with the vhd at path `path`
-  async isMergeableParent(packedParentUid, path) {
-    return await Disposable.use(openVhd(this.handler, path), vhd => {
-      // this baseUuid is not linked with this vhd
-      if (!vhd.footer.uuid.equals(packedParentUid)) {
-        return false
-      }
-
-      const isVhdDirectory = vhd instanceof VhdDirectory
-      return isVhdDirectory
-        ? this.#useVhdDirectory() && this.#getCompressionType() === vhd.compressionType
-        : !this.#useVhdDirectory()
-    })
-  }
-
   fetchPartitionFiles(diskId, partitionId, paths) {
     const { promise, reject, resolve } = pDefer()
     Disposable.use(
@@ -224,8 +253,8 @@ class RemoteAdapter {
 
   async deleteDeltaVmBackups(backups) {
     const handler = this._handler
-    debug(`deleteDeltaVmBackups will delete ${backups.length} delta backups`, { backups })
-    // this will delete the json, unused VHDs will be detected by `cleanVm`
+
+    // unused VHDs will be detected by `cleanVm`
     await asyncMapSettled(backups, ({ _filename }) => handler.unlink(_filename))
   }
 
@@ -256,42 +285,22 @@ class RemoteAdapter {
     )
   }
 
-  deleteVmBackup(file) {
-    return this.deleteVmBackups([file])
-  }
+  async deleteVmBackup(filename) {
+    const metadata = JSON.parse(String(await this._handler.readFile(filename)))
+    metadata._filename = filename
 
-  async deleteVmBackups(files) {
-    const { delta, full, ...others } = groupBy(await asyncMap(files, file => this.readVmBackupMetadata(file)), 'mode')
-
-    const unsupportedModes = Object.keys(others)
-    if (unsupportedModes.length !== 0) {
-      throw new Error('no deleter for backup modes: ' + unsupportedModes.join(', '))
-    }
-
-    await Promise.all([
-      delta !== undefined && this.deleteDeltaVmBackups(delta),
-      full !== undefined && this.deleteFullVmBackups(full),
-    ])
-
-    const dirs = new Set(files.map(file => dirname(file)))
-    for (const dir of dirs) {
-      // don't merge in main process, unused VHDs will be merged in the next backup run
-      await this.cleanVm(dir, { remove: true, onLog: warn })
+    if (metadata.mode === 'delta') {
+      await this.deleteDeltaVmBackups([metadata])
+    } else if (metadata.mode === 'full') {
+      await this.deleteFullVmBackups([metadata])
+    } else {
+      throw new Error(`no deleter for backup mode ${metadata.mode}`)
     }
   }
 
-  #getCompressionType() {
-    return this._vhdDirectoryCompression
-  }
-
-  #useVhdDirectory() {
-    return this.handler.type === 's3'
-  }
-
-  #useAlias() {
-    return this.#useVhdDirectory()
-  }
-
+  getDisk = Disposable.factory(this.getDisk)
+  getDisk = deduped(this.getDisk, diskId => [diskId])
+  getDisk = debounceResourceFactory(this.getDisk)
   async *getDisk(diskId) {
     const handler = this._handler
 
@@ -328,6 +337,7 @@ class RemoteAdapter {
   // - `<partitionId>`: partitioned disk
   // - `<pvId>/<vgName>/<lvName>`: LVM on a partitioned disk
   // - `/<vgName>/lvName>`: LVM on a raw disk
+  getPartition = Disposable.factory(this.getPartition)
   async *getPartition(diskId, partitionId) {
     const devicePath = yield this.getDisk(diskId)
     if (partitionId === undefined) {
@@ -344,26 +354,13 @@ class RemoteAdapter {
     return yield this._getPartition(devicePath, await this._findPartition(devicePath, partitionId))
   }
 
-  // if we use alias on this remote, we have to name the file alias.vhd
-  getVhdFileName(baseName) {
-    if (this.#useAlias()) {
-      return `${baseName}.alias.vhd`
-    }
-    return `${baseName}.vhd`
-  }
-
   async listAllVmBackups() {
     const handler = this._handler
 
     const backups = { __proto__: null }
-    await asyncMap(await handler.list(BACKUP_DIR), async entry => {
-      // ignore hidden and lock files
-      if (entry[0] !== '.' && !entry.endsWith('.lock')) {
-        const vmBackups = await this.listVmBackups(entry)
-        if (vmBackups.length !== 0) {
-          backups[entry] = vmBackups
-        }
-      }
+    await asyncMap(await handler.list(BACKUP_DIR), async vmUuid => {
+      const vmBackups = await this.listVmBackups(vmUuid)
+      backups[vmUuid] = vmBackups
     })
 
     return backups
@@ -501,25 +498,6 @@ class RemoteAdapter {
     return backups.sort(compareTimestamp)
   }
 
-  async writeVhd(path, input, { checksum = true, validator = noop } = {}) {
-    const handler = this._handler
-
-    if (this.#useVhdDirectory()) {
-      const dataPath = `${dirname(path)}/data/${uuidv4()}.vhd`
-      await createVhdDirectoryFromStream(handler, dataPath, input, {
-        concurrency: 16,
-        compression: this.#getCompressionType(),
-        async validator() {
-          await input.task
-          return validator.apply(this, arguments)
-        },
-      })
-      await VhdAbstract.createAlias(handler, path, dataPath)
-    } else {
-      await this.outputStream(path, input, { checksum, validator })
-    }
-  }
-
   async outputStream(path, input, { checksum = true, validator = noop } = {}) {
     await this._handler.outputStream(path, input, {
       checksum,
@@ -531,61 +509,14 @@ class RemoteAdapter {
     })
   }
 
-  async _createSyntheticStream(handler, paths) {
-    let disposableVhds = []
-
-    // if it's a path : open all hierarchy of parent
-    if (typeof paths === 'string') {
-      let vhd
-      let vhdPath = paths
-      do {
-        const disposable = await openVhd(handler, vhdPath)
-        vhd = disposable.value
-        disposableVhds.push(disposable)
-        vhdPath = resolveRelativeFromFile(vhdPath, vhd.header.parentUnicodeName)
-      } while (vhd.footer.diskType !== Constants.DISK_TYPES.DYNAMIC)
-    } else {
-      // only open the list of path given
-      disposableVhds = paths.map(path => openVhd(handler, path))
-    }
-
-    // I don't want the vhds to be disposed on return
-    // but only when the stream is done ( or failed )
-    const disposables = await Disposable.all(disposableVhds)
-    const vhds = disposables.value
-
-    let disposed = false
-    const disposeOnce = async () => {
-      if (!disposed) {
-        disposed = true
-
-        try {
-          await disposables.dispose()
-        } catch (error) {
-          warn('_createSyntheticStream: failed to dispose VHDs', { error })
-        }
-      }
-    }
-
-    const synthetic = new VhdSynthetic(vhds)
-    await synthetic.readHeaderAndFooter()
-    await synthetic.readBlockAllocationTable()
-    const stream = await synthetic.stream()
-    stream.on('end', disposeOnce)
-    stream.on('close', disposeOnce)
-    stream.on('error', disposeOnce)
-    return stream
-  }
-
-  async readDeltaVmBackup(metadata, ignoredVdis) {
+  async readDeltaVmBackup(metadata) {
     const handler = this._handler
-    const { vbds, vhds, vifs, vm } = metadata
+    const { vbds, vdis, vhds, vifs, vm } = metadata
     const dir = dirname(metadata._filename)
-    const vdis = ignoredVdis === undefined ? metadata.vdis : pickBy(metadata.vdis, vdi => !ignoredVdis.has(vdi.uuid))
 
     const streams = {}
-    await asyncMapSettled(Object.keys(vdis), async ref => {
-      streams[`${ref}.vhd`] = await this._createSyntheticStream(handler, join(dir, vhds[ref]))
+    await asyncMapSettled(Object.keys(vdis), async id => {
+      streams[`${id}.vhd`] = await createSyntheticStream(handler, join(dir, vhds[id]))
     })
 
     return {
@@ -618,30 +549,4 @@ Object.assign(RemoteAdapter.prototype, {
   isValidXva,
 })
 
-decorateMethodsWith(RemoteAdapter, {
-  _getLvmLogicalVolumes: compose([
-    Disposable.factory,
-    [deduped, (devicePath, pvId, vgName) => [devicePath, pvId, vgName]],
-    debounceResourceFactory,
-  ]),
-
-  _getLvmPhysicalVolume: compose([
-    Disposable.factory,
-    [deduped, (devicePath, partition) => [devicePath, partition?.id]],
-    debounceResourceFactory,
-  ]),
-
-  _getPartition: compose([
-    Disposable.factory,
-    [deduped, (devicePath, partition) => [devicePath, partition?.id]],
-    debounceResourceFactory,
-  ]),
-
-  _usePartitionFiles: Disposable.factory,
-
-  getDisk: compose([Disposable.factory, [deduped, diskId => [diskId]], debounceResourceFactory]),
-
-  getPartition: Disposable.factory,
-})
-
 exports.RemoteAdapter = RemoteAdapter

@xen-orchestra/backups/RestoreMetadataBackup.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { DIR_XO_POOL_METADATA_BACKUPS } = require('./RemoteAdapter.js')
 const { PATH_DB_DUMP } = require('./_PoolMetadataBackup.js')
 

@xen-orchestra/backups/Task.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const CancelToken = require('promise-toolbox/CancelToken')
+const CancelToken = require('promise-toolbox/CancelToken.js')
 const Zone = require('node-zone')
 
 const logAfterEnd = () => {
@@ -9,8 +7,6 @@ const logAfterEnd = () => {
 
 const noop = Function.prototype
 
-const serializeErrors = errors => (Array.isArray(errors) ? errors.map(serializeError) : errors)
-
 // Create a serializable object from an error.
 //
 // Otherwise some fields might be non-enumerable and missing from logs.
@@ -19,7 +15,6 @@ const serializeError = error =>
     ? {
         ...error, // Copy enumerable properties.
         code: error.code,
-        errors: serializeErrors(error.errors), // supports AggregateError
         message: error.message,
         name: error.name,
         stack: error.stack,

@xen-orchestra/backups/_PoolMetadataBackup.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { asyncMap } = require('@xen-orchestra/async-map')
 
 const { DIR_XO_POOL_METADATA_BACKUPS } = require('./RemoteAdapter.js')

@xen-orchestra/backups/_VmBackup.js

@@ -1,14 +1,11 @@
-'use strict'
-
 const assert = require('assert')
 const findLast = require('lodash/findLast.js')
 const groupBy = require('lodash/groupBy.js')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
+const ignoreErrors = require('promise-toolbox/ignoreErrors.js')
 const keyBy = require('lodash/keyBy.js')
 const mapValues = require('lodash/mapValues.js')
 const { asyncMap } = require('@xen-orchestra/async-map')
 const { createLogger } = require('@xen-orchestra/log')
-const { decorateMethodsWith } = require('@vates/decorate-with')
 const { defer } = require('golike-defer')
 const { formatDateTime } = require('@xen-orchestra/xapi')
 
@@ -24,13 +21,6 @@ const { watchStreamSize } = require('./_watchStreamSize.js')
 
 const { debug, warn } = createLogger('xo:backups:VmBackup')
 
-class AggregateError extends Error {
-  constructor(errors, message) {
-    super(message)
-    this.errors = errors
-  }
-}
-
 const asyncEach = async (iterable, fn, thisArg = iterable) => {
   for (const item of iterable) {
     await fn.call(thisArg, item)
@@ -44,14 +34,8 @@ const forkDeltaExport = deltaExport =>
     },
   })
 
-class VmBackup {
+exports.VmBackup = class VmBackup {
   constructor({ config, getSnapshotNameLabel, job, remoteAdapters, remotes, schedule, settings, srs, vm }) {
-    if (vm.other_config['xo:backup:job'] === job.id && 'start' in vm.blocked_operations) {
-      // don't match replicated VMs created by this very job otherwise they
-      // will be replicated again and again
-      throw new Error('cannot backup a VM created by this very job')
-    }
-
     this.config = config
     this.job = job
     this.remoteAdapters = remoteAdapters
@@ -135,18 +119,16 @@ class VmBackup {
       return
     }
 
-    const errors = []
     await (parallel ? asyncMap : asyncEach)(writers, async function (writer) {
       try {
         await fn(writer)
       } catch (error) {
-        errors.push(error)
         this.delete(writer)
         warn(warnMessage, { error, writer: writer.constructor.name })
       }
     })
     if (writers.size === 0) {
-      throw new AggregateError(errors, 'all targets have failed, step: ' + warnMessage)
+      throw new Error('all targets have failed, step: ' + warnMessage)
     }
   }
 
@@ -181,7 +163,6 @@ class VmBackup {
         }
 
         const snapshotRef = await vm[settings.checkpointSnapshot ? '$checkpoint' : '$snapshot']({
-          ignoreNobakVdis: true,
           name_label: this._getSnapshotNameLabel(vm),
         })
         this.timestamp = Date.now()
@@ -352,16 +333,13 @@ class VmBackup {
 
     const baseUuidToSrcVdi = new Map()
     await asyncMap(await baseVm.$getDisks(), async baseRef => {
-      const [baseUuid, snapshotOf] = await Promise.all([
-        xapi.getField('VDI', baseRef, 'uuid'),
-        xapi.getField('VDI', baseRef, 'snapshot_of'),
-      ])
+      const snapshotOf = await xapi.getField('VDI', baseRef, 'snapshot_of')
       const srcVdi = srcVdis[snapshotOf]
       if (srcVdi !== undefined) {
-        baseUuidToSrcVdi.set(baseUuid, srcVdi)
+        baseUuidToSrcVdi.set(await xapi.getField('VDI', baseRef, 'uuid'), srcVdi)
       } else {
-        debug('ignore snapshot VDI because no longer present on VM', {
-          vdi: baseUuid,
+        debug('no base VDI found', {
+          vdi: srcVdi.uuid,
         })
       }
     })
@@ -373,11 +351,6 @@ class VmBackup {
       false
     )
 
-    if (presentBaseVdis.size === 0) {
-      debug('no base VM found')
-      return
-    }
-
     const fullVdisRequired = new Set()
     baseUuidToSrcVdi.forEach((srcVdi, baseUuid) => {
       if (presentBaseVdis.has(baseUuid)) {
@@ -398,6 +371,7 @@ class VmBackup {
     this._fullVdisRequired = fullVdisRequired
   }
 
+  run = defer(this.run)
   async run($defer) {
     const settings = this._settings
     assert(
@@ -445,8 +419,3 @@ class VmBackup {
     }
   }
 }
-exports.VmBackup = VmBackup
-
-decorateMethodsWith(VmBackup, {
-  run: defer,
-})

@xen-orchestra/backups/_XoMetadataBackup.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { asyncMap } = require('@xen-orchestra/async-map')
 
 const { DIR_XO_CONFIG_BACKUPS } = require('./RemoteAdapter.js')

@xen-orchestra/backups/_backupType.js

@@ -1,6 +1,4 @@
-'use strict'
-
 exports.isMetadataFile = filename => filename.endsWith('.json')
 exports.isVhdFile = filename => filename.endsWith('.vhd')
 exports.isXvaFile = filename => filename.endsWith('.xva')
-exports.isXvaSumFile = filename => filename.endsWith('.xva.checksum')
+exports.isXvaSumFile = filename => filename.endsWith('.xva.cheksum')

@xen-orchestra/backups/_backupWorker.js

@@ -1,16 +1,11 @@
-'use strict'
-
 require('@xen-orchestra/log/configure.js').catchGlobalErrors(
   require('@xen-orchestra/log').createLogger('xo:backups:worker')
 )
 
-require('@vates/cached-dns.lookup').createCachedLookup().patchGlobal()
-
-const Disposable = require('promise-toolbox/Disposable')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
+const Disposable = require('promise-toolbox/Disposable.js')
+const ignoreErrors = require('promise-toolbox/ignoreErrors.js')
 const { compose } = require('@vates/compose')
 const { createDebounceResource } = require('@vates/disposable/debounceResource.js')
-const { decorateMethodsWith } = require('@vates/decorate-with')
 const { deduped } = require('@vates/disposable/deduped.js')
 const { getHandler } = require('@xen-orchestra/fs')
 const { parseDuration } = require('@vates/parse-duration')
@@ -63,6 +58,11 @@ class BackupWorker {
     }).run()
   }
 
+  getAdapter = Disposable.factory(this.getAdapter)
+  getAdapter = deduped(this.getAdapter, remote => [remote.url])
+  getAdapter = compose(this.getAdapter, function (resource) {
+    return this.debounceResource(resource)
+  })
   async *getAdapter(remote) {
     const handler = getHandler(remote, this.#remoteOptions)
     await handler.sync()
@@ -70,13 +70,17 @@ class BackupWorker {
       yield new RemoteAdapter(handler, {
         debounceResource: this.debounceResource,
         dirMode: this.#config.dirMode,
-        vhdDirectoryCompression: this.#config.vhdDirectoryCompression,
       })
     } finally {
       await handler.forget()
     }
   }
 
+  getXapi = Disposable.factory(this.getXapi)
+  getXapi = deduped(this.getXapi, ({ url }) => [url])
+  getXapi = compose(this.getXapi, function (resource) {
+    return this.debounceResource(resource)
+  })
   async *getXapi({ credentials: { username: user, password }, ...opts }) {
     const xapi = new Xapi({
       ...this.#xapiOptions,
@@ -98,30 +102,6 @@ class BackupWorker {
   }
 }
 
-decorateMethodsWith(BackupWorker, {
-  getAdapter: compose([
-    Disposable.factory,
-    [deduped, remote => [remote.url]],
-    [
-      compose,
-      function (resource) {
-        return this.debounceResource(resource)
-      },
-    ],
-  ]),
-
-  getXapi: compose([
-    Disposable.factory,
-    [deduped, xapi => [xapi.url]],
-    [
-      compose,
-      function (resource) {
-        return this.debounceResource(resource)
-      },
-    ],
-  ]),
-})
-
 // Received message:
 //
 // Message {

@xen-orchestra/backups/_cancelableMap.js

@@ -1,7 +1,5 @@
-'use strict'
-
-const cancelable = require('promise-toolbox/cancelable')
-const CancelToken = require('promise-toolbox/CancelToken')
+const cancelable = require('promise-toolbox/cancelable.js')
+const CancelToken = require('promise-toolbox/CancelToken.js')
 
 // Similar to `Promise.all` + `map` but pass a cancel token to the callback
 //

@xen-orchestra/backups/_cleanVm.integ.spec.js

@@ -1,439 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const rimraf = require('rimraf')
-const tmp = require('tmp')
-const fs = require('fs-extra')
-const { getHandler } = require('@xen-orchestra/fs')
-const { pFromCallback } = require('promise-toolbox')
-const crypto = require('crypto')
-const { RemoteAdapter } = require('./RemoteAdapter')
-const { VHDFOOTER, VHDHEADER } = require('./tests.fixtures.js')
-const { VhdFile, Constants, VhdDirectory, VhdAbstract } = require('vhd-lib')
-const { checkAliases } = require('./_cleanVm')
-const { dirname, basename } = require('path')
-
-let tempDir, adapter, handler, jobId, vdiId, basePath
-
-jest.setTimeout(60000)
-
-beforeEach(async () => {
-  tempDir = await pFromCallback(cb => tmp.dir(cb))
-  handler = getHandler({ url: `file://${tempDir}` })
-  await handler.sync()
-  adapter = new RemoteAdapter(handler)
-  jobId = uniqueId()
-  vdiId = uniqueId()
-  basePath = `vdis/${jobId}/${vdiId}`
-  await fs.mkdirp(`${tempDir}/${basePath}`)
-})
-
-afterEach(async () => {
-  await pFromCallback(cb => rimraf(tempDir, cb))
-  await handler.forget()
-})
-
-const uniqueId = () => crypto.randomBytes(16).toString('hex')
-
-async function generateVhd(path, opts = {}) {
-  let vhd
-
-  let dataPath = path
-  if (opts.useAlias) {
-    await handler.mkdir(dirname(path) + '/data/')
-    dataPath = dirname(path) + '/data/' + basename(path)
-  }
-  if (opts.mode === 'directory') {
-    await handler.mkdir(dataPath)
-    vhd = new VhdDirectory(handler, dataPath)
-  } else {
-    const fd = await handler.openFile(dataPath, 'wx')
-    vhd = new VhdFile(handler, fd)
-  }
-
-  vhd.header = { ...VHDHEADER, ...opts.header }
-  vhd.footer = { ...VHDFOOTER, ...opts.footer }
-  vhd.footer.uuid = Buffer.from(crypto.randomBytes(16))
-
-  if (vhd.header.parentUnicodeName) {
-    vhd.footer.diskType = Constants.DISK_TYPES.DIFFERENCING
-  } else {
-    vhd.footer.diskType = Constants.DISK_TYPES.DYNAMIC
-  }
-
-  if (opts.useAlias === true) {
-    await VhdAbstract.createAlias(handler, path + '.alias.vhd', dataPath)
-  }
-
-  await vhd.writeBlockAllocationTable()
-  await vhd.writeHeader()
-  await vhd.writeFooter()
-  return vhd
-}
-
-test('It remove broken vhd', async () => {
-  // todo also tests a directory and an alias
-
-  await handler.writeFile(`${basePath}/notReallyAVhd.vhd`, 'I AM NOT A VHD')
-  expect((await handler.list(basePath)).length).toEqual(1)
-  let loggued = ''
-  const onLog = message => {
-    loggued += message
-  }
-  await adapter.cleanVm('/', { remove: false, onLog })
-  expect(loggued).toEqual(`error while checking the VHD with path /${basePath}/notReallyAVhd.vhd`)
-  // not removed
-  expect((await handler.list(basePath)).length).toEqual(1)
-  // really remove it
-  await adapter.cleanVm('/', { remove: true, onLog })
-  expect((await handler.list(basePath)).length).toEqual(0)
-})
-
-test('it remove vhd with missing or multiple ancestors', async () => {
-  // one with a broken parent
-  await generateVhd(`${basePath}/abandonned.vhd`, {
-    header: {
-      parentUnicodeName: 'gone.vhd',
-      parentUid: Buffer.from(crypto.randomBytes(16)),
-    },
-  })
-
-  // one orphan, which is a full vhd, no parent
-  const orphan = await generateVhd(`${basePath}/orphan.vhd`)
-  // a child to the orphan
-  await generateVhd(`${basePath}/child.vhd`, {
-    header: {
-      parentUnicodeName: 'orphan.vhd',
-      parentUid: orphan.footer.uuid,
-    },
-  })
-
-  // clean
-  let loggued = ''
-  const onLog = message => {
-    loggued += message + '\n'
-  }
-  await adapter.cleanVm('/', { remove: true, onLog })
-
-  const deletedOrphanVhd = loggued.match(/deleting orphan VHD/g) || []
-  expect(deletedOrphanVhd.length).toEqual(1) // only one vhd should have been deleted
-  const deletedAbandonnedVhd = loggued.match(/abandonned.vhd is missing/g) || []
-  expect(deletedAbandonnedVhd.length).toEqual(1) // and it must be abandonned.vhd
-
-  // we don't test the filew on disk, since they will all be marker as unused and deleted without a metadata.json file
-})
-
-test('it remove backup meta data referencing a missing vhd in delta backup', async () => {
-  // create a metadata file marking child and orphan as ok
-  await handler.writeFile(
-    `metadata.json`,
-    JSON.stringify({
-      mode: 'delta',
-      vhds: [
-        `${basePath}/orphan.vhd`,
-        `${basePath}/child.vhd`,
-        // abandonned.json is not here
-      ],
-    })
-  )
-
-  await generateVhd(`${basePath}/abandonned.vhd`)
-
-  // one orphan, which is a full vhd, no parent
-  const orphan = await generateVhd(`${basePath}/orphan.vhd`)
-
-  // a child to the orphan
-  await generateVhd(`${basePath}/child.vhd`, {
-    header: {
-      parentUnicodeName: 'orphan.vhd',
-      parentUid: orphan.footer.uuid,
-    },
-  })
-
-  let loggued = ''
-  const onLog = message => {
-    loggued += message + '\n'
-  }
-  await adapter.cleanVm('/', { remove: true, onLog })
-  let matched = loggued.match(/deleting unused VHD /g) || []
-  expect(matched.length).toEqual(1) // only one vhd should have been deleted
-  matched = loggued.match(/abandonned.vhd is unused/g) || []
-  expect(matched.length).toEqual(1) // and it must be abandonned.vhd
-
-  // a missing vhd cause clean to remove all vhds
-  await handler.writeFile(
-    `metadata.json`,
-    JSON.stringify({
-      mode: 'delta',
-      vhds: [
-        `${basePath}/deleted.vhd`, // in metadata but not in vhds
-        `${basePath}/orphan.vhd`,
-        `${basePath}/child.vhd`,
-        // abandonned.vhd is not here anymore
-      ],
-    }),
-    { flags: 'w' }
-  )
-  loggued = ''
-  await adapter.cleanVm('/', { remove: true, onLog })
-  matched = loggued.match(/deleting unused VHD /g) || []
-  expect(matched.length).toEqual(2) // all vhds (orphan and  child  ) should have been deleted
-})
-
-test('it merges delta of non destroyed chain', async () => {
-  await handler.writeFile(
-    `metadata.json`,
-    JSON.stringify({
-      mode: 'delta',
-      size: 12000, // a size too small
-      vhds: [
-        `${basePath}/grandchild.vhd`, // grand child should not be merged
-        `${basePath}/child.vhd`,
-        // orphan is not here, he should be merged in child
-      ],
-    })
-  )
-
-  // one orphan, which is a full vhd, no parent
-  const orphan = await generateVhd(`${basePath}/orphan.vhd`)
-  // a child to the orphan
-  const child = await generateVhd(`${basePath}/child.vhd`, {
-    header: {
-      parentUnicodeName: 'orphan.vhd',
-      parentUid: orphan.footer.uuid,
-    },
-  })
-  // a grand child
-  await generateVhd(`${basePath}/grandchild.vhd`, {
-    header: {
-      parentUnicodeName: 'child.vhd',
-      parentUid: child.footer.uuid,
-    },
-  })
-
-  let loggued = []
-  const onLog = message => {
-    loggued.push(message)
-  }
-  await adapter.cleanVm('/', { remove: true, onLog })
-  expect(loggued[0]).toEqual(`the parent /${basePath}/orphan.vhd of the child /${basePath}/child.vhd is unused`)
-  expect(loggued[1]).toEqual(`incorrect size in metadata: 12000 instead of 209920`)
-
-  loggued = []
-  await adapter.cleanVm('/', { remove: true, merge: true, onLog })
-  const [unused, merging] = loggued
-  expect(unused).toEqual(`the parent /${basePath}/orphan.vhd of the child /${basePath}/child.vhd is unused`)
-  expect(merging).toEqual(`merging /${basePath}/child.vhd into /${basePath}/orphan.vhd`)
-
-  const metadata = JSON.parse(await handler.readFile(`metadata.json`))
-  // size should be the size of children + grand children after the merge
-  expect(metadata.size).toEqual(209920)
-
-  // merging is already tested in vhd-lib, don't retest it here (and theses vhd are as empty as my stomach at 12h12)
-  // only check deletion
-  const remainingVhds = await handler.list(basePath)
-  expect(remainingVhds.length).toEqual(2)
-  expect(remainingVhds.includes('child.vhd')).toEqual(true)
-  expect(remainingVhds.includes('grandchild.vhd')).toEqual(true)
-})
-
-test('it finish unterminated merge ', async () => {
-  await handler.writeFile(
-    `metadata.json`,
-    JSON.stringify({
-      mode: 'delta',
-      size: 209920,
-      vhds: [`${basePath}/orphan.vhd`, `${basePath}/child.vhd`],
-    })
-  )
-
-  // one orphan, which is a full vhd, no parent
-  const orphan = await generateVhd(`${basePath}/orphan.vhd`)
-  // a child to the orphan
-  const child = await generateVhd(`${basePath}/child.vhd`, {
-    header: {
-      parentUnicodeName: 'orphan.vhd',
-      parentUid: orphan.footer.uuid,
-    },
-  })
-  // a merge in progress file
-  await handler.writeFile(
-    `${basePath}/.orphan.vhd.merge.json`,
-    JSON.stringify({
-      parent: {
-        header: orphan.header.checksum,
-      },
-      child: {
-        header: child.header.checksum,
-      },
-    })
-  )
-
-  await adapter.cleanVm('/', { remove: true, merge: true })
-  // merging is already tested in vhd-lib, don't retest it here (and theses vhd are as empty as my stomach at 12h12)
-
-  // only check deletion
-  const remainingVhds = await handler.list(basePath)
-  expect(remainingVhds.length).toEqual(1)
-  expect(remainingVhds.includes('child.vhd')).toEqual(true)
-})
-
-// each of the vhd can be a file, a directory, an alias to a file or an alias to a directory
-// the message an resulting files should be identical to the output with vhd files which is tested independantly
-
-describe('tests multiple combination ', () => {
-  for (const useAlias of [true, false]) {
-    for (const vhdMode of ['file', 'directory']) {
-      test(`alias : ${useAlias}, mode: ${vhdMode}`, async () => {
-        // a broken VHD
-        if (useAlias) {
-          await handler.mkdir(basePath + '/data')
-        }
-
-        const brokenVhdDataPath = basePath + (useAlias ? '/data/broken.vhd' : '/broken.vhd')
-
-        if (vhdMode === 'directory') {
-          await handler.mkdir(brokenVhdDataPath)
-        } else {
-          await handler.writeFile(brokenVhdDataPath, 'notreallyavhd')
-        }
-        if (useAlias) {
-          await VhdAbstract.createAlias(handler, 'broken.alias.vhd', brokenVhdDataPath)
-        }
-
-        // a vhd non referenced in metada
-        await generateVhd(`${basePath}/nonreference.vhd`, { useAlias, mode: vhdMode })
-        // an abandonded delta vhd without its parent
-        await generateVhd(`${basePath}/abandonned.vhd`, {
-          useAlias,
-          mode: vhdMode,
-          header: {
-            parentUnicodeName: 'gone.vhd',
-            parentUid: crypto.randomBytes(16),
-          },
-        })
-
-        // an ancestor of a vhd present in metadata
-        const ancestor = await generateVhd(`${basePath}/ancestor.vhd`, {
-          useAlias,
-          mode: vhdMode,
-        })
-        const child = await generateVhd(`${basePath}/child.vhd`, {
-          useAlias,
-          mode: vhdMode,
-          header: {
-            parentUnicodeName: 'ancestor.vhd' + (useAlias ? '.alias.vhd' : ''),
-            parentUid: ancestor.footer.uuid,
-          },
-        })
-        // a grand child  vhd in metadata
-        await generateVhd(`${basePath}/grandchild.vhd`, {
-          useAlias,
-          mode: vhdMode,
-          header: {
-            parentUnicodeName: 'child.vhd' + (useAlias ? '.alias.vhd' : ''),
-            parentUid: child.footer.uuid,
-          },
-        })
-
-        // an older parent that was merging in clean
-        const cleanAncestor = await generateVhd(`${basePath}/cleanAncestor.vhd`, {
-          useAlias,
-          mode: vhdMode,
-        })
-        // a clean  vhd in metadata
-        const clean = await generateVhd(`${basePath}/clean.vhd`, {
-          useAlias,
-          mode: vhdMode,
-          header: {
-            parentUnicodeName: 'cleanAncestor.vhd' + (useAlias ? '.alias.vhd' : ''),
-            parentUid: cleanAncestor.footer.uuid,
-          },
-        })
-
-        await handler.writeFile(
-          `${basePath}/.cleanAncestor.vhd${useAlias ? '.alias.vhd' : ''}.merge.json`,
-          JSON.stringify({
-            parent: {
-              header: cleanAncestor.header.checksum,
-            },
-            child: {
-              header: clean.header.checksum,
-            },
-          })
-        )
-
-        // the metadata file
-        await handler.writeFile(
-          `metadata.json`,
-          JSON.stringify({
-            mode: 'delta',
-            vhds: [
-              `${basePath}/grandchild.vhd` + (useAlias ? '.alias.vhd' : ''), // grand child should not be merged
-              `${basePath}/child.vhd` + (useAlias ? '.alias.vhd' : ''),
-              `${basePath}/clean.vhd` + (useAlias ? '.alias.vhd' : ''),
-            ],
-          })
-        )
-
-        await adapter.cleanVm('/', { remove: true, merge: true })
-
-        const metadata = JSON.parse(await handler.readFile(`metadata.json`))
-        // size should be the size of children + grand children + clean after the merge
-        expect(metadata.size).toEqual(vhdMode === 'file' ? 314880 : undefined)
-
-        // broken vhd, non referenced, abandonned should be deleted ( alias and data)
-        // ancestor and child should be merged
-        // grand child and clean vhd should not have changed
-        const survivors = await handler.list(basePath)
-        // console.log(survivors)
-        if (useAlias) {
-          const dataSurvivors = await handler.list(basePath + '/data')
-          // the goal of the alias : do not move a full folder
-          expect(dataSurvivors).toContain('ancestor.vhd')
-          expect(dataSurvivors).toContain('grandchild.vhd')
-          expect(dataSurvivors).toContain('cleanAncestor.vhd')
-          expect(survivors).toContain('clean.vhd.alias.vhd')
-          expect(survivors).toContain('child.vhd.alias.vhd')
-          expect(survivors).toContain('grandchild.vhd.alias.vhd')
-          expect(survivors.length).toEqual(4) // the 3 ok + data
-          expect(dataSurvivors.length).toEqual(3) // the 3 ok + data
-        } else {
-          expect(survivors).toContain('clean.vhd')
-          expect(survivors).toContain('child.vhd')
-          expect(survivors).toContain('grandchild.vhd')
-          expect(survivors.length).toEqual(3)
-        }
-      })
-    }
-  }
-})
-
-test('it cleans orphan merge states ', async () => {
-  await handler.writeFile(`${basePath}/.orphan.vhd.merge.json`, '')
-
-  await adapter.cleanVm('/', { remove: true })
-
-  expect(await handler.list(basePath)).toEqual([])
-})
-
-test('check Aliases should work alone', async () => {
-  await handler.mkdir('vhds')
-  await handler.mkdir('vhds/data')
-  await generateVhd(`vhds/data/ok.vhd`)
-  await VhdAbstract.createAlias(handler, 'vhds/ok.alias.vhd', 'vhds/data/ok.vhd')
-
-  await VhdAbstract.createAlias(handler, 'vhds/missingData.alias.vhd', 'vhds/data/nonexistent.vhd')
-
-  await generateVhd(`vhds/data/missingalias.vhd`)
-
-  await checkAliases(['vhds/missingData.alias.vhd', 'vhds/ok.alias.vhd'], 'vhds/data', { remove: true, handler })
-
-  // only ok have suvived
-  const alias = (await handler.list('vhds')).filter(f => f.endsWith('.vhd'))
-  expect(alias.length).toEqual(1)
-
-  const data = await handler.list('vhds/data')
-  expect(data.length).toEqual(1)
-})

@xen-orchestra/backups/_cleanVm.js

@@ -1,35 +1,13 @@
-'use strict'
-
 const assert = require('assert')
 const sum = require('lodash/sum')
 const { asyncMap } = require('@xen-orchestra/async-map')
-const { Constants, mergeVhd, openVhd, VhdAbstract, VhdFile } = require('vhd-lib')
-const { isVhdAlias, resolveVhdAlias } = require('vhd-lib/aliases')
-const { dirname, resolve, basename } = require('path')
-const { DISK_TYPES } = Constants
+const { VhdFile, mergeVhd } = require('vhd-lib')
+const { dirname, resolve } = require('path')
+const { DISK_TYPE_DIFFERENCING } = require('vhd-lib/dist/_constants.js')
 const { isMetadataFile, isVhdFile, isXvaFile, isXvaSumFile } = require('./_backupType.js')
 const { limitConcurrency } = require('limit-concurrency-decorator')
 
 const { Task } = require('./Task.js')
-const { Disposable } = require('promise-toolbox')
-
-// checking the size of a vhd directory is costly
-// 1 Http Query per 1000 blocks
-// we only check size of all the vhd are VhdFiles
-function shouldComputeVhdsSize(vhds) {
-  return vhds.every(vhd => vhd instanceof VhdFile)
-}
-
-const computeVhdsSize = (handler, vhdPaths) =>
-  Disposable.use(
-    vhdPaths.map(vhdPath => openVhd(handler, vhdPath)),
-    async vhds => {
-      if (shouldComputeVhdsSize(vhds)) {
-        const sizes = await asyncMap(vhds, vhd => vhd.getSize())
-        return sum(sizes)
-      }
-    }
-  )
 
 // chain is an array of VHDs from child to parent
 //
@@ -85,13 +63,14 @@ async function mergeVhdChain(chain, { handler, onLog, remove, merge }) {
     )
 
     clearInterval(handle)
+
     await Promise.all([
-      VhdAbstract.rename(handler, parent, child),
+      handler.rename(parent, child),
       asyncMap(children.slice(0, -1), child => {
         onLog(`the VHD ${child} is unused`)
         if (remove) {
-          onLog(`mergeVhdChain: deleting unused VHD ${child}`)
-          return VhdAbstract.unlink(handler, child)
+          onLog(`deleting unused VHD ${child}`)
+          return handler.unlink(child)
         }
       }),
     ])
@@ -102,11 +81,10 @@ async function mergeVhdChain(chain, { handler, onLog, remove, merge }) {
 
 const noop = Function.prototype
 
-const INTERRUPTED_VHDS_REG = /^\.(.+)\.merge.json$/
+const INTERRUPTED_VHDS_REG = /^(?:(.+)\/)?\.(.+)\.merge.json$/
 const listVhds = async (handler, vmDir) => {
-  const vhds = new Set()
-  const aliases = {}
-  const interruptedVhds = new Map()
+  const vhds = []
+  const interruptedVhds = new Set()
 
   await asyncMap(
     await handler.list(`${vmDir}/vdis`, {
@@ -121,77 +99,25 @@ const listVhds = async (handler, vmDir) => {
         async vdiDir => {
           const list = await handler.list(vdiDir, {
             filter: file => isVhdFile(file) || INTERRUPTED_VHDS_REG.test(file),
+            prependDir: true,
           })
-          aliases[vdiDir] = list.filter(vhd => isVhdAlias(vhd)).map(file => `${vdiDir}/${file}`)
+
           list.forEach(file => {
             const res = INTERRUPTED_VHDS_REG.exec(file)
             if (res === null) {
-              vhds.add(`${vdiDir}/${file}`)
+              vhds.push(file)
             } else {
-              interruptedVhds.set(`${vdiDir}/${res[1]}`, `${vdiDir}/${file}`)
+              const [, dir, file] = res
+              interruptedVhds.add(`${dir}/${file}`)
             }
           })
         }
       )
   )
 
-  return { vhds, interruptedVhds, aliases }
+  return { vhds, interruptedVhds }
 }
 
-async function checkAliases(aliasPaths, targetDataRepository, { handler, onLog = noop, remove = false }) {
-  const aliasFound = []
-  for (const path of aliasPaths) {
-    const target = await resolveVhdAlias(handler, path)
-
-    if (!isVhdFile(target)) {
-      onLog(`Alias ${path} references a non vhd target:  ${target}`)
-      if (remove) {
-        await handler.unlink(target)
-        await handler.unlink(path)
-      }
-      continue
-    }
-
-    try {
-      const { dispose } = await openVhd(handler, target)
-      try {
-        await dispose()
-      } catch (e) {
-        // error during dispose should not trigger a deletion
-      }
-    } catch (error) {
-      onLog(`target ${target} of alias ${path} is missing or broken`, { error })
-      if (remove) {
-        try {
-          await VhdAbstract.unlink(handler, path)
-        } catch (e) {
-          if (e.code !== 'ENOENT') {
-            onLog(`Error while deleting target ${target} of alias ${path}`, { error: e })
-          }
-        }
-      }
-      continue
-    }
-
-    aliasFound.push(resolve('/', target))
-  }
-
-  const entries = await handler.list(targetDataRepository, {
-    ignoreMissing: true,
-    prependDir: true,
-  })
-
-  entries.forEach(async entry => {
-    if (!aliasFound.includes(entry)) {
-      onLog(`the Vhd  ${entry} is not referenced by a an alias`)
-      if (remove) {
-        await VhdAbstract.unlink(handler, entry)
-      }
-    }
-  })
-}
-exports.checkAliases = checkAliases
-
 const defaultMergeLimiter = limitConcurrency(1)
 
 exports.cleanVm = async function cleanVm(
@@ -202,85 +128,62 @@ exports.cleanVm = async function cleanVm(
 
   const handler = this._handler
 
-  const vhdsToJSons = new Set()
+  const vhds = new Set()
   const vhdParents = { __proto__: null }
   const vhdChildren = { __proto__: null }
 
-  const { vhds, interruptedVhds, aliases } = await listVhds(handler, vmDir)
+  const vhdsList = await listVhds(handler, vmDir)
 
   // remove broken VHDs
-  await asyncMap(vhds, async path => {
+  await asyncMap(vhdsList.vhds, async path => {
     try {
-      await Disposable.use(openVhd(handler, path, { checkSecondFooter: !interruptedVhds.has(path) }), vhd => {
-        if (vhd.footer.diskType === DISK_TYPES.DIFFERENCING) {
-          const parent = resolve('/', dirname(path), vhd.header.parentUnicodeName)
-          vhdParents[path] = parent
-          if (parent in vhdChildren) {
-            const error = new Error('this script does not support multiple VHD children')
-            error.parent = parent
-            error.child1 = vhdChildren[parent]
-            error.child2 = path
-            throw error // should we throw?
-          }
-          vhdChildren[parent] = path
+      const vhd = new VhdFile(handler, path)
+      await vhd.readHeaderAndFooter(!vhdsList.interruptedVhds.has(path))
+      vhds.add(path)
+      if (vhd.footer.diskType === DISK_TYPE_DIFFERENCING) {
+        const parent = resolve('/', dirname(path), vhd.header.parentUnicodeName)
+        vhdParents[path] = parent
+        if (parent in vhdChildren) {
+          const error = new Error('this script does not support multiple VHD children')
+          error.parent = parent
+          error.child1 = vhdChildren[parent]
+          error.child2 = path
+          throw error // should we throw?
         }
-      })
+        vhdChildren[parent] = path
+      }
     } catch (error) {
-      vhds.delete(path)
       onLog(`error while checking the VHD with path ${path}`, { error })
       if (error?.code === 'ERR_ASSERTION' && remove) {
         onLog(`deleting broken ${path}`)
-        return VhdAbstract.unlink(handler, path)
+        await handler.unlink(path)
       }
     }
   })
 
-  // remove interrupted merge states for missing VHDs
-  for (const interruptedVhd of interruptedVhds.keys()) {
-    if (!vhds.has(interruptedVhd)) {
-      const statePath = interruptedVhds.get(interruptedVhd)
-      interruptedVhds.delete(interruptedVhd)
-
-      onLog('orphan merge state', {
-        mergeStatePath: statePath,
-        missingVhdPath: interruptedVhd,
-      })
-      if (remove) {
-        onLog(`deleting orphan merge state ${statePath}`)
-        await handler.unlink(statePath)
-      }
-    }
-  }
-
-  // check if alias are correct
-  // check if all vhd in data subfolder have a corresponding alias
-  await asyncMap(Object.keys(aliases), async dir => {
-    await checkAliases(aliases[dir], `${dir}/data`, { handler, onLog, remove })
-  })
-
   // remove VHDs with missing ancestors
   {
     const deletions = []
 
     // return true if the VHD has been deleted or is missing
-    const deleteIfOrphan = vhdPath => {
-      const parent = vhdParents[vhdPath]
+    const deleteIfOrphan = vhd => {
+      const parent = vhdParents[vhd]
       if (parent === undefined) {
         return
       }
 
       // no longer needs to be checked
-      delete vhdParents[vhdPath]
+      delete vhdParents[vhd]
 
       deleteIfOrphan(parent)
 
       if (!vhds.has(parent)) {
-        vhds.delete(vhdPath)
+        vhds.delete(vhd)
 
-        onLog(`the parent ${parent} of the VHD ${vhdPath} is missing`)
+        onLog(`the parent ${parent} of the VHD ${vhd} is missing`)
         if (remove) {
-          onLog(`deleting orphan VHD ${vhdPath}`)
-          deletions.push(VhdAbstract.unlink(handler, vhdPath))
+          onLog(`deleting orphan VHD ${vhd}`)
+          deletions.push(handler.unlink(vhd))
         }
       }
     }
@@ -296,7 +199,7 @@ exports.cleanVm = async function cleanVm(
     await Promise.all(deletions)
   }
 
-  const jsons = new Set()
+  const jsons = []
   const xvas = new Set()
   const xvaSums = []
   const entries = await handler.list(vmDir, {
@@ -304,7 +207,7 @@ exports.cleanVm = async function cleanVm(
   })
   entries.forEach(path => {
     if (isMetadataFile(path)) {
-      jsons.add(path)
+      jsons.push(path)
     } else if (isXvaFile(path)) {
       xvas.add(path)
     } else if (isXvaSumFile(path)) {
@@ -326,25 +229,22 @@ exports.cleanVm = async function cleanVm(
   // compile the list of unused XVAs and VHDs, and remove backup metadata which
   // reference a missing XVA/VHD
   await asyncMap(jsons, async json => {
-    let metadata
-    try {
-      metadata = JSON.parse(await handler.readFile(json))
-    } catch (error) {
-      onLog(`failed to read metadata file ${json}`, { error })
-      jsons.delete(json)
-      return
-    }
-
+    const metadata = JSON.parse(await handler.readFile(json))
     const { mode } = metadata
+    let size
     if (mode === 'full') {
       const linkedXva = resolve('/', vmDir, metadata.xva)
+
       if (xvas.has(linkedXva)) {
         unusedXvas.delete(linkedXva)
+
+        size = await handler.getSize(linkedXva).catch(error => {
+          onLog(`failed to get size of ${json}`, { error })
+        })
       } else {
         onLog(`the XVA linked to the metadata ${json} is missing`)
         if (remove) {
           onLog(`deleting incomplete backup ${json}`)
-          jsons.delete(json)
           await handler.unlink(json)
         }
       }
@@ -354,24 +254,38 @@ exports.cleanVm = async function cleanVm(
         return Object.keys(vhds).map(key => resolve('/', vmDir, vhds[key]))
       })()
 
-      const missingVhds = linkedVhds.filter(_ => !vhds.has(_))
-
       // FIXME: find better approach by keeping as much of the backup as
       // possible (existing disks) even if one disk is missing
-      if (missingVhds.length === 0) {
+      if (linkedVhds.every(_ => vhds.has(_))) {
         linkedVhds.forEach(_ => unusedVhds.delete(_))
-        linkedVhds.forEach(path => {
-          vhdsToJSons[path] = json
+
+        size = await asyncMap(linkedVhds, vhd => handler.getSize(vhd)).then(sum, error => {
+          onLog(`failed to get size of ${json}`, { error })
         })
       } else {
-        onLog(`Some VHDs linked to the metadata ${json} are missing`, { missingVhds })
+        onLog(`Some VHDs linked to the metadata ${json} are missing`)
         if (remove) {
           onLog(`deleting incomplete backup ${json}`)
-          jsons.delete(json)
           await handler.unlink(json)
         }
       }
     }
+
+    const metadataSize = metadata.size
+    if (size !== undefined && metadataSize !== size) {
+      onLog(`incorrect size in metadata: ${metadataSize ?? 'none'} instead of ${size}`)
+
+      // don't update if the the stored size is greater than found files,
+      // it can indicates a problem
+      if (fixMetadata && (metadataSize === undefined || metadataSize < size)) {
+        try {
+          metadata.size = size
+          await handler.writeFile(json, JSON.stringify(metadata), { flags: 'w' })
+        } catch (error) {
+          onLog(`failed to update size in backup metadata ${json}`, { error })
+        }
+      }
+    }
   })
 
   // TODO: parallelize by vm/job/vdi
@@ -383,7 +297,7 @@ exports.cleanVm = async function cleanVm(
     const vhdChainsToMerge = { __proto__: null }
 
     const toCheck = new Set(unusedVhds)
-    let shouldDelete = false
+
     const getUsedChildChainOrDelete = vhd => {
       if (vhd in vhdChainsToMerge) {
         const chain = vhdChainsToMerge[vhd]
@@ -409,64 +323,8 @@ exports.cleanVm = async function cleanVm(
 
       onLog(`the VHD ${vhd} is unused`)
       if (remove) {
-        onLog(`getUsedChildChainOrDelete: deleting unused VHD`, {
-          vhdChildren,
-          vhd,
-        })
-        // temporarly disabled
-        shouldDelete = true
-        // unusedVhdsDeletion.push(VhdAbstract.unlink(handler, vhd))
-      }
-    }
-
-    {
-      // eslint-disable-next-line no-console
-      const debug = console.debug
-
-      if (shouldDelete) {
-        const chains = { __proto__: null }
-
-        const queue = new Set(vhds)
-        function addChildren(parent, chain) {
-          queue.delete(parent)
-
-          const child = vhdChildren[parent]
-          if (child !== undefined) {
-            const childChain = chains[child]
-            if (childChain !== undefined) {
-              // if a chain already exists, use it
-              delete chains[child]
-              chain.push(...childChain)
-            } else {
-              chain.push(child)
-              addChildren(child, chain)
-            }
-          }
-        }
-        for (const vhd of queue) {
-          const chain = []
-          addChildren(vhd, chain)
-          chains[vhd] = chain
-        }
-
-        const entries = Object.entries(chains)
-        debug(`${vhds.size} VHDs (${unusedVhds.size} unused) found among ${entries.length} chains [`)
-        const decorateVhd = vhd => {
-          const shortPath = basename(vhd)
-          return unusedVhds.has(vhd) ? `${shortPath} [unused]` : shortPath
-        }
-        for (let i = 0, n = entries.length; i < n; ++i) {
-          debug(`in ${dirname(entries[i][0])}`)
-          debug('  [')
-
-          const [parent, children] = entries[i]
-          debug('    ' + decorateVhd(parent))
-          for (const child of children) {
-            debug('    ' + decorateVhd(child))
-          }
-          debug('  ]')
-        }
-        debug(']')
+        onLog(`deleting unused VHD ${vhd}`)
+        unusedVhdsDeletion.push(handler.unlink(vhd))
       }
     }
 
@@ -475,9 +333,9 @@ exports.cleanVm = async function cleanVm(
     })
 
     // merge interrupted VHDs
-    for (const parent of interruptedVhds.keys()) {
+    vhdsList.interruptedVhds.forEach(parent => {
       vhdChainsToMerge[parent] = [vhdChildren[parent], parent]
-    }
+    })
 
     Object.values(vhdChainsToMerge).forEach(chain => {
       if (chain !== undefined) {
@@ -486,15 +344,9 @@ exports.cleanVm = async function cleanVm(
     })
   }
 
-  const metadataWithMergedVhd = {}
-  const doMerge = async () => {
-    await asyncMap(toMerge, async chain => {
-      const merged = await limitedMergeVhdChain(chain, { handler, onLog, remove, merge })
-      if (merged !== undefined) {
-        const metadataPath = vhdsToJSons[chain[0]] // all the chain should have the same metada file
-        metadataWithMergedVhd[metadataPath] = true
-      }
-    })
+  const doMerge = () => {
+    const promise = asyncMap(toMerge, async chain => limitedMergeVhdChain(chain, { handler, onLog, remove, merge }))
+    return merge ? promise.then(sizes => ({ size: sum(sizes) })) : promise
   }
 
   await Promise.all([
@@ -519,52 +371,6 @@ exports.cleanVm = async function cleanVm(
     }),
   ])
 
-  // update size for delta metadata with merged VHD
-  // check for the other that the size is the same as the real file size
-
-  await asyncMap(jsons, async metadataPath => {
-    const metadata = JSON.parse(await handler.readFile(metadataPath))
-
-    let fileSystemSize
-    const merged = metadataWithMergedVhd[metadataPath] !== undefined
-
-    const { mode, size, vhds, xva } = metadata
-
-    try {
-      if (mode === 'full') {
-        // a full backup : check size
-        const linkedXva = resolve('/', vmDir, xva)
-        fileSystemSize = await handler.getSize(linkedXva)
-      } else if (mode === 'delta') {
-        const linkedVhds = Object.keys(vhds).map(key => resolve('/', vmDir, vhds[key]))
-        fileSystemSize = await computeVhdsSize(handler, linkedVhds)
-
-        // the size is not computed in some cases (e.g. VhdDirectory)
-        if (fileSystemSize === undefined) {
-          return
-        }
-
-        // don't warn if the size has changed after a merge
-        if (!merged && fileSystemSize !== size) {
-          onLog(`incorrect size in metadata: ${size ?? 'none'} instead of ${fileSystemSize}`)
-        }
-      }
-    } catch (error) {
-      onLog(`failed to get size of ${metadataPath}`, { error })
-      return
-    }
-
-    // systematically update size after a merge
-    if ((merged || fixMetadata) && size !== fileSystemSize) {
-      metadata.size = fileSystemSize
-      try {
-        await handler.writeFile(metadataPath, JSON.stringify(metadata), { flags: 'w' })
-      } catch (error) {
-        onLog(`failed to update size in backup metadata ${metadataPath} after merge`, { error })
-      }
-    }
-  })
-
   return {
     // boolean whether some VHDs were merged (or should be merged)
     merge: toMerge.length !== 0,

@xen-orchestra/backups/_deltaVm.js

@@ -1,9 +1,7 @@
-'use strict'
-
 const compareVersions = require('compare-versions')
 const find = require('lodash/find.js')
 const groupBy = require('lodash/groupBy.js')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
+const ignoreErrors = require('promise-toolbox/ignoreErrors.js')
 const omit = require('lodash/omit.js')
 const { asyncMap } = require('@xen-orchestra/async-map')
 const { CancelToken } = require('promise-toolbox')
@@ -11,8 +9,6 @@ const { createVhdStreamWithLength } = require('vhd-lib')
 const { defer } = require('golike-defer')
 
 const { cancelableMap } = require('./_cancelableMap.js')
-const { Task } = require('./Task.js')
-const { pick } = require('lodash')
 
 const TAG_BASE_DELTA = 'xo:base_delta'
 exports.TAG_BASE_DELTA = TAG_BASE_DELTA
@@ -21,17 +17,6 @@ const TAG_COPY_SRC = 'xo:copy_of'
 exports.TAG_COPY_SRC = TAG_COPY_SRC
 
 const ensureArray = value => (value === undefined ? [] : Array.isArray(value) ? value : [value])
-const resolveUuid = async (xapi, cache, uuid, type) => {
-  if (uuid == null) {
-    return uuid
-  }
-  let ref = cache.get(uuid)
-  if (ref === undefined) {
-    ref = await xapi.call(`${type}.get_by_uuid`, uuid)
-    cache.set(uuid, ref)
-  }
-  return ref
-}
 
 exports.exportDeltaVm = async function exportDeltaVm(
   vm,
@@ -65,6 +50,17 @@ exports.exportDeltaVm = async function exportDeltaVm(
       return
     }
 
+    // If the VDI name start with `[NOBAK]`, do not export it.
+    if (vdi.name_label.startsWith('[NOBAK]')) {
+      // FIXME: find a way to not create the VDI snapshot in the
+      // first time.
+      //
+      // The snapshot must not exist otherwise it could break the
+      // next export.
+      ignoreErrors.call(vdi.$destroy())
+      return
+    }
+
     vbds[vbd.$ref] = vbd
 
     const vdiRef = vdi.$ref
@@ -169,12 +165,6 @@ exports.importDeltaVm = defer(async function importDeltaVm(
     }
   }
 
-  const cache = new Map()
-  const mapVdisSrRefs = {}
-  for (const [vdiUuid, srUuid] of Object.entries(mapVdisSrs)) {
-    mapVdisSrRefs[vdiUuid] = await resolveUuid(xapi, cache, srUuid, 'SR')
-  }
-
   const baseVdis = {}
   baseVm &&
     baseVm.$VBDs.forEach(vbd => {
@@ -189,25 +179,19 @@ exports.importDeltaVm = defer(async function importDeltaVm(
   let suspendVdi
   if (vmRecord.power_state === 'Suspended') {
     const vdi = vdiRecords[vmRecord.suspend_VDI]
-    if (vdi === undefined) {
-      Task.warning('Suspend VDI not available for this suspended VM', {
-        vm: pick(vmRecord, 'uuid', 'name_label'),
+    suspendVdi = await xapi.getRecord(
+      'VDI',
+      await xapi.VDI_create({
+        ...vdi,
+        other_config: {
+          ...vdi.other_config,
+          [TAG_BASE_DELTA]: undefined,
+          [TAG_COPY_SRC]: vdi.uuid,
+        },
+        sr: mapVdisSrs[vdi.uuid] ?? sr.$ref,
       })
-    } else {
-      suspendVdi = await xapi.getRecord(
-        'VDI',
-        await xapi.VDI_create({
-          ...vdi,
-          other_config: {
-            ...vdi.other_config,
-            [TAG_BASE_DELTA]: undefined,
-            [TAG_COPY_SRC]: vdi.uuid,
-          },
-          sr: mapVdisSrRefs[vdi.uuid] ?? sr.$ref,
-        })
-      )
-      $defer.onFailure(() => suspendVdi.$destroy())
-    }
+    )
+    $defer.onFailure(() => suspendVdi.$destroy())
   }
 
   // 1. Create the VM.
@@ -271,7 +255,7 @@ exports.importDeltaVm = defer(async function importDeltaVm(
             [TAG_BASE_DELTA]: undefined,
             [TAG_COPY_SRC]: vdi.uuid,
           },
-          SR: mapVdisSrRefs[vdi.uuid] ?? sr.$ref,
+          SR: mapVdisSrs[vdi.uuid] ?? sr.$ref,
         })
       )
       $defer.onFailure(() => newVdi.$destroy())

@xen-orchestra/backups/_extractIdsFromSimplePattern.js

@@ -1,5 +1,3 @@
-'use strict'
-
 exports.extractIdsFromSimplePattern = function extractIdsFromSimplePattern(pattern) {
   if (pattern === undefined) {
     return []

@xen-orchestra/backups/_filenameDate.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { utcFormat, utcParse } = require('d3-time-format')
 
 // Format a date in ISO 8601 in a safe way to be used in filenames

@xen-orchestra/backups/_forkStreamUnpipe.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const eos = require('end-of-stream')
 const { PassThrough } = require('stream')
 

@xen-orchestra/backups/_getOldEntries.js

@@ -1,5 +1,3 @@
-'use strict'
-
 // returns all entries but the last retention-th
 exports.getOldEntries = function getOldEntries(retention, entries) {
   return entries === undefined ? [] : retention > 0 ? entries.slice(0, -retention) : entries

@xen-orchestra/backups/_getTmpDir.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const Disposable = require('promise-toolbox/Disposable')
+const Disposable = require('promise-toolbox/Disposable.js')
 const { join } = require('path')
 const { mkdir, rmdir } = require('fs-extra')
 const { tmpdir } = require('os')

@xen-orchestra/backups/_getVmBackupDir.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const BACKUP_DIR = 'xo-vm-backups'
 exports.BACKUP_DIR = BACKUP_DIR