feat: use additionnal file for checksum instead of attributes

Introduced by 7c80d0c1e

.commitlintrc.json

@@ -0,0 +1 @@
+{ "extends": ["@commitlint/config-conventional"] }

.eslintrc.js

@@ -1,5 +1,7 @@
+'use strict'
+
 module.exports = {
-  extends: ['plugin:eslint-comments/recommended', 'standard', 'standard-jsx', 'prettier'],
+  extends: ['plugin:eslint-comments/recommended', 'plugin:n/recommended', 'standard', 'standard-jsx', 'prettier'],
   globals: {
     __DEV__: true,
     $Dict: true,
@@ -15,11 +17,42 @@ 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: ['*.{integ,spec,test}.{,c,m}js'],
+      rules: {
+        'n/no-unpublished-require': 'off',
+        'n/no-unpublished-import': 'off',
+        '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'],
@@ -34,5 +67,7 @@ module.exports = {
     'lines-between-class-members': 'off',
 
     'no-console': ['error', { allow: ['warn', 'error'] }],
+
+    strict: 'error',
   },
 }

.flowconfig

@@ -1,16 +0,0 @@
-[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,14 +4,30 @@ about: Create a report to help us improve
 title: ''
 labels: 'status: triaging :triangular_flag_on_post:, type: bug :bug:'
 assignees: ''
-
 ---
 
+1. ⚠️ **If you don't follow this template, the issue will be closed**.
+2. ⚠️ **If your issue can't be easily reproduced, please report it [on the forum first](https://xcp-ng.org/forum/category/12/xen-orchestra)**.
+
+Are you using 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:
+
+- Provide **your commit number**. If it's older than a week, we won't investigate
+- 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 '....'
@@ -23,11 +39,10 @@ A clear and concise description of what you expected to happen.
 **Screenshots**
 If applicable, add screenshots to help explain your problem.
 
-**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]
+**Environment (please provide the following information):**
+
+- Node: [e.g. 16.12.1]
+- hypervisor: [e.g. XCP-ng 8.2.0]
 
 **Additional context**
 Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -4,7 +4,6 @@ about: Suggest an idea for this project
 title: ''
 labels: ''
 assignees: ''
-
 ---
 
 **Is your feature request related to a problem? Please describe.**

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: Continous Integration
+on: push
+jobs:
+  CI:
+    runs-on: ubuntu-latest
+    steps:
+      # https://github.com/actions/checkout
+      - uses: actions/checkout@v3
+      - name: Install packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y curl qemu-utils python3-vmdkstream git libxml2-utils libfuse2 nbdkit
+      - name: Cache Turbo
+        # https://github.com/actions/cache
+        uses: actions/cache@v3
+        with:
+          path: '**/node_modules/.cache/turbo'
+          key: ${{ runner.os }}-turbo-cache
+      - name: Setup Node environment
+        # https://github.com/actions/setup-node
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          cache: 'yarn'
+      - name: Install project dependencies
+        run: yarn
+      - name: Build the project
+        run: yarn build
+      - name: Lint tests
+        run: yarn test-lint
+      - name: Integration tests
+        run: sudo yarn test-integration

.gitignore

@@ -1,5 +1,4 @@
 /_book/
-/coverage/
 /node_modules/
 /lerna-debug.log
 /lerna-debug.log.*
@@ -11,10 +10,6 @@
 /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/
 /packages/xen-api/plot.dat
 
@@ -35,3 +30,8 @@ pnpm-debug.log.*
 yarn-error.log
 yarn-error.log.*
 .env
+
+# code coverage
+.nyc_output/
+coverage/
+.turbo/

.husky/commit-msg

@@ -0,0 +1,11 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+# Only check commit message if commit on master or first commit on another
+# branch to avoid bothering fix commits after reviews
+#
+# FIXME: does not properly run with git commit --amend
+if [ "$(git rev-parse --abbrev-ref HEAD)" = master ] || [ "$(git rev-list --count master..)" -eq 0 ]
+then
+  npx --no -- commitlint --edit "$1"
+fi

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged

.travis.yml

@@ -1,23 +0,0 @@
-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

@@ -14,7 +14,7 @@ Returns a promise wich rejects as soon as a call to `iteratee` throws or a promi
 
 `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`
+- `concurrency`: a number which indicates the maximum number of parallel call to `iteratee`, defaults to `10`. The value `0` means no concurrency limit.
 - `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`
 

@vates/async-each/README.md

@@ -10,8 +10,8 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/async-each):
 
-```
-> npm install --save @vates/async-each
+```sh
+npm install --save @vates/async-each
 ```
 
 ## Usage
@@ -32,7 +32,7 @@ Returns a promise wich rejects as soon as a call to `iteratee` throws or a promi
 
 `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`
+- `concurrency`: a number which indicates the maximum number of parallel call to `iteratee`, defaults to `10`. The value `0` means no concurrency limit.
 - `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`
 

@vates/async-each/index.js

@@ -9,7 +9,16 @@ class AggregateError extends Error {
   }
 }
 
-exports.asyncEach = function asyncEach(iterable, iteratee, { concurrency = 1, signal, stopOnError = true } = {}) {
+/**
+ * @template Item
+ * @param {Iterable<Item>} iterable
+ * @param {(item: Item, index: number, iterable: Iterable<Item>) => Promise<void>} iteratee
+ * @returns {Promise<void>}
+ */
+exports.asyncEach = function asyncEach(iterable, iteratee, { concurrency = 10, signal, stopOnError = true } = {}) {
+  if (concurrency === 0) {
+    concurrency = Infinity
+  }
   return new Promise((resolve, reject) => {
     const it = (iterable[Symbol.iterator] || iterable[Symbol.asyncIterator]).call(iterable)
     const errors = []

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

@@ -1,6 +1,8 @@
 'use strict'
 
-/* eslint-env jest */
+const { describe, it, beforeEach } = require('test')
+const assert = require('assert').strict
+const { spy } = require('sinon')
 
 const { asyncEach } = require('./')
 
@@ -34,12 +36,18 @@ describe('asyncEach', () => {
       })
 
       it('works', async () => {
-        const iteratee = jest.fn(async () => {})
+        const iteratee = spy(async () => {})
 
-        await asyncEach.call(thisArg, iterable, iteratee)
+        await asyncEach.call(thisArg, iterable, iteratee, { concurrency: 1 })
 
-        expect(iteratee.mock.instances).toEqual(Array.from(values, () => thisArg))
-        expect(iteratee.mock.calls).toEqual(Array.from(values, (value, index) => [value, index, iterable]))
+        assert.deepStrictEqual(
+          iteratee.thisValues,
+          Array.from(values, () => thisArg)
+        )
+        assert.deepStrictEqual(
+          iteratee.args,
+          Array.from(values, (value, index) => [value, index, iterable])
+        )
       })
       ;[1, 2, 4].forEach(concurrency => {
         it('respects a concurrency of ' + concurrency, async () => {
@@ -49,7 +57,7 @@ describe('asyncEach', () => {
             values,
             async () => {
               ++running
-              expect(running).toBeLessThanOrEqual(concurrency)
+              assert.deepStrictEqual(running <= concurrency, true)
               await randomDelay()
               --running
             },
@@ -59,40 +67,52 @@ describe('asyncEach', () => {
       })
 
       it('stops on first error when stopOnError is true', async () => {
+        const tracker = new assert.CallTracker()
+
         const error = new Error()
-        const iteratee = jest.fn((_, i) => {
+        const iteratee = tracker.calls((_, i) => {
           if (i === 1) {
             throw error
           }
-        })
+        }, 2)
+        assert.deepStrictEqual(
+          await rejectionOf(asyncEach(iterable, iteratee, { concurrency: 1, stopOnError: true })),
+          error
+        )
 
-        expect(await rejectionOf(asyncEach(iterable, iteratee, { stopOnError: true }))).toBe(error)
-        expect(iteratee).toHaveBeenCalledTimes(2)
+        tracker.verify()
       })
 
       it('rejects AggregateError when stopOnError is false', async () => {
         const errors = []
-        const iteratee = jest.fn(() => {
+        const iteratee = spy(() => {
           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]))
+        assert.deepStrictEqual(error.errors, errors)
+        assert.deepStrictEqual(
+          iteratee.args,
+          Array.from(values, (value, index) => [value, index, iterable])
+        )
       })
 
       it('can be interrupted with an AbortSignal', async () => {
+        const tracker = new assert.CallTracker()
+
         const ac = new AbortController()
-        const iteratee = jest.fn((_, i) => {
+        const iteratee = tracker.calls((_, i) => {
           if (i === 1) {
             ac.abort()
           }
+        }, 2)
+        await assert.rejects(asyncEach(iterable, iteratee, { concurrency: 1, signal: ac.signal }), {
+          message: 'asyncEach aborted',
         })
 
-        await expect(asyncEach(iterable, iteratee, { signal: ac.signal })).rejects.toThrow('asyncEach aborted')
-        expect(iteratee).toHaveBeenCalledTimes(2)
+        tracker.verify()
       })
     })
   )

@vates/async-each/package.json

@@ -24,11 +24,17 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "engines": {
     "node": ">=8.10"
   },
   "scripts": {
-    "postversion": "npm publish --access public"
+    "postversion": "npm publish --access public",
+    "test": "node--test"
+  },
+  "devDependencies": {
+    "sinon": "^15.0.1",
+    "tap": "^16.3.0",
+    "test": "^3.2.1"
   }
 }

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

@@ -0,0 +1,30 @@
+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

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

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

@@ -0,0 +1,63 @@
+<!-- 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):
+
+```sh
+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

@@ -0,0 +1,72 @@
+'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

@@ -0,0 +1,32 @@
+{
+  "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/README.md

@@ -10,8 +10,8 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/coalesce-calls):
 
-```
-> npm install --save @vates/coalesce-calls
+```sh
+npm install --save @vates/coalesce-calls
 ```
 
 ## Usage

@vates/coalesce-calls/index.js

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

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

@@ -1,4 +1,7 @@
-/* eslint-env jest */
+'use strict'
+
+const { describe, it } = require('test')
+const assert = require('assert')
 
 const { coalesceCalls } = require('./')
 
@@ -21,13 +24,13 @@ describe('coalesceCalls', () => {
     const promise2 = fn(defer2.promise)
 
     defer1.resolve('foo')
-    expect(await promise1).toBe('foo')
-    expect(await promise2).toBe('foo')
+    assert.strictEqual(await promise1, 'foo')
+    assert.strictEqual(await promise2, 'foo')
 
     const defer3 = pDefer()
     const promise3 = fn(defer3.promise)
 
     defer3.resolve('bar')
-    expect(await promise3).toBe('bar')
+    assert.strictEqual(await promise3, 'bar')
   })
 })

@vates/coalesce-calls/package.json

@@ -30,6 +30,10 @@
     "node": ">=8.10"
   },
   "scripts": {
-    "postversion": "npm publish --access public"
+    "postversion": "npm publish --access public",
+    "test": "node--test"
+  },
+  "devDependencies": {
+    "test": "^3.2.1"
   }
 }

@vates/compose/README.md

@@ -10,8 +10,8 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/compose):
 
-```
-> npm install --save @vates/compose
+```sh
+npm install --save @vates/compose
 ```
 
 ## Usage

@vates/compose/index.test.js

@@ -1,4 +1,7 @@
-/* eslint-env jest */
+'use strict'
+
+const { describe, it } = require('test')
+const assert = require('node:assert').strict
 
 const { compose } = require('./')
 
@@ -7,43 +10,42 @@ const mul3 = x => x * 3
 
 describe('compose()', () => {
   it('throws when no functions is passed', () => {
-    expect(() => compose()).toThrow(TypeError)
-    expect(() => compose([])).toThrow(TypeError)
+    assert.throws(() => compose(), TypeError)
+    assert.throws(() => compose([]), TypeError)
   })
 
   it('applies from left to right', () => {
-    expect(compose(add2, mul3)(5)).toBe(21)
+    assert.strictEqual(compose(add2, mul3)(5), 21)
   })
 
   it('accepts functions in an array', () => {
-    expect(compose([add2, mul3])(5)).toBe(21)
+    assert.strictEqual(compose([add2, mul3])(5), 21)
   })
 
   it('can apply from right to left', () => {
-    expect(compose({ right: true }, add2, mul3)(5)).toBe(17)
+    assert.strictEqual(compose({ right: true }, add2, mul3)(5), 17)
   })
 
   it('accepts options with functions in an array', () => {
-    expect(compose({ right: true }, [add2, mul3])(5)).toBe(17)
+    assert.strictEqual(compose({ right: true }, [add2, mul3])(5), 17)
   })
 
   it('can compose async functions', async () => {
-    expect(
+    assert.strictEqual(
       await compose(
         { async: true },
         async x => x + 2,
         async x => x * 3
-      )(5)
-    ).toBe(21)
+      )(5),
+      21
+    )
   })
 
   it('forwards all args to first function', () => {
-    expect.assertions(1)
-
     const expectedArgs = [Math.random(), Math.random()]
     compose(
       (...args) => {
-        expect(args).toEqual(expectedArgs)
+        assert.deepEqual(args, expectedArgs)
       },
       // add a second function to avoid the one function special case
       Function.prototype
@@ -51,15 +53,13 @@ describe('compose()', () => {
   })
 
   it('forwards context to all functions', () => {
-    expect.assertions(2)
-
     const expectedThis = {}
     compose(
       function () {
-        expect(this).toBe(expectedThis)
+        assert.strictEqual(this, expectedThis)
       },
       function () {
-        expect(this).toBe(expectedThis)
+        assert.strictEqual(this, expectedThis)
       }
     ).call(expectedThis)
   })

@vates/compose/package.json

@@ -19,6 +19,10 @@
     "node": ">=7.6"
   },
   "scripts": {
-    "postversion": "npm publish --access public"
+    "postversion": "npm publish --access public",
+    "test": "node--test"
+  },
+  "devDependencies": {
+    "test": "^3.2.1"
   }
 }

@vates/decorate-with/.USAGE.md

@@ -0,0 +1,86 @@
+### `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

@@ -10,8 +10,8 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/decorate-with):
 
-```
-> npm install --save @vates/decorate-with
+```sh
+npm install --save @vates/decorate-with
 ```
 
 ## Usage
@@ -31,15 +31,19 @@ class Foo {
 }
 ```
 
-### `decorateMethodsWith(class, map)`
+### `decorateClass(class, map)`
 
-Decorates a number of methods directly, without using the decorator syntax:
+Decorates a number of accessors and methods directly, without using the decorator syntax:
 
 ```js
-import { decorateMethodsWith } from '@vates/decorate-with'
+import { decorateClass } from '@vates/decorate-with'
 
 class Foo {
-  bar() {
+  get bar() {
+    // body
+  }
+
+  set bar(value) {
     // body
   }
 
@@ -48,28 +52,57 @@ class Foo {
   }
 }
 
-decorateMethodsWith(Foo, {
-  // without arguments
-  bar: lodash.curry,
+decorateClass(Foo, {
+  // getter and/or setter
+  bar: {
+    // without arguments
+    get: lodash.memoize,
 
-  // with arguments
-  baz: [lodash.debounce, 150],
+    // 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 a method, you can either call `decorateMethodsWith` multiple times or use [`@vates/compose`](https://www.npmjs.com/package/@vates/compose):
+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
-decorateMethodsWith(Foo, {
-  bar: compose([
+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

@@ -1,53 +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
-  }
-}
-```
-
-### `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.
-
-To apply multiple transforms to a method, you can either call `decorateMethodsWith` multiple times or use [`@vates/compose`](https://www.npmjs.com/package/@vates/compose):
-
-```js
-decorateMethodsWith(Foo, {
-  bar: compose([
-    [lodash.debounce, 150]
-    lodash.curry,
-  ])
-})
-```

@vates/decorate-with/index.js

@@ -1,3 +1,5 @@
+'use strict'
+
 exports.decorateWith = function decorateWith(fn, ...args) {
   return (target, name, descriptor) => ({
     ...descriptor,
@@ -7,15 +9,40 @@ exports.decorateWith = function decorateWith(fn, ...args) {
 
 const { getOwnPropertyDescriptor, defineProperty } = Object
 
-exports.decorateMethodsWith = function decorateMethodsWith(klass, map) {
+function applyDecorator(decorator, value) {
+  return typeof decorator === 'function' ? decorator(value) : decorator[0](value, ...decorator.slice(1))
+}
+
+exports.decorateClass = exports.decorateMethodsWith = function decorateClass(klass, map) {
   const { prototype } = klass
   for (const name of Object.keys(map)) {
-    const descriptor = getOwnPropertyDescriptor(prototype, name)
-    const { value } = descriptor
-
     const decorator = map[name]
-    descriptor.value = typeof decorator === 'function' ? decorator(value) : decorator[0](value, ...decorator.slice(1))
+    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)
+      }
+    }
+
     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.test.js

@@ -0,0 +1,152 @@
+'use strict'
+
+const assert = require('assert')
+const { describe, it } = require('test')
+
+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,11 +20,15 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "0.1.0",
+  "version": "2.0.0",
   "engines": {
     "node": ">=8.10"
   },
   "scripts": {
-    "postversion": "npm publish --access public"
+    "postversion": "npm publish --access public",
+    "test": "node--test"
+  },
+  "devDependencies": {
+    "test": "^3.2.1"
   }
 }

@vates/diff/.USAGE.md

@@ -0,0 +1,32 @@
+```js
+import diff from '@vates/diff'
+
+diff('foo bar baz', 'Foo qux')
+// → [ 0, 'F', 4, 'qux', 7, '' ]
+//
+// Differences of the second string from the first one:
+// - at position 0, it contains `F`
+// - at position 4, it contains `qux`
+// - at position 7, it ends
+
+diff('Foo qux', 'foo bar baz')
+// → [ 0, 'f', 4, 'bar', 7, ' baz' ]
+//
+// Differences of the second string from the first one:
+// - at position 0, it contains f`
+// - at position 4, it contains `bar`
+// - at position 7, it contains `baz`
+
+// works with all collections that supports
+// - `.length`
+// - `collection[index]`
+// - `.slice(start, end)`
+//
+// which includes:
+// - arrays
+// - strings
+// - `Buffer`
+// - `TypedArray`
+diff([0, 1, 2], [3, 4])
+// → [ 0, [ 3, 4 ], 2, [] ]
+```

@vates/diff/.npmignore

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

@vates/diff/README.md

@@ -0,0 +1,65 @@
+<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
+
+# @vates/diff
+
+[![Package Version](https://badgen.net/npm/v/@vates/diff)](https://npmjs.org/package/@vates/diff) ![License](https://badgen.net/npm/license/@vates/diff) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/diff)](https://bundlephobia.com/result?p=@vates/diff) [![Node compatibility](https://badgen.net/npm/node/@vates/diff)](https://npmjs.org/package/@vates/diff)
+
+> Computes differences between two arrays, buffers or strings
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/@vates/diff):
+
+```sh
+npm install --save @vates/diff
+```
+
+## Usage
+
+```js
+import diff from '@vates/diff'
+
+diff('foo bar baz', 'Foo qux')
+// → [ 0, 'F', 4, 'qux', 7, '' ]
+//
+// Differences of the second string from the first one:
+// - at position 0, it contains `F`
+// - at position 4, it contains `qux`
+// - at position 7, it ends
+
+diff('Foo qux', 'foo bar baz')
+// → [ 0, 'f', 4, 'bar', 7, ' baz' ]
+//
+// Differences of the second string from the first one:
+// - at position 0, it contains f`
+// - at position 4, it contains `bar`
+// - at position 7, it contains `baz`
+
+// works with all collections that supports
+// - `.length`
+// - `collection[index]`
+// - `.slice(start, end)`
+//
+// which includes:
+// - arrays
+// - strings
+// - `Buffer`
+// - `TypedArray`
+diff([0, 1, 2], [3, 4])
+// → [ 0, [ 3, 4 ], 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/diff/index.js

@@ -0,0 +1,37 @@
+'use strict'
+
+/**
+ * Compare two data arrays, buffers or strings and invoke the provided callback function for each difference.
+ *
+ * @template {Array|Buffer|string} T
+ * @param {Array|Buffer|string} data1 - The first data array or buffer to compare.
+ * @param {T} data2 - The second data array or buffer to compare.
+ * @param {(index: number, diff: T) => void} [cb] - The callback function to invoke for each difference. If not provided, an array of differences will be returned.
+ * @returns {Array<number|T>|undefined} - An array of differences if no callback is provided, otherwise undefined.
+ */
+module.exports = function diff(data1, data2, cb) {
+  let result
+  if (cb === undefined) {
+    result = []
+    cb = result.push.bind(result)
+  }
+
+  const n1 = data1.length
+  const n2 = data2.length
+  const n = Math.min(n1, n2)
+  for (let i = 0; i < n; ++i) {
+    if (data1[i] !== data2[i]) {
+      let j = i + 1
+      while (j < n && data1[j] !== data2[j]) {
+        ++j
+      }
+      cb(i, data2.slice(i, j))
+      i = j
+    }
+  }
+  if (n1 !== n2) {
+    cb(n, n1 < n2 ? data2.slice(n) : data2.slice(0, 0))
+  }
+
+  return result
+}

@vates/diff/index.test.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const test = require('test')
+
+const diff = require('./index.js')
+
+test('data of equal length', function () {
+  const data1 = 'foo bar baz'
+  const data2 = 'baz bar foo'
+  assert.deepEqual(diff(data1, data2), [0, 'baz', 8, 'foo'])
+})
+
+test('data1 is longer', function () {
+  const data1 = 'foo bar'
+  const data2 = 'foo'
+  assert.deepEqual(diff(data1, data2), [3, ''])
+})
+
+test('data2 is longer', function () {
+  const data1 = 'foo'
+  const data2 = 'foo bar'
+  assert.deepEqual(diff(data1, data2), [3, ' bar'])
+})
+
+test('with arrays', function () {
+  const data1 = 'foo bar baz'.split('')
+  const data2 = 'baz bar foo'.split('')
+  assert.deepEqual(diff(data1, data2), [0, 'baz'.split(''), 8, 'foo'.split('')])
+})
+
+test('with buffers', function () {
+  const data1 = Buffer.from('foo bar baz')
+  const data2 = Buffer.from('baz bar foo')
+  assert.deepEqual(diff(data1, data2), [0, Buffer.from('baz'), 8, Buffer.from('foo')])
+})
+
+test('cb param', function () {
+  const data1 = 'foo bar baz'
+  const data2 = 'baz bar foo'
+
+  const calls = []
+  const cb = (...args) => calls.push(args)
+
+  diff(data1, data2, cb)
+
+  assert.deepEqual(calls, [
+    [0, 'baz'],
+    [8, 'foo'],
+  ])
+})

@vates/diff/package.json

@@ -0,0 +1,36 @@
+{
+  "private": false,
+  "name": "@vates/diff",
+  "description": "Computes differences between two arrays, buffers or strings",
+  "keywords": [
+    "array",
+    "binary",
+    "buffer",
+    "diff",
+    "differences",
+    "string"
+  ],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/diff",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "directory": "@vates/diff",
+    "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",
+    "test": "node--test"
+  },
+  "devDependencies": {
+    "test": "^3.3.0"
+  }
+}

@vates/disposable/README.md

@@ -10,8 +10,8 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/disposable):
 
-```
-> npm install --save @vates/disposable
+```sh
+npm install --save @vates/disposable
 ```
 
 ## Usage

@vates/disposable/debounceResource.js

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

@vates/disposable/debounceResource.test.js

@@ -1,14 +1,17 @@
-/* eslint-env jest */
+'use strict'
+
+const { describe, it } = require('test')
+const { useFakeTimers, spy, assert } = require('sinon')
 
 const { createDebounceResource } = require('./debounceResource')
 
-jest.useFakeTimers()
+const clock = useFakeTimers()
 
 describe('debounceResource()', () => {
   it('calls the resource disposer after 10 seconds', async () => {
     const debounceResource = createDebounceResource()
     const delay = 10e3
-    const dispose = jest.fn()
+    const dispose = spy()
 
     const resource = await debounceResource(
       Promise.resolve({
@@ -20,10 +23,10 @@ describe('debounceResource()', () => {
 
     resource.dispose()
 
-    expect(dispose).not.toBeCalled()
+    assert.notCalled(dispose)
 
-    jest.advanceTimersByTime(delay)
+    clock.tick(delay)
 
-    expect(dispose).toBeCalled()
+    assert.called(dispose)
   })
 })

@vates/disposable/deduped.js

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

@vates/disposable/deduped.test.js

@@ -1,11 +1,14 @@
-/* eslint-env jest */
+'use strict'
+
+const { describe, it } = require('test')
+const { spy, assert } = require('sinon')
 
 const { deduped } = require('./deduped')
 
 describe('deduped()', () => {
   it('calls the resource function only once', async () => {
     const value = {}
-    const getResource = jest.fn(async () => ({
+    const getResource = spy(async () => ({
       value,
       dispose: Function.prototype,
     }))
@@ -15,13 +18,13 @@ describe('deduped()', () => {
     const { value: v1 } = await dedupedGetResource()
     const { value: v2 } = await dedupedGetResource()
 
-    expect(getResource).toHaveBeenCalledTimes(1)
-    expect(v1).toBe(value)
-    expect(v2).toBe(value)
+    assert.calledOnce(getResource)
+    assert.match(v1, value)
+    assert.match(v2, value)
   })
 
   it('only disposes the source disposable when its all copies dispose', async () => {
-    const dispose = jest.fn()
+    const dispose = spy()
     const getResource = async () => ({
       value: '',
       dispose,
@@ -34,35 +37,35 @@ describe('deduped()', () => {
 
     d1()
 
-    expect(dispose).not.toHaveBeenCalled()
+    assert.notCalled(dispose)
 
     d2()
 
-    expect(dispose).toHaveBeenCalledTimes(1)
+    assert.calledOnce(dispose)
   })
 
   it('works with sync factory', () => {
     const value = {}
-    const dispose = jest.fn()
+    const dispose = spy()
     const dedupedGetResource = deduped(() => ({ value, dispose }))
 
     const d1 = dedupedGetResource()
-    expect(d1.value).toBe(value)
+    assert.match(d1.value, value)
 
     const d2 = dedupedGetResource()
-    expect(d2.value).toBe(value)
+    assert.match(d2.value, value)
 
     d1.dispose()
 
-    expect(dispose).not.toHaveBeenCalled()
+    assert.notCalled(dispose)
 
     d2.dispose()
 
-    expect(dispose).toHaveBeenCalledTimes(1)
+    assert.calledOnce(dispose)
   })
 
   it('no race condition on dispose before async acquisition', async () => {
-    const dispose = jest.fn()
+    const dispose = spy()
     const dedupedGetResource = deduped(async () => ({ value: 42, dispose }))
 
     const d1 = await dedupedGetResource()
@@ -71,6 +74,6 @@ describe('deduped()', () => {
 
     d1.dispose()
 
-    expect(dispose).not.toHaveBeenCalled()
+    assert.notCalled(dispose)
   })
 })

@vates/disposable/package.json

@@ -14,17 +14,22 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "engines": {
     "node": ">=8.10"
   },
   "scripts": {
-    "postversion": "npm publish --access public"
+    "postversion": "npm publish --access public",
+    "test": "node--test"
   },
   "dependencies": {
     "@vates/multi-key-map": "^0.1.0",
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/log": "^0.3.0",
+    "@xen-orchestra/log": "^0.6.0",
     "ensure-array": "^1.0.0"
+  },
+  "devDependencies": {
+    "sinon": "^15.0.1",
+    "test": "^3.2.1"
   }
 }

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

@@ -0,0 +1,50 @@
+> 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

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

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

@@ -0,0 +1,81 @@
+<!-- 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):
+
+```sh
+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

@@ -0,0 +1,56 @@
+'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.get(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/index.spec.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const t = require('tap')
+const { EventEmitter } = require('events')
+
+const { EventListenersManager } = require('./')
+
+const noop = Function.prototype
+
+// function spy (impl = Function.prototype) {
+//   function spy() {
+//     spy.calls.push([Array.from(arguments), this])
+//   }
+//   spy.calls = []
+//   return spy
+// }
+
+function assertListeners(t, event, listeners) {
+  t.strictSame(t.context.ee.listeners(event), listeners)
+}
+
+t.beforeEach(function (t) {
+  t.context.ee = new EventEmitter()
+  t.context.em = new EventListenersManager(t.context.ee)
+})
+
+t.test('.add adds a listener', function (t) {
+  t.context.em.add('foo', noop)
+
+  assertListeners(t, 'foo', [noop])
+
+  t.end()
+})
+
+t.test('.add does not add a duplicate listener', function (t) {
+  t.context.em.add('foo', noop).add('foo', noop)
+
+  assertListeners(t, 'foo', [noop])
+
+  t.end()
+})
+
+t.test('.remove removes a listener', function (t) {
+  t.context.em.add('foo', noop).remove('foo', noop)
+
+  assertListeners(t, 'foo', [])
+
+  t.end()
+})
+
+t.test('.removeAll removes all listeners of a given type', function (t) {
+  t.context.em.add('foo', noop).add('bar', noop).removeAll('foo')
+
+  assertListeners(t, 'foo', [])
+  assertListeners(t, 'bar', [noop])
+
+  t.end()
+})
+
+t.test('.removeAll removes all listeners', function (t) {
+  t.context.em.add('foo', noop).add('bar', noop).removeAll()
+
+  assertListeners(t, 'foo', [])
+  assertListeners(t, 'bar', [])
+
+  t.end()
+})

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

@@ -0,0 +1,46 @@
+{
+  "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.1",
+  "scripts": {
+    "postversion": "npm publish --access public",
+    "test": "tap --branches=72"
+  },
+  "devDependencies": {
+    "tap": "^16.2.0"
+  }
+}

@vates/fuse-vhd/.npmignore

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

@vates/fuse-vhd/index.mjs

@@ -0,0 +1,64 @@
+import LRU from 'lru-cache'
+import Fuse from 'fuse-native'
+import { VhdSynthetic } from 'vhd-lib'
+import { Disposable, fromCallback } from 'promise-toolbox'
+
+// build a s stat object from https://github.com/fuse-friends/fuse-native/blob/master/test/fixtures/stat.js
+const stat = st => ({
+  mtime: st.mtime || new Date(),
+  atime: st.atime || new Date(),
+  ctime: st.ctime || new Date(),
+  size: st.size !== undefined ? st.size : 0,
+  mode: st.mode === 'dir' ? 16877 : st.mode === 'file' ? 33188 : st.mode === 'link' ? 41453 : st.mode,
+  uid: st.uid !== undefined ? st.uid : process.getuid(),
+  gid: st.gid !== undefined ? st.gid : process.getgid(),
+})
+
+export const mount = Disposable.factory(async function* mount(handler, diskPath, mountDir) {
+  const vhd = yield VhdSynthetic.fromVhdChain(handler, diskPath)
+
+  const cache = new LRU({
+    max: 16, // each cached block is 2MB in size
+  })
+  await vhd.readBlockAllocationTable()
+  const fuse = new Fuse(mountDir, {
+    async readdir(path, cb) {
+      if (path === '/') {
+        return cb(null, ['vhd0'])
+      }
+      cb(Fuse.ENOENT)
+    },
+    async getattr(path, cb) {
+      if (path === '/') {
+        return cb(
+          null,
+          stat({
+            mode: 'dir',
+            size: 4096,
+          })
+        )
+      }
+      if (path === '/vhd0') {
+        return cb(
+          null,
+          stat({
+            mode: 'file',
+            size: vhd.footer.currentSize,
+          })
+        )
+      }
+
+      cb(Fuse.ENOENT)
+    },
+    read(path, fd, buf, len, pos, cb) {
+      if (path === '/vhd0') {
+        return vhd.readRawData(pos, len, cache, buf).then(cb)
+      }
+      throw new Error(`read file ${path} not exists`)
+    },
+  })
+  return new Disposable(
+    () => fromCallback(() => fuse.unmount()),
+    fromCallback(() => fuse.mount())
+  )
+})

@vates/fuse-vhd/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@vates/fuse-vhd",
+  "version": "1.0.0",
+  "license": "ISC",
+  "private": false,
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/fuse-vhd",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "directory": "@vates/fuse-vhd",
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Vates SAS",
+    "url": "https://vates.fr"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "main": "./index.mjs",
+  "dependencies": {
+    "fuse-native": "^2.2.6",
+    "lru-cache": "^7.14.0",
+    "promise-toolbox": "^0.21.0",
+    "vhd-lib": "^4.5.0"
+  },
+  "scripts": {
+    "postversion": "npm publish --access public"
+  }
+}

@vates/multi-key-map/README.md

@@ -10,8 +10,8 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/multi-key-map):
 
-```
-> npm install --save @vates/multi-key-map
+```sh
+npm install --save @vates/multi-key-map
 ```
 
 ## Usage

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

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

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

@@ -1,4 +1,7 @@
-/* eslint-env jest */
+'use strict'
+
+const { describe, it } = require('test')
+const assert = require('node:assert')
 
 const { MultiKeyMap } = require('./')
 
@@ -26,9 +29,9 @@ describe('MultiKeyMap', () => {
 
     keys.forEach((key, i) => {
       // copy the key to make sure the array itself is not the key
-      expect(map.get(key.slice())).toBe(values[i])
+      assert.strictEqual(map.get(key.slice()), values[i])
       map.delete(key.slice())
-      expect(map.get(key.slice())).toBe(undefined)
+      assert.strictEqual(map.get(key.slice()), undefined)
     })
   })
 })

@vates/multi-key-map/package.json

@@ -23,6 +23,10 @@
     "node": ">=8.10"
   },
   "scripts": {
-    "postversion": "npm publish --access public"
+    "postversion": "npm publish --access public",
+    "test": "node--test"
+  },
+  "devDependencies": {
+    "test": "^3.2.1"
   }
 }

@vates/nbd-client/.USAGE.md

@@ -0,0 +1,16 @@
+### `new NdbClient({address, exportname, secure = true, port = 10809})`
+
+create a new nbd client
+
+```js
+import NbdClient from '@vates/nbd-client'
+const client = new NbdClient({
+  address: 'MY_NBD_HOST',
+  exportname: 'MY_SECRET_EXPORT',
+  cert: 'Server certificate', // optional, will use encrypted link if provided
+})
+
+await client.connect()
+const block = await client.readBlock(blockIndex, BlockSize)
+await client.disconnect()
+```

@vates/nbd-client/.npmignore

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

@vates/nbd-client/README.md

@@ -0,0 +1,47 @@
+<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
+
+# @vates/nbd-client
+
+[![Package Version](https://badgen.net/npm/v/@vates/nbd-client)](https://npmjs.org/package/@vates/nbd-client) ![License](https://badgen.net/npm/license/@vates/nbd-client) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/nbd-client)](https://bundlephobia.com/result?p=@vates/nbd-client) [![Node compatibility](https://badgen.net/npm/node/@vates/nbd-client)](https://npmjs.org/package/@vates/nbd-client)
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/@vates/nbd-client):
+
+```sh
+npm install --save @vates/nbd-client
+```
+
+## Usage
+
+### `new NdbClient({address, exportname, secure = true, port = 10809})`
+
+create a new nbd client
+
+```js
+import NbdClient from '@vates/nbd-client'
+const client = new NbdClient({
+  address: 'MY_NBD_HOST',
+  exportname: 'MY_SECRET_EXPORT',
+  cert: 'Server certificate', // optional, will use encrypted link if provided
+})
+
+await client.connect()
+const block = await client.readBlock(blockIndex, BlockSize)
+await client.disconnect()
+```
+
+## 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/nbd-client/constants.mjs

@@ -0,0 +1,41 @@
+export const INIT_PASSWD = Buffer.from('NBDMAGIC') // "NBDMAGIC" ensure we're connected to a nbd server
+export const OPTS_MAGIC = Buffer.from('IHAVEOPT') // "IHAVEOPT" start an option block
+export const NBD_OPT_REPLY_MAGIC = 1100100111001001n // magic received during negociation
+export const NBD_OPT_EXPORT_NAME = 1
+export const NBD_OPT_ABORT = 2
+export const NBD_OPT_LIST = 3
+export const NBD_OPT_STARTTLS = 5
+export const NBD_OPT_INFO = 6
+export const NBD_OPT_GO = 7
+
+export const NBD_FLAG_HAS_FLAGS = 1 << 0
+export const NBD_FLAG_READ_ONLY = 1 << 1
+export const NBD_FLAG_SEND_FLUSH = 1 << 2
+export const NBD_FLAG_SEND_FUA = 1 << 3
+export const NBD_FLAG_ROTATIONAL = 1 << 4
+export const NBD_FLAG_SEND_TRIM = 1 << 5
+
+export const NBD_FLAG_FIXED_NEWSTYLE = 1 << 0
+
+export const NBD_CMD_FLAG_FUA = 1 << 0
+export const NBD_CMD_FLAG_NO_HOLE = 1 << 1
+export const NBD_CMD_FLAG_DF = 1 << 2
+export const NBD_CMD_FLAG_REQ_ONE = 1 << 3
+export const NBD_CMD_FLAG_FAST_ZERO = 1 << 4
+
+export const NBD_CMD_READ = 0
+export const NBD_CMD_WRITE = 1
+export const NBD_CMD_DISC = 2
+export const NBD_CMD_FLUSH = 3
+export const NBD_CMD_TRIM = 4
+export const NBD_CMD_CACHE = 5
+export const NBD_CMD_WRITE_ZEROES = 6
+export const NBD_CMD_BLOCK_STATUS = 7
+export const NBD_CMD_RESIZE = 8
+
+export const NBD_REQUEST_MAGIC = 0x25609513 // magic number to create a new NBD request to send to the server
+export const NBD_REPLY_MAGIC = 0x67446698 // magic number received from the server when reading response to a nbd request
+export const NBD_REPLY_ACK = 1
+
+export const NBD_DEFAULT_PORT = 10809
+export const NBD_DEFAULT_BLOCK_SIZE = 64 * 1024

@vates/nbd-client/index.mjs

@@ -0,0 +1,351 @@
+import assert from 'node:assert'
+import { Socket } from 'node:net'
+import { connect } from 'node:tls'
+import { fromCallback, pRetry, pDelay, pTimeout } from 'promise-toolbox'
+import { readChunkStrict } from '@vates/read-chunk'
+import { createLogger } from '@xen-orchestra/log'
+
+import {
+  INIT_PASSWD,
+  NBD_CMD_READ,
+  NBD_DEFAULT_BLOCK_SIZE,
+  NBD_DEFAULT_PORT,
+  NBD_FLAG_FIXED_NEWSTYLE,
+  NBD_FLAG_HAS_FLAGS,
+  NBD_OPT_EXPORT_NAME,
+  NBD_OPT_REPLY_MAGIC,
+  NBD_OPT_STARTTLS,
+  NBD_REPLY_ACK,
+  NBD_REPLY_MAGIC,
+  NBD_REQUEST_MAGIC,
+  OPTS_MAGIC,
+  NBD_CMD_DISC,
+} from './constants.mjs'
+
+const { warn } = createLogger('vates:nbd-client')
+
+// documentation is here : https://github.com/NetworkBlockDevice/nbd/blob/master/doc/proto.md
+
+export default class NbdClient {
+  #serverAddress
+  #serverCert
+  #serverPort
+  #serverSocket
+
+  #exportName
+  #exportSize
+
+  #waitBeforeReconnect
+  #readAhead
+  #readBlockRetries
+  #reconnectRetry
+  #connectTimeout
+
+  // AFAIK, there is no guaranty the server answers in the same order as the queries
+  // so we handle a backlog of command waiting for response and handle concurrency manually
+
+  #waitingForResponse // there is already a listenner waiting for a response
+  #nextCommandQueryId = BigInt(0)
+  #commandQueryBacklog // map of command waiting for an response queryId => { size/*in byte*/, resolve, reject}
+  #connected = false
+
+  #reconnectingPromise
+  constructor(
+    { address, port = NBD_DEFAULT_PORT, exportname, cert },
+    { connectTimeout = 6e4, waitBeforeReconnect = 1e3, readAhead = 10, readBlockRetries = 5, reconnectRetry = 5 } = {}
+  ) {
+    this.#serverAddress = address
+    this.#serverPort = port
+    this.#exportName = exportname
+    this.#serverCert = cert
+    this.#waitBeforeReconnect = waitBeforeReconnect
+    this.#readAhead = readAhead
+    this.#readBlockRetries = readBlockRetries
+    this.#reconnectRetry = reconnectRetry
+    this.#connectTimeout = connectTimeout
+  }
+
+  get exportSize() {
+    return this.#exportSize
+  }
+
+  async #tlsConnect() {
+    return new Promise((resolve, reject) => {
+      this.#serverSocket = connect({
+        socket: this.#serverSocket,
+        rejectUnauthorized: false,
+        cert: this.#serverCert,
+      })
+      this.#serverSocket.once('error', reject)
+      this.#serverSocket.once('secureConnect', () => {
+        this.#serverSocket.removeListener('error', reject)
+        resolve()
+      })
+    })
+  }
+
+  // mandatory , at least to start the handshake
+  async #unsecureConnect() {
+    this.#serverSocket = new Socket()
+    return new Promise((resolve, reject) => {
+      this.#serverSocket.connect(this.#serverPort, this.#serverAddress)
+      this.#serverSocket.once('error', reject)
+      this.#serverSocket.once('connect', () => {
+        this.#serverSocket.removeListener('error', reject)
+        resolve()
+      })
+    })
+  }
+
+  async #connect() {
+    // first we connect to the server without tls, and then we upgrade the connection
+    // to tls during the handshake
+    await this.#unsecureConnect()
+    await this.#handshake()
+    this.#connected = true
+    // reset internal state if we reconnected a nbd client
+    this.#commandQueryBacklog = new Map()
+    this.#waitingForResponse = false
+  }
+  async connect() {
+    return pTimeout.call(this.#connect(), this.#connectTimeout)
+  }
+
+  async disconnect() {
+    if (!this.#connected) {
+      return
+    }
+
+    const buffer = Buffer.alloc(28)
+    buffer.writeInt32BE(NBD_REQUEST_MAGIC, 0) // it is a nbd request
+    buffer.writeInt16BE(0, 4) // no command flags for a disconnect
+    buffer.writeInt16BE(NBD_CMD_DISC, 6) // we want to disconnect from nbd server
+    await this.#write(buffer)
+    await this.#serverSocket.destroy()
+    this.#serverSocket = undefined
+    this.#connected = false
+  }
+
+  #clearReconnectPromise = () => {
+    this.#reconnectingPromise = undefined
+  }
+
+  async #reconnect() {
+    await this.disconnect().catch(() => {})
+    await pDelay(this.#waitBeforeReconnect) // need to let the xapi clean things on its side
+    await this.connect()
+  }
+
+  async reconnect() {
+    // we need to ensure reconnections do not occur in parallel
+    if (this.#reconnectingPromise === undefined) {
+      this.#reconnectingPromise = pRetry(() => this.#reconnect(), {
+        tries: this.#reconnectRetry,
+      })
+      this.#reconnectingPromise.then(this.#clearReconnectPromise, this.#clearReconnectPromise)
+    }
+
+    return this.#reconnectingPromise
+  }
+
+  // we can use individual read/write from the socket here since there is no concurrency
+  async #sendOption(option, buffer = Buffer.alloc(0)) {
+    await this.#write(OPTS_MAGIC)
+    await this.#writeInt32(option)
+    await this.#writeInt32(buffer.length)
+    await this.#write(buffer)
+    assert.strictEqual(await this.#readInt64(), NBD_OPT_REPLY_MAGIC) // magic number everywhere
+    assert.strictEqual(await this.#readInt32(), option) // the option passed
+    assert.strictEqual(await this.#readInt32(), NBD_REPLY_ACK) // ACK
+    const length = await this.#readInt32()
+    assert.strictEqual(length, 0) // length
+  }
+
+  // we can use individual read/write from the socket here since there is only one handshake at once, no concurrency
+  async #handshake() {
+    assert((await this.#read(8)).equals(INIT_PASSWD))
+    assert((await this.#read(8)).equals(OPTS_MAGIC))
+    const flagsBuffer = await this.#read(2)
+    const flags = flagsBuffer.readInt16BE(0)
+    assert.strictEqual(flags & NBD_FLAG_FIXED_NEWSTYLE, NBD_FLAG_FIXED_NEWSTYLE) // only FIXED_NEWSTYLE one is supported from the server options
+    await this.#writeInt32(NBD_FLAG_FIXED_NEWSTYLE) // client also support  NBD_FLAG_C_FIXED_NEWSTYLE
+
+    if (this.#serverCert !== undefined) {
+      // upgrade socket to TLS if needed
+      await this.#sendOption(NBD_OPT_STARTTLS)
+      await this.#tlsConnect()
+    }
+
+    // send export name we want to access.
+    // it's  implictly closing the negociation phase.
+    await this.#write(OPTS_MAGIC)
+    await this.#writeInt32(NBD_OPT_EXPORT_NAME)
+    const exportNameBuffer = Buffer.from(this.#exportName)
+    await this.#writeInt32(exportNameBuffer.length)
+    await this.#write(exportNameBuffer)
+
+    // 8 (export size ) + 2 (flags) + 124 zero = 134
+    // must read all to ensure nothing stays in the  buffer
+    const answer = await this.#read(134)
+    this.#exportSize = answer.readBigUInt64BE(0)
+    const transmissionFlags = answer.readInt16BE(8)
+    assert.strictEqual(transmissionFlags & NBD_FLAG_HAS_FLAGS, NBD_FLAG_HAS_FLAGS, 'NBD_FLAG_HAS_FLAGS') // must always be 1 by the norm
+
+    // note : xapi server always send NBD_FLAG_READ_ONLY (3) as a flag
+  }
+
+  #read(length) {
+    return readChunkStrict(this.#serverSocket, length)
+  }
+
+  #write(buffer) {
+    return fromCallback.call(this.#serverSocket, 'write', buffer)
+  }
+
+  async #readInt32() {
+    const buffer = await this.#read(4)
+    return buffer.readInt32BE(0)
+  }
+
+  async #readInt64() {
+    const buffer = await this.#read(8)
+    return buffer.readBigUInt64BE(0)
+  }
+
+  #writeInt32(int) {
+    const buffer = Buffer.alloc(4)
+    buffer.writeInt32BE(int)
+    return this.#write(buffer)
+  }
+
+  // when one read fail ,stop everything
+  async #rejectAll(error) {
+    this.#commandQueryBacklog.forEach(({ reject }) => {
+      reject(error)
+    })
+  }
+
+  async #readBlockResponse() {
+    // ensure at most one read occur in parallel
+    if (this.#waitingForResponse) {
+      return
+    }
+    try {
+      this.#waitingForResponse = true
+      const magic = await this.#readInt32()
+
+      if (magic !== NBD_REPLY_MAGIC) {
+        throw new Error(`magic number for block answer is wrong : ${magic} ${NBD_REPLY_MAGIC}`)
+      }
+
+      const error = await this.#readInt32()
+      if (error !== 0) {
+        // @todo use error code from constants.mjs
+        throw new Error(`GOT ERROR CODE  : ${error}`)
+      }
+
+      const blockQueryId = await this.#readInt64()
+      const query = this.#commandQueryBacklog.get(blockQueryId)
+      if (!query) {
+        throw new Error(` no query associated with id ${blockQueryId}`)
+      }
+      this.#commandQueryBacklog.delete(blockQueryId)
+      const data = await this.#read(query.size)
+      query.resolve(data)
+      this.#waitingForResponse = false
+      if (this.#commandQueryBacklog.size > 0) {
+        // it doesn't throw directly but will throw all relevant promise on failure
+        this.#readBlockResponse()
+      }
+    } catch (error) {
+      // reject all the promises
+      // we don't need to call readBlockResponse on failure
+      // since we will empty the backlog
+      await this.#rejectAll(error)
+    }
+  }
+
+  async readBlock(index, size = NBD_DEFAULT_BLOCK_SIZE) {
+    // we don't want to add anything in backlog while reconnecting
+    if (this.#reconnectingPromise) {
+      await this.#reconnectingPromise
+    }
+
+    const queryId = this.#nextCommandQueryId
+    this.#nextCommandQueryId++
+
+    // create and send  command at once to ensure there is no concurrency issue
+    const buffer = Buffer.alloc(28)
+    buffer.writeInt32BE(NBD_REQUEST_MAGIC, 0) // it is a nbd request
+    buffer.writeInt16BE(0, 4) // no command flags for a simple block read
+    buffer.writeInt16BE(NBD_CMD_READ, 6) // we want to read a data block
+    buffer.writeBigUInt64BE(queryId, 8)
+    // byte offset in the raw disk
+    buffer.writeBigUInt64BE(BigInt(index) * BigInt(size), 16)
+    buffer.writeInt32BE(size, 24)
+
+    return new Promise((resolve, reject) => {
+      function decoratedReject(error) {
+        error.index = index
+        error.size = size
+        reject(error)
+      }
+
+      // this will handle one block response, but it can be another block
+      // since server does not guaranty to handle query in order
+      this.#commandQueryBacklog.set(queryId, {
+        size,
+        resolve,
+        reject: decoratedReject,
+      })
+      // really send the command to the server
+      this.#write(buffer).catch(decoratedReject)
+
+      // #readBlockResponse never throws directly
+      // but if it fails it will reject all the promises in the backlog
+      this.#readBlockResponse()
+    })
+  }
+
+  async *readBlocks(indexGenerator) {
+    // default : read all blocks
+    if (indexGenerator === undefined) {
+      const exportSize = this.#exportSize
+      const chunkSize = 2 * 1024 * 1024
+      indexGenerator = function* () {
+        const nbBlocks = Math.ceil(Number(exportSize / BigInt(chunkSize)))
+        for (let index = 0; BigInt(index) < nbBlocks; index++) {
+          yield { index, size: chunkSize }
+        }
+      }
+    }
+    const readAhead = []
+    const readAheadMaxLength = this.#readAhead
+    const makeReadBlockPromise = (index, size) => {
+      const promise = pRetry(() => this.readBlock(index, size), {
+        tries: this.#readBlockRetries,
+        onRetry: async err => {
+          warn('will retry reading block ', index, err)
+          await this.reconnect()
+        },
+      })
+      // error is handled during unshift
+      promise.catch(() => {})
+      return promise
+    }
+
+    // read all blocks, but try to keep readAheadMaxLength promise waiting ahead
+    for (const { index, size } of indexGenerator()) {
+      // stack readAheadMaxLength promises before starting to handle the results
+      if (readAhead.length === readAheadMaxLength) {
+        // any error will stop reading blocks
+        yield readAhead.shift()
+      }
+
+      readAhead.push(makeReadBlockPromise(index, size))
+    }
+    while (readAhead.length > 0) {
+      yield readAhead.shift()
+    }
+  }
+}

@vates/nbd-client/package.json

@@ -0,0 +1,37 @@
+{
+  "private": false,
+  "name": "@vates/nbd-client",
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/nbd-client",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "repository": {
+    "directory": "@vates/nbd-client",
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Vates SAS",
+    "url": "https://vates.fr"
+  },
+  "license": "ISC",
+  "version": "1.2.1",
+  "engines": {
+    "node": ">=14.0"
+  },
+  "main": "./index.mjs",
+  "dependencies": {
+    "@vates/async-each": "^1.0.0",
+    "@vates/read-chunk": "^1.1.1",
+    "@xen-orchestra/async-map": "^0.1.2",
+    "@xen-orchestra/log": "^0.6.0",
+    "promise-toolbox": "^0.21.0",
+    "xen-api": "^1.3.3"
+  },
+  "devDependencies": {
+    "tap": "^16.3.0",
+    "tmp": "^0.2.1"
+  },
+  "scripts": {
+    "postversion": "npm publish --access public",
+    "test-integration": "tap --lines 97 --functions 95 --branches 74 --statements 97 tests/*.integ.mjs"
+  }
+}

@vates/nbd-client/tests/ca-cert.pem

@@ -0,0 +1,182 @@
+Public Key Info:
+	Public Key Algorithm: RSA
+	Key Security Level: High (3072 bits)
+
+modulus:
+	00:be:92:be:df:de:0a:ab:38:fc:1a:c0:1a:58:4d:86
+	b8:1f:25:10:7d:19:05:17:bf:02:3d:e9:ef:f8:c0:04
+	5d:6f:98:de:5c:dd:c3:0f:e2:61:61:e4:b5:9c:42:ac
+	3e:af:fd:30:10:e1:54:32:66:75:f6:80:90:85:05:a0
+	6a:14:a2:6f:a7:2e:f0:f3:52:94:2a:f2:34:fc:0d:b4
+	fb:28:5d:1c:11:5c:59:6e:63:34:ba:b3:fd:73:b1:48
+	35:00:84:53:da:6a:9b:84:ab:64:b1:a1:2b:3a:d1:5a
+	d7:13:7c:12:2a:4e:72:e9:96:d6:30:74:c5:71:05:14
+	4b:2d:01:94:23:67:4e:37:3c:1e:c1:a0:bc:34:04:25
+	21:11:fb:4b:6b:53:74:8f:90:93:57:af:7f:3b:78:d6
+	a4:87:fe:7d:ed:20:11:8b:70:54:67:b8:c9:f5:c0:6b
+	de:4e:e7:a5:79:ff:f7:ad:cf:10:57:f5:51:70:7b:54
+	68:28:9e:b9:c2:10:7b:ab:aa:11:47:9f:ec:e6:2f:09
+	44:4a:88:5b:dd:8c:10:b4:c4:03:25:06:d9:e0:9f:a0
+	0d:cf:94:4b:3b:fa:a5:17:2c:e4:67:c4:17:6a:ab:d8
+	c8:7a:16:41:b9:91:b7:9c:ae:8c:94:be:26:61:51:71
+	c1:a6:39:39:97:75:28:a9:0e:21:ea:f0:bd:71:4a:8c
+	e1:f8:1d:a9:22:2f:10:a8:1b:e5:a4:9a:fd:0f:fa:c6
+	20:bc:96:99:79:c6:ba:a4:1f:3e:d4:91:c5:af:bb:71
+	0a:5a:ef:69:9c:64:69:ce:5a:fe:3f:c2:24:f4:26:d4
+	3d:ab:ab:9a:f0:f6:f1:b1:64:a9:f4:e2:34:6a:ab:2e
+	95:47:b9:07:5a:39:c6:95:9c:a9:e8:ed:71:dd:c1:21
+	16:c8:2d:4c:2c:af:06:9d:c6:fa:fe:c5:2a:6c:b4:c3
+	d5:96:fc:5e:fd:ec:1c:30:b4:9d:cb:29:ef:a8:50:1c
+	21:
+
+public exponent:
+	01:00:01:
+
+private exponent:
+	25:37:c5:7d:35:01:02:65:73:9e:c9:cb:9b:59:30:a9
+	3e:b3:df:5f:7f:06:66:97:d0:19:45:59:af:4b:d8:ce
+	62:a0:09:35:3b:bd:ff:99:27:89:95:bf:fe:0f:6b:52
+	26:ce:9c:97:7f:5a:11:29:bf:79:ef:ab:c9:be:ca:90
+	4d:0d:58:1e:df:65:01:30:2c:6d:a2:b5:c4:4f:ec:fb
+	6b:eb:9b:32:ac:c5:6e:70:83:78:be:f4:0d:a7:1e:c1
+	f3:22:e4:b9:70:3e:85:0f:6f:ef:dc:d8:f3:78:b5:73
+	f1:83:36:8c:fa:9b:28:91:63:ad:3c:f0:de:5c:ae:94
+	eb:ea:36:03:20:06:bf:74:c7:50:eb:52:36:1a:65:21
+	eb:40:17:7f:93:61:dd:33:d0:02:bc:ec:6d:31:f1:41
+	5a:a9:d1:f0:00:66:4c:c4:18:47:d5:67:e3:cd:bb:83
+	44:07:ab:62:83:21:dc:d8:e6:89:37:08:bb:9d:ea:62
+	c2:5d:ce:85:c2:dc:48:27:0c:a4:23:61:b7:30:e7:26
+	44:dc:1e:5c:2e:16:35:2b:2e:a6:e6:a4:ce:1f:9b:e9
+	fe:96:fa:49:1d:fb:2a:df:bc:bf:46:da:52:f8:37:8a
+	84:ab:e4:73:e6:46:56:b5:b4:3d:e1:63:eb:02:8e:d7
+	67:96:c4:dc:28:6d:6b:b6:0c:a3:0b:db:87:29:ad:f9
+	ec:73:b6:55:a3:40:32:13:84:c7:2f:33:74:04:dc:42
+	00:11:9c:fb:fc:62:35:b3:82:c3:3c:28:80:e8:09:a8
+	97:c7:c1:2e:3d:27:fa:4f:9b:fc:c2:34:58:41:5c:a1
+	e2:70:2e:2f:82:ad:bd:bd:8e:dd:23:12:25:de:89:70
+	60:75:48:90:80:ac:55:74:51:6f:49:9e:7f:63:41:8b
+	3c:b1:f5:c3:6b:4b:5a:50:a6:4d:38:e8:82:c2:04:c8
+	30:fd:06:9b:c1:04:27:b6:63:3a:5e:f5:4d:00:c3:d1
+	
+
+prime1:
+	00:f6:00:2e:7d:89:61:24:16:5e:87:ca:18:6c:03:b8
+	b4:33:df:4a:a7:7f:db:ed:39:15:41:12:61:4f:4e:b4
+	de:ab:29:d9:0c:6c:01:7e:53:2e:ee:e7:5f:a2:e4:6d
+	c6:4b:07:4e:d8:a3:ae:45:06:97:bd:18:a3:e9:dd:29
+	54:64:6d:f0:af:08:95:ae:ae:3e:71:63:76:2a:a1:18
+	c4:b1:fc:bc:3d:42:15:74:b3:c5:38:1f:5d:92:f1:b2
+	c6:3f:10:fe:35:1a:c6:b1:ce:70:38:ff:08:5c:de:61
+	79:c7:50:91:22:4d:e9:c8:18:49:e2:5c:91:84:86:e2
+	4d:0f:6e:9b:0d:81:df:aa:f3:59:75:56:e9:33:18:dd
+	ab:39:da:e2:25:01:05:a1:6e:23:59:15:2c:89:35:c7
+	ae:9c:c7:ea:88:9a:1a:f3:48:07:11:82:59:79:8c:62
+	53:06:37:30:14:b3:82:b1:50:fc:ae:b8:f7:1c:57:44
+	7d:
+
+prime2:
+	00:c6:51:cc:dc:88:2e:cf:98:90:10:19:e0:d3:a4:d1
+	3f:dc:b0:29:d3:bb:26:ee:eb:00:17:17:d1:d1:bb:9b
+	34:b1:4e:af:b5:6c:1c:54:53:b4:bb:55:da:f7:78:cd
+	38:b4:2e:3a:8c:63:80:3b:64:9c:b4:2b:cd:dd:50:0b
+	05:d2:00:7a:df:8e:c3:e6:29:e0:9c:d8:40:b7:11:09
+	f4:38:df:f6:ed:93:1e:18:d4:93:fa:8d:ee:82:9c:0f
+	c1:88:26:84:9d:4f:ae:8a:17:d5:55:54:4c:c6:0a:ac
+	4d:ec:33:51:68:0f:4b:92:2e:04:57:fe:15:f5:00:46
+	5c:8e:ad:09:2c:e7:df:d5:36:7a:4e:bd:da:21:22:d7
+	58:b4:72:93:94:af:34:cc:e2:b8:d0:4f:0b:5d:97:08
+	12:19:17:34:c5:15:49:00:48:56:13:b8:45:4e:3b:f8
+	bc:d5:ab:d9:6d:c2:4a:cc:01:1a:53:4d:46:50:49:3b
+	75:
+
+coefficient:
+	63:67:50:29:10:6a:85:a3:dc:51:90:20:76:86:8c:83
+	8e:d5:ff:aa:75:fd:b5:f8:31:b0:96:6c:18:1d:5b:ed
+	a4:2e:47:8d:9c:c2:1e:2c:a8:6d:4b:10:a5:c2:53:46
+	8a:9a:84:91:d7:fc:f5:cc:03:ce:b9:3d:5c:01:d2:27
+	99:7b:79:89:4f:a1:12:e3:05:5d:ee:10:f6:8c:e6:ce
+	5e:da:32:56:6d:6f:eb:32:b4:75:7b:94:49:d8:2d:9e
+	4d:19:59:2e:e4:0b:bc:95:df:df:65:67:a1:dd:c6:2b
+	99:f4:76:e8:9f:fa:57:1d:ca:f9:58:a9:ce:9b:30:5c
+	42:8a:ba:05:e7:e2:15:45:25:bc:e9:68:c1:8b:1a:37
+	cc:e1:aa:45:2e:94:f5:81:47:1e:64:7f:c0:c1:b7:a8
+	21:58:18:a9:a0:ed:e0:27:75:bf:65:81:6b:e4:1d:5a
+	b7:7e:df:d8:28:c6:36:21:19:c8:6e:da:ca:9e:da:84
+	
+
+exp1:
+	00:ba:d7:fe:77:a9:0d:98:2c:49:56:57:c0:5e:e2:20
+	ba:f6:1f:26:03:bc:d0:5d:08:9b:45:16:61:c4:ab:e2
+	22:b1:dc:92:17:a6:3d:28:26:a4:22:1e:a8:7b:ff:86
+	05:33:5d:74:9c:85:0d:cb:2d:ab:b8:9b:6b:7c:28:57
+	c8:da:92:ca:59:17:6b:21:07:05:34:78:37:fb:3e:ea
+	a2:13:12:04:23:7e:fa:ee:ed:cf:e0:c5:a9:fb:ff:0a
+	2b:1b:21:9c:02:d7:b8:8c:ba:60:70:59:fc:8f:14:f4
+	f2:5a:d9:ad:b2:61:7d:2c:56:8e:5f:98:b1:89:f8:2d
+	10:1c:a5:84:ad:28:b4:aa:92:34:a3:34:04:e1:a3:84
+	52:16:1a:52:e3:8a:38:2d:99:8a:cd:91:90:87:12:ca
+	fc:ab:e6:08:14:03:00:6f:41:88:e4:da:9d:7c:fd:8c
+	7c:c4:de:cb:ed:1d:3f:29:d0:7a:6b:76:df:71:ae:32
+	bd:
+
+exp2:
+	4a:e9:d3:6c:ea:b4:64:0e:c9:3c:8b:c9:f5:a8:a8:b2
+	6a:f6:d0:95:fe:78:32:7f:ea:c4:ce:66:9f:c7:32:55
+	b1:34:7c:03:18:17:8b:73:23:2e:30:bc:4a:07:03:de
+	8b:91:7a:e4:55:21:b7:4d:c6:33:f8:e8:06:d5:99:94
+	55:43:81:26:b9:93:1e:7a:6b:32:54:2d:fd:f9:1d:bd
+	77:4e:82:c4:33:72:87:06:a5:ef:5b:75:e1:38:7a:6b
+	2c:b7:00:19:3c:64:3e:1d:ca:a4:34:f7:db:47:64:d6
+	fa:86:58:15:ea:d1:2d:22:dc:d9:30:4d:b3:02:ab:91
+	83:03:b2:17:98:6f:60:e6:f7:44:8f:4a:ba:81:a2:bf
+	0b:4a:cc:9c:b9:a2:44:52:d0:65:3f:b6:97:5f:d9:d8
+	9c:49:bb:d1:46:bd:10:b2:42:71:a8:85:e5:8b:99:e6
+	1b:00:93:5d:76:ab:32:6c:a8:39:17:53:9c:38:4d:91
+	
+
+
+Public Key PIN:
+	pin-sha256:ISh/UeFjUG5Gwrpx6hMUGQPvg9wOKjOkHmRbs4YjZqs=
+Public Key ID:
+	sha256:21287f51e163506e46c2ba71ea13141903ef83dc0e2a33a41e645bb3862366ab
+	sha1:1a48455111ac45fb5807c5cdb7b20b896c52f0b6
+
+-----BEGIN RSA PRIVATE KEY-----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+-----END RSA PRIVATE KEY-----

@vates/nbd-client/tests/nbdclient.integ.mjs

@@ -0,0 +1,168 @@
+import NbdClient from '../index.mjs'
+import { spawn, exec } from 'node:child_process'
+import fs from 'node:fs/promises'
+import { test } from 'tap'
+import tmp from 'tmp'
+import { pFromCallback } from 'promise-toolbox'
+import { Socket } from 'node:net'
+import { NBD_DEFAULT_PORT } from '../constants.mjs'
+import assert from 'node:assert'
+
+const FILE_SIZE = 10 * 1024 * 1024
+
+async function createTempFile(size) {
+  const tmpPath = await pFromCallback(cb => tmp.file(cb))
+  const data = Buffer.alloc(size, 0)
+  for (let i = 0; i < size; i += 4) {
+    data.writeUInt32BE(i, i)
+  }
+  await fs.writeFile(tmpPath, data)
+
+  return tmpPath
+}
+
+async function spawnNbdKit(path) {
+  let tries = 5
+  // wait for server to be ready
+
+  const nbdServer = spawn(
+    'nbdkit',
+    [
+      'file',
+      path,
+      '--newstyle', //
+      '--exit-with-parent',
+      '--read-only',
+      '--export-name=MY_SECRET_EXPORT',
+      '--tls=on',
+      '--tls-certificates=./tests/',
+      //  '--tls-verify-peer',
+      //  '--verbose',
+      '--exit-with-parent',
+    ],
+    {
+      stdio: ['inherit', 'inherit', 'inherit'],
+    }
+  )
+  nbdServer.on('error', err => {
+    console.error(err)
+  })
+  do {
+    try {
+      const socket = new Socket()
+      await new Promise((resolve, reject) => {
+        socket.connect(NBD_DEFAULT_PORT, 'localhost')
+        socket.once('error', reject)
+        socket.once('connect', resolve)
+      })
+      socket.destroy()
+      break
+    } catch (err) {
+      tries--
+      if (tries <= 0) {
+        throw err
+      } else {
+        await new Promise(resolve => setTimeout(resolve, 1000))
+      }
+    }
+  } while (true)
+  return nbdServer
+}
+
+async function killNbdKit() {
+  return new Promise((resolve, reject) =>
+    exec('pkill -9 -f -o nbdkit', err => {
+      err ? reject(err) : resolve()
+    })
+  )
+}
+
+test('it works with unsecured network', async tap => {
+  const path = await createTempFile(FILE_SIZE)
+
+  let nbdServer = await spawnNbdKit(path)
+  const client = new NbdClient(
+    {
+      address: '127.0.0.1',
+      exportname: 'MY_SECRET_EXPORT',
+      cert: `-----BEGIN CERTIFICATE-----
+MIIDazCCAlOgAwIBAgIUeHpQ0IeD6BmP2zgsv3LV3J4BI/EwDQYJKoZIhvcNAQEL
+BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMzA1MTcxMzU1MzBaFw0yNDA1
+MTYxMzU1MzBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
+HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQC/8wLopj/iZY6ijmpvgCJsl+zY0hQZQcIoaCs0H75u
+8PPSzHedtOLURAkJeMmIS40UY/eIvHh7yZolevaSJLNT2Iolscvc2W9NCF4N1V6y
+zs4pDzP+YPF7Q8ldNaQIX0bAk4PfaMSM+pLh67u+uI40732AfQqD01BNCTD/uHRB
+lKnQuqQpe9UM9UzRRVejpu1r19D4dJruAm6y2SJVTeT4a1sSJixl6I1YPmt80FJh
+gq9O2KRGbXp1xIjemWgW99MHg63pTgxEiULwdJOGgmqGRDzgZKJS5UUpxe/ViEO4
+59I18vIkgibaRYhENgmnP3lIzTOLlUe07tbSML5RGBbBAgMBAAGjUzBRMB0GA1Ud
+DgQWBBR/8+zYoL0H0LdWfULHg1LynFdSbzAfBgNVHSMEGDAWgBR/8+zYoL0H0LdW
+fULHg1LynFdSbzAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBD
+OF5bTmbDEGoZ6OuQaI0vyya/T4FeaoWmh22gLeL6dEEmUVGJ1NyMTOvG9GiGJ8OM
+QhD1uHJei45/bXOYIDGey2+LwLWye7T4vtRFhf8amYh0ReyP/NV4/JoR/U3pTSH6
+tns7GZ4YWdwUhvOOlm17EQKVO/hP3t9mp74gcjdL4bCe5MYSheKuNACAakC1OR0U
+ZakJMP9ijvQuq8spfCzrK+NbHKNHR9tEgQw+ax/t1Au4dGVtFbcoxqCrx2kTl0RP
+CYu1Xn/FVPx1HoRgWc7E8wFhDcA/P3SJtfIQWHB9FzSaBflKGR4t8WCE2eE8+cTB
+57ABhfYpMlZ4aHjuN1bL
+-----END CERTIFICATE-----
+`,
+    },
+    {
+      readAhead: 2,
+    }
+  )
+
+  await client.connect()
+  tap.equal(client.exportSize, BigInt(FILE_SIZE))
+  const CHUNK_SIZE = 1024 * 1024 // non default size
+  const indexes = []
+  for (let i = 0; i < FILE_SIZE / CHUNK_SIZE; i++) {
+    indexes.push(i)
+  }
+  const nbdIterator = client.readBlocks(function* () {
+    for (const index of indexes) {
+      yield { index, size: CHUNK_SIZE }
+    }
+  })
+  let i = 0
+  for await (const block of nbdIterator) {
+    let blockOk = true
+    let firstFail
+    for (let j = 0; j < CHUNK_SIZE; j += 4) {
+      const wanted = i * CHUNK_SIZE + j
+      const found = block.readUInt32BE(j)
+      blockOk = blockOk && found === wanted
+      if (!blockOk && firstFail === undefined) {
+        firstFail = j
+      }
+    }
+    tap.ok(blockOk, `check block ${i} content`)
+    i++
+
+    // flaky server is flaky
+    if (i % 7 === 0) {
+      // kill the older nbdkit process
+      await killNbdKit()
+      nbdServer = await spawnNbdKit(path)
+    }
+  }
+
+  // we can reuse the conneciton to read other blocks
+  // default iterator
+  const nbdIteratorWithDefaultBlockIterator = client.readBlocks()
+  let nb = 0
+  for await (const block of nbdIteratorWithDefaultBlockIterator) {
+    nb++
+    tap.equal(block.length, 2 * 1024 * 1024)
+  }
+
+  tap.equal(nb, 5)
+  assert.rejects(() => client.readBlock(100, CHUNK_SIZE))
+
+  await client.disconnect()
+  // double disconnection shouldn't pose any problem
+  await client.disconnect()
+  nbdServer.kill()
+  await fs.unlink(path)
+})

@vates/nbd-client/tests/server-cert.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDazCCAlOgAwIBAgIUeHpQ0IeD6BmP2zgsv3LV3J4BI/EwDQYJKoZIhvcNAQEL
+BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMzA1MTcxMzU1MzBaFw0yNDA1
+MTYxMzU1MzBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
+HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQC/8wLopj/iZY6ijmpvgCJsl+zY0hQZQcIoaCs0H75u
+8PPSzHedtOLURAkJeMmIS40UY/eIvHh7yZolevaSJLNT2Iolscvc2W9NCF4N1V6y
+zs4pDzP+YPF7Q8ldNaQIX0bAk4PfaMSM+pLh67u+uI40732AfQqD01BNCTD/uHRB
+lKnQuqQpe9UM9UzRRVejpu1r19D4dJruAm6y2SJVTeT4a1sSJixl6I1YPmt80FJh
+gq9O2KRGbXp1xIjemWgW99MHg63pTgxEiULwdJOGgmqGRDzgZKJS5UUpxe/ViEO4
+59I18vIkgibaRYhENgmnP3lIzTOLlUe07tbSML5RGBbBAgMBAAGjUzBRMB0GA1Ud
+DgQWBBR/8+zYoL0H0LdWfULHg1LynFdSbzAfBgNVHSMEGDAWgBR/8+zYoL0H0LdW
+fULHg1LynFdSbzAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBD
+OF5bTmbDEGoZ6OuQaI0vyya/T4FeaoWmh22gLeL6dEEmUVGJ1NyMTOvG9GiGJ8OM
+QhD1uHJei45/bXOYIDGey2+LwLWye7T4vtRFhf8amYh0ReyP/NV4/JoR/U3pTSH6
+tns7GZ4YWdwUhvOOlm17EQKVO/hP3t9mp74gcjdL4bCe5MYSheKuNACAakC1OR0U
+ZakJMP9ijvQuq8spfCzrK+NbHKNHR9tEgQw+ax/t1Au4dGVtFbcoxqCrx2kTl0RP
+CYu1Xn/FVPx1HoRgWc7E8wFhDcA/P3SJtfIQWHB9FzSaBflKGR4t8WCE2eE8+cTB
+57ABhfYpMlZ4aHjuN1bL
+-----END CERTIFICATE-----

@vates/nbd-client/tests/server-key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC/8wLopj/iZY6i
+jmpvgCJsl+zY0hQZQcIoaCs0H75u8PPSzHedtOLURAkJeMmIS40UY/eIvHh7yZol
+evaSJLNT2Iolscvc2W9NCF4N1V6yzs4pDzP+YPF7Q8ldNaQIX0bAk4PfaMSM+pLh
+67u+uI40732AfQqD01BNCTD/uHRBlKnQuqQpe9UM9UzRRVejpu1r19D4dJruAm6y
+2SJVTeT4a1sSJixl6I1YPmt80FJhgq9O2KRGbXp1xIjemWgW99MHg63pTgxEiULw
+dJOGgmqGRDzgZKJS5UUpxe/ViEO459I18vIkgibaRYhENgmnP3lIzTOLlUe07tbS
+ML5RGBbBAgMBAAECggEATLYiafcTHfgnZmjTOad0WoDnC4n9tVBV948WARlUooLS
+duL3RQRHCLz9/ZaTuFA1XDpNcYyc/B/IZoU7aJGZR3+JSmJBjowpUphu+klVNNG4
+i6lDRrzYlUI0hfdLjHsDTDBIKi91KcB0lix/VkvsrVQvDHwsiR2ZAIiVWAWQFKrR
+5O3DhSTHbqyq47uR58rWr4Zf3zvZaUl841AS1yELzCiZqz7AenvyWphim0c0XA5d
+I63CEShntHnEAA9OMcP8+BNf/3AmqB4welY+m8elB3aJNH+j7DKq/AWqaM5nl2PC
+cS6qgpxwOyTxEOyj1xhwK5ZMRR3heW3NfutIxSOPlwKBgQDB9ZkrBeeGVtCISO7C
+eCANzSLpeVrahTvaCSQLdPHsLRLDUc+5mxdpi3CaRlzYs3S1OWdAtyWX9mBryltF
+qDPhCNjFDyHok4D3wLEWdS9oUVwEKUM8fOPW3tXLLiMM7p4862Qo7LqnqHzPqsnz
+22iZo5yjcc7aLJ+VmFrbAowwOwKBgQD9WNCvczTd7Ymn7zEvdiAyNoS0OZ0orwEJ
+zGaxtjqVguGklNfrb/UB+eKNGE80+YnMiSaFc9IQPetLntZdV0L7kWYdCI8kGDNA
+DbVRCOp+z8DwAojlrb/zsYu23anQozT3WeHxVU66lNuyEQvSW2tJa8gN1htrD7uY
+5KLibYrBMwKBgEM0iiHyJcrSgeb2/mO7o7+keJhVSDm3OInP6QFfQAQJihrLWiKB
+rpcPjbCm+LzNUX8JqNEvpIMHB1nR/9Ye9frfSdzd5W3kzicKSVHywL5wkmWOtpFa
+5Mcq5wFDtzlf5MxO86GKhRJauwRptRgdyhySKFApuva1x4XaCIEiXNjJAoGBAN82
+t3c+HCBEv3o05rMYcrmLC1T3Rh6oQlPtwbVmByvfywsFEVCgrc/16MPD3VWhXuXV
+GRmPuE8THxLbead30M5xhvShq+xzXgRbj5s8Lc9ZIHbW5OLoOS1vCtgtaQcoJOyi
+Rs4pCVqe+QpktnO6lEZ2Libys+maTQEiwNibBxu9AoGAUG1V5aKMoXa7pmGeuFR6
+ES+1NDiCt6yDq9BsLZ+e2uqvWTkvTGLLwvH6xf9a0pnnILd0AUTKAAaoUdZS6++E
+cGob7fxMwEE+UETp0QBgLtfjtExMOFwr2avw8PV4CYEUkPUAm2OFB2Twh+d/PNfr
+FAxF1rN47SBPNbFI8N4TFsg=
+-----END PRIVATE KEY-----

@vates/node-vsphere-soap/.npmignore

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

@vates/node-vsphere-soap/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 reedog117
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

@vates/node-vsphere-soap/README.md

@@ -0,0 +1,127 @@
+forked from https://github.com/reedog117/node-vsphere-soap
+
+# node-vsphere-soap
+
+[![Join the chat at https://gitter.im/reedog117/node-vsphere-soap](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/reedog117/node-vsphere-soap?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+This is a Node.js module to connect to VMware vCenter servers and/or ESXi hosts and perform operations using the [vSphere Web Services API]. If you're feeling really adventurous, you can use this module to port vSphere operations from other languages (such as the Perl, Python, and Go libraries that exist) and have fully native Node.js code controlling your VMware virtual infrastructure!
+
+This is very much in alpha.
+
+## Authors
+
+- Patrick C - [@reedog117]
+
+## Version
+
+0.0.2-5
+
+## Installation
+
+```sh
+$ npm install node-vsphere-soap --save
+```
+
+## Sample Code
+
+### To connect to a vCenter server:
+
+    var nvs = require('node-vsphere-soap');
+    var vc = new nvs.Client(host, user, password, sslVerify);
+    vc.once('ready', function() {
+      // perform work here
+    });
+    vc.once('error', function(err) {
+      // handle error here
+    });
+
+#### Arguments
+
+- host = hostname or IP of vCenter/ESX/ESXi server
+- user = username
+- password = password
+- sslVerify = true|false - set to false if you have self-signed/unverified certificates
+
+#### Events
+
+- ready = emits when session authenticated with server
+- error = emits when there's an error
+  - _err_ contains the error
+
+#### Client instance variables
+
+- serviceContent - ServiceContent object retrieved by RetrieveServiceContent API call
+- userName - username of authenticated user
+- fullName - full name of authenticated user
+
+### To run a command:
+
+    var vcCmd = vc.runCommand( commandToRun, arguments );
+    vcCmd.once('result', function( result, raw, soapHeader) {
+      // handle results
+    });
+    vcCmd.once('error', function( err) {
+      // handle errors
+    });
+
+#### Arguments
+
+- commandToRun = Method from the vSphere API
+- arguments = JSON document containing arguments to send
+
+#### Events
+
+- result = emits when session authenticated with server
+  - _result_ contains the JSON-formatted result from the server
+  - _raw_ contains the raw SOAP XML response from the server
+  - _soapHeader_ contains any soapHeaders from the server
+- error = emits when there's an error
+  - _err_ contains the error
+
+Make sure you check out tests/vsphere-soap.test.js for examples on how to create commands to run
+
+## Development
+
+node-vsphere-soap uses a number of open source projects to work properly:
+
+- [node.js] - evented I/O for the backend
+- [node-soap] - SOAP client for Node.js
+- [soap-cookie] - cookie authentication for the node-soap module
+- [lodash] - for quickly manipulating JSON
+- [lab] - testing engine
+- [code] - assertion engine used with lab
+
+Want to contribute? Great!
+
+### Todo's
+
+- Write More Tests
+- Create Travis CI test harness with a fake vCenter Instance
+- Add Code Comments
+
+### Testing
+
+I have been testing on a Mac with node v0.10.36 and both ESXi and vCenter 5.5.
+
+To edit tests, edit the file **test/vsphere-soap.test.js**
+
+To point the module at your own vCenter/ESXi host, edit **config-test.stub.js** and save it as **config-test.js**
+
+To run test scripts:
+
+```sh
+$ npm test
+```
+
+## License
+
+MIT
+
+[vSphere Web Services API]: http://pubs.vmware.com/vsphere-55/topic/com.vmware.wssdk.apiref.doc/right-pane.html
+[node-soap]: https://github.com/vpulim/node-soap
+[node.js]: http://nodejs.org/
+[soap-cookie]: https://github.com/shanestillwell/soap-cookie
+[code]: https://github.com/hapijs/code
+[lab]: https://github.com/hapijs/lab
+[lodash]: https://lodash.com/
+[@reedog117]: http://www.twitter.com/reedog117

@vates/node-vsphere-soap/lib/client.mjs

@@ -0,0 +1,230 @@
+/*
+
+  node-vsphere-soap
+
+  client.js
+
+  This file creates the Client class
+
+  - when the class is instantiated, a connection will be made to the ESXi/vCenter server to verify that the creds are good
+  - upon a bad login, the connnection will be terminated
+
+*/
+
+import { EventEmitter } from 'events'
+import axios from 'axios'
+import https from 'node:https'
+import util from 'util'
+import soap from 'soap'
+import Cookie from 'soap-cookie' // required for session persistence
+
+// Client class
+// inherits from EventEmitter
+// possible events: connect, error, ready
+
+export function Client(vCenterHostname, username, password, sslVerify) {
+  this.status = 'disconnected'
+  this.reconnectCount = 0
+
+  sslVerify = typeof sslVerify !== 'undefined' ? sslVerify : false
+
+  EventEmitter.call(this)
+
+  // sslVerify argument handling
+  if (sslVerify) {
+    this.clientopts = {}
+  } else {
+    this.clientopts = {
+      request: axios.create({
+        httpsAgent: new https.Agent({
+          rejectUnauthorized: false,
+        }),
+      }),
+    }
+  }
+
+  this.connectionInfo = {
+    host: vCenterHostname,
+    user: username,
+    password,
+    sslVerify,
+  }
+
+  this._loginArgs = {
+    userName: this.connectionInfo.user,
+    password: this.connectionInfo.password,
+  }
+
+  this._vcUrl = 'https://' + this.connectionInfo.host + '/sdk/vimService.wsdl'
+
+  // connect to the vCenter / ESXi host
+  this.on('connect', this._connect)
+  this.emit('connect')
+
+  // close session
+  this.on('close', this._close)
+
+  return this
+}
+
+util.inherits(Client, EventEmitter)
+
+Client.prototype.runCommand = function (command, args) {
+  const self = this
+  let cmdargs
+  if (!args || args === null) {
+    cmdargs = {}
+  } else {
+    cmdargs = args
+  }
+
+  const emitter = new EventEmitter()
+
+  // check if client has successfully connected
+  if (self.status === 'ready' || self.status === 'connecting') {
+    self.client.VimService.VimPort[command](cmdargs, function (err, result, raw, soapHeader) {
+      if (err) {
+        _soapErrorHandler(self, emitter, command, cmdargs, err)
+      }
+      if (command === 'Logout') {
+        self.status = 'disconnected'
+        process.removeAllListeners('beforeExit')
+      }
+      emitter.emit('result', result, raw, soapHeader)
+    })
+  } else {
+    // if connection not ready or connecting, reconnect to instance
+    if (self.status === 'disconnected') {
+      self.emit('connect')
+    }
+    self.once('ready', function () {
+      self.client.VimService.VimPort[command](cmdargs, function (err, result, raw, soapHeader) {
+        if (err) {
+          _soapErrorHandler(self, emitter, command, cmdargs, err)
+        }
+        if (command === 'Logout') {
+          self.status = 'disconnected'
+          process.removeAllListeners('beforeExit')
+        }
+        emitter.emit('result', result, raw, soapHeader)
+      })
+    })
+  }
+
+  return emitter
+}
+
+Client.prototype.close = function () {
+  const self = this
+
+  self.emit('close')
+}
+
+Client.prototype._connect = function () {
+  const self = this
+
+  if (self.status !== 'disconnected') {
+    return
+  }
+
+  self.status = 'connecting'
+
+  soap.createClient(
+    self._vcUrl,
+    self.clientopts,
+    function (err, client) {
+      if (err) {
+        self.emit('error', err)
+        throw err
+      }
+
+      self.client = client // save client for later use
+
+      self
+        .runCommand('RetrieveServiceContent', { _this: 'ServiceInstance' })
+        .once('result', function (result, raw, soapHeader) {
+          if (!result.returnval) {
+            self.status = 'disconnected'
+            self.emit('error', raw)
+            return
+          }
+
+          self.serviceContent = result.returnval
+          self.sessionManager = result.returnval.sessionManager
+          const loginArgs = { _this: self.sessionManager, ...self._loginArgs }
+
+          self
+            .runCommand('Login', loginArgs)
+            .once('result', function (result, raw, soapHeader) {
+              self.authCookie = new Cookie(client.lastResponseHeaders)
+              self.client.setSecurity(self.authCookie) // needed since vSphere SOAP WS uses cookies
+
+              self.userName = result.returnval.userName
+              self.fullName = result.returnval.fullName
+              self.reconnectCount = 0
+
+              self.status = 'ready'
+              self.emit('ready')
+              process.once('beforeExit', self._close)
+            })
+            .once('error', function (err) {
+              self.status = 'disconnected'
+              self.emit('error', err)
+            })
+        })
+        .once('error', function (err) {
+          self.status = 'disconnected'
+          self.emit('error', err)
+        })
+    },
+    self._vcUrl
+  )
+}
+
+Client.prototype._close = function () {
+  const self = this
+
+  if (self.status === 'ready') {
+    self
+      .runCommand('Logout', { _this: self.sessionManager })
+      .once('result', function () {
+        self.status = 'disconnected'
+      })
+      .once('error', function () {
+        /* don't care of error during disconnection */
+        self.status = 'disconnected'
+      })
+  } else {
+    self.status = 'disconnected'
+  }
+}
+
+function _soapErrorHandler(self, emitter, command, args, err) {
+  err = err || { body: 'general error' }
+
+  if (err.body.match(/session is not authenticated/)) {
+    self.status = 'disconnected'
+    process.removeAllListeners('beforeExit')
+
+    if (self.reconnectCount < 10) {
+      self.reconnectCount += 1
+      self
+        .runCommand(command, args)
+        .once('result', function (result, raw, soapHeader) {
+          emitter.emit('result', result, raw, soapHeader)
+        })
+        .once('error', function (err) {
+          emitter.emit('error', err.body)
+          throw err
+        })
+    } else {
+      emitter.emit('error', err.body)
+      throw err
+    }
+  } else {
+    emitter.emit('error', err.body)
+    throw err
+  }
+}
+
+// end

@vates/node-vsphere-soap/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@vates/node-vsphere-soap",
+  "version": "1.0.0",
+  "description": "interface to vSphere SOAP/WSDL from node for interfacing with vCenter or ESXi, forked from node-vsphere-soap",
+  "main": "lib/client.mjs",
+  "author": "reedog117",
+  "repository": {
+    "directory": "@vates/node-vsphere-soap",
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "dependencies": {
+    "axios": "^1.4.0",
+    "soap": "^1.0.0",
+    "soap-cookie": "^0.10.1"
+  },
+  "devDependencies": {
+    "test": "^3.3.0"
+  },
+  "keywords": [
+    "vsphere",
+    "vcenter",
+    "api",
+    "soap",
+    "wsdl"
+  ],
+  "preferGlobal": false,
+  "license": "MIT",
+  "private": false,
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/node-vsphere-soap",
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "postversion": "npm publish --access public"
+  }
+}

@vates/node-vsphere-soap/test/config-test.stub.mjs

@@ -0,0 +1,11 @@
+// place your own credentials here for a vCenter or ESXi server
+// this information will be used for connecting to a vCenter instance
+// for module testing
+// name the file config-test.js
+
+export const vCenterTestCreds = {
+  vCenterIP: 'vcsa',
+  vCenterUser: 'vcuser',
+  vCenterPassword: 'vcpw',
+  vCenter: true,
+}

@vates/node-vsphere-soap/test/vsphere-soap.test.mjs

@@ -0,0 +1,138 @@
+/*
+  vsphere-soap.test.js
+
+  tests for the vCenterConnectionInstance class
+*/
+
+import assert from 'assert'
+import { describe, it } from 'test'
+
+import * as vc from '../lib/client.mjs'
+
+// eslint-disable-next-line n/no-missing-import
+import { vCenterTestCreds as TestCreds } from '../config-test.mjs'
+
+const VItest = new vc.Client(TestCreds.vCenterIP, TestCreds.vCenterUser, TestCreds.vCenterPassword, false)
+
+describe('Client object initialization:', function () {
+  it('provides a successful login', { timeout: 5000 }, function (t, done) {
+    VItest.once('ready', function () {
+      assert.notEqual(VItest.userName, null)
+      assert.notEqual(VItest.fullName, null)
+      assert.notEqual(VItest.serviceContent, null)
+      done()
+    }).once('error', function (err) {
+      console.error(err)
+      // this should fail if there's a problem
+      assert.notEqual(VItest.userName, null)
+      assert.notEqual(VItest.fullName, null)
+      assert.notEqual(VItest.serviceContent, null)
+      done()
+    })
+  })
+})
+
+describe('Client reconnection test:', function () {
+  it('can successfully reconnect', { timeout: 5000 }, function (t, done) {
+    VItest.runCommand('Logout', { _this: VItest.serviceContent.sessionManager })
+      .once('result', function (result) {
+        // now we're logged out, so let's try running a command to test automatic re-login
+        VItest.runCommand('CurrentTime', { _this: 'ServiceInstance' })
+          .once('result', function (result) {
+            assert(result.returnval instanceof Date)
+            done()
+          })
+          .once('error', function (err) {
+            console.error(err)
+          })
+      })
+      .once('error', function (err) {
+        console.error(err)
+      })
+  })
+})
+
+// these tests don't work yet
+describe('Client tests - query commands:', function () {
+  it('retrieves current time', { timeout: 5000 }, function (t, done) {
+    VItest.runCommand('CurrentTime', { _this: 'ServiceInstance' }).once('result', function (result) {
+      assert(result.returnval instanceof Date)
+      done()
+    })
+  })
+
+  it('retrieves current time 2 (check for event clobbering)', { timeout: 5000 }, function (t, done) {
+    VItest.runCommand('CurrentTime', { _this: 'ServiceInstance' }).once('result', function (result) {
+      assert(result.returnval instanceof Date)
+      done()
+    })
+  })
+
+  it('can obtain the names of all Virtual Machines in the inventory', { timeout: 20000 }, function (t, done) {
+    // get property collector
+    const propertyCollector = VItest.serviceContent.propertyCollector
+    // get view manager
+    const viewManager = VItest.serviceContent.viewManager
+    // get root folder
+    const rootFolder = VItest.serviceContent.rootFolder
+
+    let containerView, objectSpec, traversalSpec, propertySpec, propertyFilterSpec
+    // this is the equivalent to
+    VItest.runCommand('CreateContainerView', {
+      _this: viewManager,
+      container: rootFolder,
+      type: ['VirtualMachine'],
+      recursive: true,
+    }).once('result', function (result) {
+      // build all the data structures needed to query all the vm names
+      containerView = result.returnval
+
+      objectSpec = {
+        attributes: { 'xsi:type': 'ObjectSpec' }, // setting attributes xsi:type is important or else the server may mis-recognize types!
+        obj: containerView,
+        skip: true,
+      }
+
+      traversalSpec = {
+        attributes: { 'xsi:type': 'TraversalSpec' },
+        name: 'traverseEntities',
+        type: 'ContainerView',
+        path: 'view',
+        skip: false,
+      }
+
+      objectSpec = { ...objectSpec, selectSet: [traversalSpec] }
+
+      propertySpec = {
+        attributes: { 'xsi:type': 'PropertySpec' },
+        type: 'VirtualMachine',
+        pathSet: ['name'],
+      }
+
+      propertyFilterSpec = {
+        attributes: { 'xsi:type': 'PropertyFilterSpec' },
+        propSet: [propertySpec],
+        objectSet: [objectSpec],
+      }
+      // TODO: research why it fails if propSet is declared after objectSet
+
+      VItest.runCommand('RetrievePropertiesEx', {
+        _this: propertyCollector,
+        specSet: [propertyFilterSpec],
+        options: { attributes: { type: 'RetrieveOptions' } },
+      })
+        .once('result', function (result, raw) {
+          assert.notEqual(result.returnval.objects, null)
+          if (Array.isArray(result.returnval.objects)) {
+            assert.strictEqual(result.returnval.objects[0].obj.attributes.type, 'VirtualMachine')
+          } else {
+            assert.strictEqual(result.returnval.objects.obj.attributes.type, 'VirtualMachine')
+          }
+          done()
+        })
+        .once('error', function (err) {
+          console.error('\n\nlast request : ' + VItest.client.lastRequest, err)
+        })
+    })
+  })
+})

@vates/otp/.USAGE.md

@@ -0,0 +1,130 @@
+### Usual workflow
+
+> This section presents how this library should be used to implement a classic two factor authentification.
+
+#### Setup
+
+```js
+import { generateSecret, generateTotp } from '@vates/otp'
+import QrCode from 'qrcode'
+
+// Generates a secret that will be shared by both the service and the user:
+const secret = generateSecret()
+
+// Stores the secret in the service:
+await currentUser.saveOtpSecret(secret)
+
+// Generates an URI to present to the user
+const uri = generateTotpUri({ secret })
+
+// Generates the QR code from the URI to make it easily importable in Authy or Google Authenticator
+const qr = await QrCode.toDataURL(uri)
+```
+
+#### Authentication
+
+```js
+import { verifyTotp } from '@vates/otp'
+
+// Verifies a `token` entered by the user against a `secret` generated during setup.
+if (await verifyTotp(token, { secret })) {
+  console.log('authenticated!')
+}
+```
+
+### API
+
+#### Secret
+
+```js
+import { generateSecret } from '@vates/otp'
+
+const secret = generateSecret()
+// 'OJOKA65RY5FQQ2RYWVKD5Y3YG5CSHGYH'
+```
+
+#### HOTP
+
+> This is likely not what you want to use, see TOTP below instead.
+
+```js
+import { generateHotp, generateHotpUri, verifyHotp } from '@vates/otp'
+
+// a sequence number, see HOTP specification
+const counter = 0
+
+// generate a token
+//
+// optional params:
+// - digits
+const token = await generateHotp({ counter, secret })
+// '239988'
+
+// verify a token
+//
+// optional params:
+// - digits
+const isValid = await verifyHotp(token, { counter, secret })
+// true
+
+// generate a URI than can be displayed as a QR code to be used with Authy or Google Authenticator
+//
+// optional params:
+// - digits
+const uri = generateHotpUri({ counter, label: 'account name', issuer: 'my app', secret })
+// 'otpauth://hotp/my%20app:account%20name?counter=0&issuer=my%20app&secret=OJOKA65RY5FQQ2RYWVKD5Y3YG5CSHGYH'
+```
+
+Optional params and their default values:
+
+- `digits = 6`: length of the token, avoid using it because not compatible with Google Authenticator
+
+#### TOTP
+
+```js
+import { generateTotp, generateTotpUri, verifyTotp } from '@vates/otp'
+
+// generate a token
+//
+// optional params:
+// - digits
+// - period
+// - timestamp
+const token = await generateTotp({ secret })
+// '632869'
+
+// verify a token
+//
+// optional params:
+// - digits
+// - period
+// - timestamp
+// - window
+const isValid = await verifyTotp(token, { secret })
+// true
+
+// generate a URI than can be displayed as a QR code to be used with Authy or Google Authenticator
+//
+// optional params:
+// - digits
+// - period
+const uri = generateTotpUri({ label: 'account name', issuer: 'my app', secret })
+// 'otpauth://totp/my%20app:account%20name?issuer=my%20app&secret=OJOKA65RY5FQQ2RYWVKD5Y3YG5CSHGYH'
+```
+
+Optional params and their default values:
+
+- `digits = 6`: length of the token, avoid using it because not compatible with Google Authenticator
+- `period = 30`: number of seconds a token is valid
+- `timestamp = Date.now() / 1e3`: Unix timestamp, in seconds, when this token will be valid, default to now
+- `window = 1`: number of periods before and after `timestamp` for which the token is considered valid
+
+#### Verification from URI
+
+```js
+import { verifyFromUri } from '@vates/otp'
+
+// Verify the token using all the information contained in the URI
+const isValid = await verifyFromUri(token, uri)
+// true
+```

@vates/otp/.npmignore

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

@vates/otp/README.md

@@ -0,0 +1,163 @@
+<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
+
+# @vates/otp
+
+[![Package Version](https://badgen.net/npm/v/@vates/otp)](https://npmjs.org/package/@vates/otp) ![License](https://badgen.net/npm/license/@vates/otp) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/otp)](https://bundlephobia.com/result?p=@vates/otp) [![Node compatibility](https://badgen.net/npm/node/@vates/otp)](https://npmjs.org/package/@vates/otp)
+
+> Minimal HTOP/TOTP implementation
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/@vates/otp):
+
+```sh
+npm install --save @vates/otp
+```
+
+## Usage
+
+### Usual workflow
+
+> This section presents how this library should be used to implement a classic two factor authentification.
+
+#### Setup
+
+```js
+import { generateSecret, generateTotp } from '@vates/otp'
+import QrCode from 'qrcode'
+
+// Generates a secret that will be shared by both the service and the user:
+const secret = generateSecret()
+
+// Stores the secret in the service:
+await currentUser.saveOtpSecret(secret)
+
+// Generates an URI to present to the user
+const uri = generateTotpUri({ secret })
+
+// Generates the QR code from the URI to make it easily importable in Authy or Google Authenticator
+const qr = await QrCode.toDataURL(uri)
+```
+
+#### Authentication
+
+```js
+import { verifyTotp } from '@vates/otp'
+
+// Verifies a `token` entered by the user against a `secret` generated during setup.
+if (await verifyTotp(token, { secret })) {
+  console.log('authenticated!')
+}
+```
+
+### API
+
+#### Secret
+
+```js
+import { generateSecret } from '@vates/otp'
+
+const secret = generateSecret()
+// 'OJOKA65RY5FQQ2RYWVKD5Y3YG5CSHGYH'
+```
+
+#### HOTP
+
+> This is likely not what you want to use, see TOTP below instead.
+
+```js
+import { generateHotp, generateHotpUri, verifyHotp } from '@vates/otp'
+
+// a sequence number, see HOTP specification
+const counter = 0
+
+// generate a token
+//
+// optional params:
+// - digits
+const token = await generateHotp({ counter, secret })
+// '239988'
+
+// verify a token
+//
+// optional params:
+// - digits
+const isValid = await verifyHotp(token, { counter, secret })
+// true
+
+// generate a URI than can be displayed as a QR code to be used with Authy or Google Authenticator
+//
+// optional params:
+// - digits
+const uri = generateHotpUri({ counter, label: 'account name', issuer: 'my app', secret })
+// 'otpauth://hotp/my%20app:account%20name?counter=0&issuer=my%20app&secret=OJOKA65RY5FQQ2RYWVKD5Y3YG5CSHGYH'
+```
+
+Optional params and their default values:
+
+- `digits = 6`: length of the token, avoid using it because not compatible with Google Authenticator
+
+#### TOTP
+
+```js
+import { generateTotp, generateTotpUri, verifyTotp } from '@vates/otp'
+
+// generate a token
+//
+// optional params:
+// - digits
+// - period
+// - timestamp
+const token = await generateTotp({ secret })
+// '632869'
+
+// verify a token
+//
+// optional params:
+// - digits
+// - period
+// - timestamp
+// - window
+const isValid = await verifyTotp(token, { secret })
+// true
+
+// generate a URI than can be displayed as a QR code to be used with Authy or Google Authenticator
+//
+// optional params:
+// - digits
+// - period
+const uri = generateTotpUri({ label: 'account name', issuer: 'my app', secret })
+// 'otpauth://totp/my%20app:account%20name?issuer=my%20app&secret=OJOKA65RY5FQQ2RYWVKD5Y3YG5CSHGYH'
+```
+
+Optional params and their default values:
+
+- `digits = 6`: length of the token, avoid using it because not compatible with Google Authenticator
+- `period = 30`: number of seconds a token is valid
+- `timestamp = Date.now() / 1e3`: Unix timestamp, in seconds, when this token will be valid, default to now
+- `window = 1`: number of periods before and after `timestamp` for which the token is considered valid
+
+#### Verification from URI
+
+```js
+import { verifyFromUri } from '@vates/otp'
+
+// Verify the token using all the information contained in the URI
+const isValid = await verifyFromUri(token, uri)
+// true
+```
+
+## 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/otp/index.mjs

@@ -0,0 +1,111 @@
+import { base32 } from 'rfc4648'
+import { webcrypto } from 'node:crypto'
+
+const { subtle } = webcrypto
+
+function assert(name, value) {
+  if (!value) {
+    throw new TypeError('invalid value for param ' + name)
+  }
+}
+
+// https://github.com/google/google-authenticator/wiki/Key-Uri-Format
+function generateUri(protocol, label, params) {
+  assert('label', typeof label === 'string')
+  assert('secret', typeof params.secret === 'string')
+
+  let path = encodeURIComponent(label)
+
+  const { issuer } = params
+  if (issuer !== undefined) {
+    path = encodeURIComponent(issuer) + ':' + path
+  }
+
+  const query = Object.entries(params)
+    .filter(_ => _[1] !== undefined)
+    .map(([key, value]) => key + '=' + encodeURIComponent(value))
+    .join('&')
+
+  return `otpauth://${protocol}/${path}?${query}`
+}
+
+export function generateSecret() {
+  // https://www.rfc-editor.org/rfc/rfc4226 recommends 160 bits (i.e. 20 bytes)
+  const data = new Uint8Array(20)
+  webcrypto.getRandomValues(data)
+  return base32.stringify(data, { pad: false })
+}
+
+const DIGITS = 6
+
+// https://www.rfc-editor.org/rfc/rfc4226
+export async function generateHotp({ counter, digits = DIGITS, secret }) {
+  const data = new Uint8Array(8)
+  new DataView(data.buffer).setBigInt64(0, BigInt(counter), false)
+
+  const key = await subtle.importKey(
+    'raw',
+    base32.parse(secret, { loose: true }),
+    { name: 'HMAC', hash: 'SHA-1' },
+    false,
+    ['sign', 'verify']
+  )
+  const digest = new DataView(await subtle.sign('HMAC', key, data))
+
+  const offset = digest.getUint8(digest.byteLength - 1) & 0xf
+  const p = digest.getUint32(offset) & 0x7f_ff_ff_ff
+
+  return String(p % Math.pow(10, digits)).padStart(digits, '0')
+}
+
+export function generateHotpUri({ counter, digits, issuer, label, secret }) {
+  assert('counter', typeof counter === 'number')
+  return generateUri('hotp', label, { counter, digits, issuer, secret })
+}
+
+export async function verifyHotp(token, opts) {
+  return token === (await generateHotp(opts))
+}
+
+function totpCounter(period = 30, timestamp = Math.floor(Date.now() / 1e3)) {
+  return Math.floor(timestamp / period)
+}
+
+// https://www.rfc-editor.org/rfc/rfc6238.html
+export async function generateTotp({ period, timestamp, ...opts }) {
+  opts.counter = totpCounter(period, timestamp)
+  return await generateHotp(opts)
+}
+
+export function generateTotpUri({ digits, issuer, label, period, secret }) {
+  return generateUri('totp', label, { digits, issuer, period, secret })
+}
+
+export async function verifyTotp(token, { period, timestamp, window = 1, ...opts }) {
+  const counter = totpCounter(period, timestamp)
+  const end = counter + window
+  opts.counter = counter - window
+  while (opts.counter <= end) {
+    if (token === (await generateHotp(opts))) {
+      return true
+    }
+    opts.counter += 1
+  }
+  return false
+}
+
+export async function verifyFromUri(token, uri) {
+  const url = new URL(uri)
+  assert('protocol', url.protocol === 'otpauth:')
+
+  const { host } = url
+  const opts = Object.fromEntries(url.searchParams.entries())
+  if (host === 'hotp') {
+    return await verifyHotp(token, opts)
+  }
+  if (host === 'totp') {
+    return await verifyTotp(token, opts)
+  }
+
+  assert('host', false)
+}

@vates/otp/index.spec.mjs

@@ -0,0 +1,112 @@
+import { strict as assert } from 'node:assert'
+import { describe, it } from 'tap/mocha'
+
+import {
+  generateHotp,
+  generateHotpUri,
+  generateSecret,
+  generateTotp,
+  generateTotpUri,
+  verifyHotp,
+  verifyTotp,
+} from './index.mjs'
+
+describe('generateSecret', function () {
+  it('generates a string of 32 chars', async function () {
+    const secret = generateSecret()
+    assert.equal(typeof secret, 'string')
+    assert.equal(secret.length, 32)
+  })
+
+  it('generates a different secret at each call', async function () {
+    assert.notEqual(generateSecret(), generateSecret())
+  })
+})
+
+describe('HOTP', function () {
+  it('generate and verify valid tokens', async function () {
+    for (const [token, opts] of Object.entries({
+      382752: {
+        counter: -3088,
+        secret: 'PJYFSZ3JNVXVQMZXOB2EQYJSKB2HE6TB',
+      },
+      163376: {
+        counter: 30598,
+        secret: 'GBUDQZ3UKZZGIMRLNVYXA33GMFMEGQKN',
+      },
+    })) {
+      assert.equal(await generateHotp(opts), token)
+      assert(await verifyHotp(token, opts))
+    }
+  })
+
+  describe('generateHotpUri', function () {
+    const opts = {
+      counter: 59732,
+      label: 'the label',
+      secret: 'OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX',
+    }
+
+    Object.entries({
+      'without optional params': [
+        opts,
+        'otpauth://hotp/the%20label?counter=59732&secret=OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX',
+      ],
+      'with issuer': [
+        { ...opts, issuer: 'the issuer' },
+        'otpauth://hotp/the%20issuer:the%20label?counter=59732&issuer=the%20issuer&secret=OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX',
+      ],
+      'with digits': [
+        { ...opts, digits: 7 },
+        'otpauth://hotp/the%20label?counter=59732&digits=7&secret=OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX',
+      ],
+    }).forEach(([title, [opts, uri]]) => {
+      it(title, async function () {
+        assert.strictEqual(generateHotpUri(opts), uri)
+      })
+    })
+  })
+})
+
+describe('TOTP', function () {
+  Object.entries({
+    '033702': {
+      secret: 'PJYFSZ3JNVXVQMZXOB2EQYJSKB2HE6TB',
+      timestamp: 1665416296,
+      period: 30,
+    },
+    107250: {
+      secret: 'GBUDQZ3UKZZGIMRLNVYXA33GMFMEGQKN',
+      timestamp: 1665416674,
+      period: 60,
+    },
+  }).forEach(([token, opts]) => {
+    it('works', async function () {
+      assert.equal(await generateTotp(opts), token)
+      assert(await verifyTotp(token, opts))
+    })
+  })
+
+  describe('generateHotpUri', function () {
+    const opts = {
+      label: 'the label',
+      secret: 'OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX',
+    }
+
+    Object.entries({
+      'without optional params': [opts, 'otpauth://totp/the%20label?secret=OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX'],
+      'with issuer': [
+        { ...opts, issuer: 'the issuer' },
+        'otpauth://totp/the%20issuer:the%20label?issuer=the%20issuer&secret=OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX',
+      ],
+      'with digits': [
+        { ...opts, digits: 7 },
+        'otpauth://totp/the%20label?digits=7&secret=OGK45BBZAIGNGELHZPXYKN4GUVWWO6YX',
+      ],
+    }).forEach(([title, [opts, uri]]) => {
+      it(title, async function () {
+        assert.strictEqual(generateTotpUri(opts), uri)
+      })
+    })
+  })
+})

@vates/otp/package.json

@@ -0,0 +1,39 @@
+{
+  "private": false,
+  "name": "@vates/otp",
+  "description": "Minimal HTOP/TOTP implementation",
+  "keywords": [
+    "2fa",
+    "authenticator",
+    "hotp",
+    "otp",
+    "totp"
+  ],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/otp",
+  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
+  "main": "index.mjs",
+  "repository": {
+    "directory": "@vates/otp",
+    "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": ">=15"
+  },
+  "dependencies": {
+    "rfc4648": "^1.5.2"
+  },
+  "scripts": {
+    "postversion": "npm publish --access public",
+    "test": "tap"
+  },
+  "devDependencies": {
+    "tap": "^16.3.0"
+  }
+}

@vates/parse-duration/README.md

@@ -10,8 +10,8 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/parse-duration):
 
-```
-> npm install --save @vates/parse-duration
+```sh
+npm install --save @vates/parse-duration
 ```
 
 ## Usage

@vates/parse-duration/index.js

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

@vates/predicates/.USAGE.md

@@ -0,0 +1,72 @@
+`undefined` predicates are ignored and `undefined` is returned if all predicates are `undefined`, this permits the most efficient composition:
+
+```js
+const compositePredicate = not(every(undefined, some(not(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
+```
+
+### `not(predicate)`
+
+> Returns a predicate that returns the negation of the predicate.
+
+```js
+const isEven = n => n % 2 === 0
+const isOdd = not(isEven)
+
+isOdd(1)
+// true
+
+isOdd(2)
+// 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

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

@vates/predicates/README.md

@@ -0,0 +1,105 @@
+<!-- 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):
+
+```sh
+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 = not(every(undefined, some(not(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
+```
+
+### `not(predicate)`
+
+> Returns a predicate that returns the negation of the predicate.
+
+```js
+const isEven = n => n % 2 === 0
+const isOdd = not(isEven)
+
+isOdd(1)
+// true
+
+isOdd(2)
+// 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

@@ -0,0 +1,87 @@
+'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
+  }
+}
+
+const notPredicateTag = {}
+exports.not = function not(predicate) {
+  if (isDefinedPredicate(predicate)) {
+    if (predicate.tag === notPredicateTag) {
+      return predicate.predicate
+    }
+
+    function notPredicate() {
+      return !predicate.apply(this, arguments)
+    }
+    notPredicate.predicate = predicate
+    notPredicate.tag = notPredicateTag
+    return notPredicate
+  }
+}
+
+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

@@ -0,0 +1,85 @@
+'use strict'
+
+const assert = require('assert/strict')
+const { describe, it } = require('tap').mocha
+
+const { every, not, some } = require('./')
+
+const T = () => true
+const F = () => false
+
+const testArgHandling = fn => {
+  it('returns undefined if predicate is undefined', () => {
+    assert.equal(fn(undefined), undefined)
+  })
+
+  it('throws if it receives a non-predicate', () => {
+    const error = new TypeError('not a valid predicate')
+    error.value = 3
+    assert.throws(() => fn(3), error)
+  })
+}
+
+const testArgsHandling = fn => {
+  testArgHandling(fn)
+
+  it('returns the predicate if only a single one is passed', () => {
+    assert.equal(fn(undefined, T), T)
+    assert.equal(fn([undefined, T]), T)
+  })
+
+  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, acceptMultiple, truthTable) =>
+  it('works', () => {
+    truthTable.forEach(([result, ...predicates]) => {
+      if (acceptMultiple) {
+        assert.equal(fn(predicates)(), result)
+      } else {
+        assert.equal(predicates.length, 1)
+      }
+      assert.equal(fn(...predicates)(), result)
+    })
+  })
+
+describe('every', () => {
+  testArgsHandling(every)
+  runTests(every, true, [
+    [true, T, T],
+    [false, T, F],
+    [false, F, T],
+    [false, F, F],
+  ])
+})
+
+describe('not', () => {
+  testArgHandling(not)
+
+  it('returns the original predicate if negated twice', () => {
+    assert.equal(not(not(T)), T)
+  })
+
+  runTests(not, false, [
+    [true, F],
+    [false, T],
+  ])
+})
+
+describe('some', () => {
+  testArgsHandling(some)
+  runTests(some, true, [
+    [true, T, T],
+    [true, T, F],
+    [true, F, T],
+    [false, F, F],
+  ])
+})

@vates/predicates/package.json

@@ -0,0 +1,40 @@
+{
+  "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.1.0",
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "postversion": "npm publish --access public",
+    "test": "tap"
+  },
+  "devDependencies": {
+    "tap": "^16.0.1"
+  }
+}

@vates/read-chunk/.USAGE.md

@@ -0,0 +1,48 @@
+### `readChunk(stream, [size])`
+
+- returns the next available chunk of data
+- like `stream.read()`, a number of bytes can be specified
+- returns with less data than expected if stream has ended
+- returns `null` if the stream has ended and no data has been read
+
+```js
+import { readChunk } from '@vates/read-chunk'
+;(async () => {
+  let chunk
+  while ((chunk = await readChunk(stream, 1024)) !== null) {
+    // do something with chunk
+  }
+})()
+```
+
+### `readChunkStrict(stream, [size])`
+
+Similar behavior to `readChunk` but throws if the stream ended before the requested data could be read.
+
+```js
+import { readChunkStrict } from '@vates/read-chunk'
+
+const chunk = await readChunkStrict(stream, 1024)
+```
+
+### `skip(stream, size)`
+
+Skips a given number of bytes from a stream.
+
+Returns the number of bytes actually skipped, which may be less than the requested size if the stream has ended.
+
+```js
+import { skip } from '@vates/read-chunk'
+
+const bytesSkipped = await skip(stream, 2 * 1024 * 1024 * 1024)
+```
+
+### `skipStrict(stream, size)`
+
+Skips a given number of bytes from a stream and throws if the stream ended before enough stream has been skipped.
+
+```js
+import { skipStrict } from '@vates/read-chunk'
+
+await skipStrict(stream, 2 * 1024 * 1024 * 1024)
+```

@vates/read-chunk/README.md

@@ -10,15 +10,18 @@
 
 Installation of the [npm package](https://npmjs.org/package/@vates/read-chunk):
 
-```
-> npm install --save @vates/read-chunk
+```sh
+npm install --save @vates/read-chunk
 ```
 
 ## Usage
 
+### `readChunk(stream, [size])`
+
 - returns the next available chunk of data
 - like `stream.read()`, a number of bytes can be specified
-- returns `null` if the stream has ended
+- returns with less data than expected if stream has ended
+- returns `null` if the stream has ended and no data has been read
 
 ```js
 import { readChunk } from '@vates/read-chunk'
@@ -30,6 +33,38 @@ import { readChunk } from '@vates/read-chunk'
 })()
 ```
 
+### `readChunkStrict(stream, [size])`
+
+Similar behavior to `readChunk` but throws if the stream ended before the requested data could be read.
+
+```js
+import { readChunkStrict } from '@vates/read-chunk'
+
+const chunk = await readChunkStrict(stream, 1024)
+```
+
+### `skip(stream, size)`
+
+Skips a given number of bytes from a stream.
+
+Returns the number of bytes actually skipped, which may be less than the requested size if the stream has ended.
+
+```js
+import { skip } from '@vates/read-chunk'
+
+const bytesSkipped = await skip(stream, 2 * 1024 * 1024 * 1024)
+```
+
+### `skipStrict(stream, size)`
+
+Skips a given number of bytes from a stream and throws if the stream ended before enough stream has been skipped.
+
+```js
+import { skipStrict } from '@vates/read-chunk'
+
+await skipStrict(stream, 2 * 1024 * 1024 * 1024)
+```
+
 ## Contributions
 
 Contributions are _very_ welcomed, either on the documentation or on

@vates/read-chunk/USAGE.md

@@ -1,13 +0,0 @@
-- returns the next available chunk of data
-- like `stream.read()`, a number of bytes can be specified
-- returns `null` if the stream has ended
-
-```js
-import { readChunk } from '@vates/read-chunk'
-;(async () => {
-  let chunk
-  while ((chunk = await readChunk(stream, 1024)) !== null) {
-    // do something with chunk
-  }
-})()
-```

@vates/read-chunk/index.js

@@ -1,7 +1,36 @@
+'use strict'
+
+const assert = require('assert')
+
+/**
+ * Read a chunk of data from a stream.
+ *
+ * The returned promise is rejected if there is an error while reading the stream.
+ *
+ * For streams in object mode, the returned promise resolves to a single object read from the stream.
+ *
+ * For streams in binary mode, the returned promise resolves to a Buffer or a string if an encoding has been specified using the `stream.setEncoding()` method.
+ *
+ * If `size` bytes are not available to be read, `null` will be returned *unless* the stream has ended, in which case all of the data remaining will be returned.
+ *
+ * @param {Readable} stream - A readable stream to read from.
+ * @param {number} [size] - The number of bytes to read for binary streams (ignored for object streams).
+ * @returns {Promise<Buffer|string|unknown|null>} - A Promise that resolves to the read chunk if available, or null if end of stream is reached.
+ */
 const readChunk = (stream, size) =>
-  size === 0
-    ? Promise.resolve(Buffer.alloc(0))
+  stream.errored != null
+    ? Promise.reject(stream.errored)
+    : stream.closed || stream.readableEnded
+    ? Promise.resolve(null)
     : new Promise((resolve, reject) => {
+        if (size !== undefined) {
+          assert(size > 0)
+
+          // per Node documentation:
+          // > The size argument must be less than or equal to 1 GiB.
+          assert(size < 1073741824)
+        }
+
         function onEnd() {
           resolve(null)
           removeListeners()
@@ -28,3 +57,103 @@ const readChunk = (stream, size) =>
         onReadable()
       })
 exports.readChunk = readChunk
+
+/**
+ * Read a chunk of data from a stream.
+ *
+ * The returned promise is rejected if there is an error while reading the stream.
+ *
+ * For streams in object mode, the returned promise resolves to a single object read from the stream.
+ *
+ * For streams in binary mode, the returned promise resolves to a Buffer or a string if an encoding has been specified using the `stream.setEncoding()` method.
+ *
+ * If `size` bytes are not available to be read, the returned promise is rejected.
+ *
+ * @param {Readable} stream - A readable stream to read from.
+ * @param {number} [size] - The number of bytes to read for binary streams (ignored for object streams).
+ * @returns {Promise<Buffer|string|unknown>} - A Promise that resolves to the read chunk.
+ */
+exports.readChunkStrict = async function readChunkStrict(stream, size) {
+  const chunk = await readChunk(stream, size)
+  if (chunk === null) {
+    throw new Error('stream has ended without data')
+  }
+
+  if (size !== undefined && chunk.length !== size) {
+    const error = new Error(`stream has ended with not enough data (actual: ${chunk.length}, expected: ${size})`)
+    Object.defineProperties(error, {
+      chunk: {
+        value: chunk,
+      },
+    })
+    throw error
+  }
+
+  return chunk
+}
+
+/**
+ * Skips a given number of bytes from a readable stream.
+ *
+ * @param {Readable} stream - A readable stream to skip bytes from.
+ * @param {number} size - The number of bytes to skip.
+ * @returns {Promise<number>} A Promise that resolves to the number of bytes actually skipped. If the end of the stream is reached before all bytes are skipped, the Promise resolves to the number of bytes that were skipped before the end of the stream was reached. The Promise is rejected if there is an error while reading from the stream.
+ */
+async function skip(stream, size) {
+  return stream.errored != null
+    ? Promise.reject(stream.errored)
+    : size === 0 || stream.closed || stream.readableEnded
+    ? Promise.resolve(0)
+    : new Promise((resolve, reject) => {
+        let left = size
+        function onEnd() {
+          resolve(size - left)
+          removeListeners()
+        }
+        function onError(error) {
+          reject(error)
+          removeListeners()
+        }
+        function onReadable() {
+          const data = stream.read()
+          left -= data === null ? 0 : data.length
+          if (left > 0) {
+            // continue to read
+          } else {
+            // if more than wanted has been read, push back the rest
+            if (left < 0) {
+              stream.unshift(data.slice(left))
+            }
+
+            resolve(size)
+            removeListeners()
+          }
+        }
+        function removeListeners() {
+          stream.removeListener('end', onEnd)
+          stream.removeListener('error', onError)
+          stream.removeListener('readable', onReadable)
+        }
+        stream.on('end', onEnd)
+        stream.on('error', onError)
+        stream.on('readable', onReadable)
+        onReadable()
+      })
+}
+exports.skip = skip
+
+/**
+ * Skips a given number of bytes from a stream.
+ *
+ * @param {Readable} stream - A readable stream to skip bytes from.
+ * @param {number} size - The number of bytes to skip.
+ * @returns {Promise<void>} - A Promise that resolves when the exact number of bytes have been skipped. The Promise is rejected if there is an error while reading from the stream or the stream ends before the exact number of bytes have been skipped.
+ */
+exports.skipStrict = async function skipStrict(stream, size) {
+  const bytesSkipped = await skip(stream, size)
+  if (bytesSkipped !== size) {
+    const error = new Error(`stream has ended with not enough data (actual: ${bytesSkipped}, expected: ${size})`)
+    error.bytesSkipped = bytesSkipped
+    throw error
+  }
+}

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

@@ -1,43 +0,0 @@
-/* eslint-env jest */
-
-const { Readable } = require('stream')
-
-const { readChunk } = require('./')
-
-const makeStream = it => Readable.from(it, { objectMode: false })
-makeStream.obj = Readable.from
-
-describe('readChunk', () => {
-  it('returns null if stream is empty', async () => {
-    expect(await readChunk(makeStream([]))).toBe(null)
-  })
-
-  describe('with binary stream', () => {
-    it('returns the first chunk of data', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']))).toEqual(Buffer.from('foo'))
-    })
-
-    it('returns a chunk of the specified size (smaller than first)', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 2)).toEqual(Buffer.from('fo'))
-    })
-
-    it('returns a chunk of the specified size (larger than first)', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 4)).toEqual(Buffer.from('foob'))
-    })
-
-    it('returns less data if stream ends', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 10)).toEqual(Buffer.from('foobar'))
-    })
-
-    it('returns an empty buffer if the specified size is 0', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 0)).toEqual(Buffer.alloc(0))
-    })
-  })
-
-  describe('with object stream', () => {
-    it('returns the first chunk of data verbatim', async () => {
-      const chunks = [{}, {}]
-      expect(await readChunk(makeStream.obj(chunks))).toBe(chunks[0])
-    })
-  })
-})

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

@@ -0,0 +1,147 @@
+'use strict'
+
+const { describe, it } = require('test')
+const assert = require('node:assert').strict
+
+const { Readable } = require('stream')
+
+const { readChunk, readChunkStrict, skip, skipStrict } = require('./')
+
+const makeStream = it => Readable.from(it, { objectMode: false })
+makeStream.obj = Readable.from
+
+const rejectionOf = promise =>
+  promise.then(
+    value => {
+      throw value
+    },
+    error => error
+  )
+
+const makeErrorTests = fn => {
+  it('rejects if the stream errors', async () => {
+    const error = new Error()
+    const stream = makeStream([])
+
+    const pError = rejectionOf(fn(stream, 10))
+    stream.destroy(error)
+
+    assert.strict(await pError, error)
+  })
+
+  // only supported for Node >= 18
+  if (process.versions.node.split('.')[0] >= 18) {
+    it('rejects if the stream has already errored', async () => {
+      const error = new Error()
+      const stream = makeStream([])
+
+      await new Promise(resolve => {
+        stream.once('error', resolve).destroy(error)
+      })
+
+      assert.strict(await rejectionOf(fn(stream, 10)), error)
+    })
+  }
+}
+
+describe('readChunk', () => {
+  it('rejects if size is less than or equal to 0', async () => {
+    const error = await rejectionOf(readChunk(makeStream([]), 0))
+    assert.strictEqual(error.code, 'ERR_ASSERTION')
+  })
+
+  it('rejects if size is greater than or equal to 1 GiB', async () => {
+    const error = await rejectionOf(readChunk(makeStream([]), 1024 * 1024 * 1024))
+    assert.strictEqual(error.code, 'ERR_ASSERTION')
+  })
+
+  makeErrorTests(readChunk)
+
+  it('returns null if stream is empty', async () => {
+    assert.strictEqual(await readChunk(makeStream([])), null)
+  })
+
+  it('returns null if the stream is already ended', async () => {
+    const stream = await makeStream([])
+    await readChunk(stream)
+
+    assert.strictEqual(await readChunk(stream), null)
+  })
+
+  describe('with binary stream', () => {
+    it('returns the first chunk of data', async () => {
+      assert.deepEqual(await readChunk(makeStream(['foo', 'bar'])), Buffer.from('foo'))
+    })
+
+    it('returns a chunk of the specified size (smaller than first)', async () => {
+      assert.deepEqual(await readChunk(makeStream(['foo', 'bar']), 2), Buffer.from('fo'))
+    })
+
+    it('returns a chunk of the specified size (larger than first)', async () => {
+      assert.deepEqual(await readChunk(makeStream(['foo', 'bar']), 4), Buffer.from('foob'))
+    })
+
+    it('returns less data if stream ends', async () => {
+      assert.deepEqual(await readChunk(makeStream(['foo', 'bar']), 10), Buffer.from('foobar'))
+    })
+  })
+
+  describe('with object stream', () => {
+    it('returns the first chunk of data verbatim', async () => {
+      const chunks = [{}, {}]
+      assert.strictEqual(await readChunk(makeStream.obj(chunks)), chunks[0])
+    })
+  })
+})
+
+describe('readChunkStrict', function () {
+  it('throws if stream is empty', async () => {
+    const error = await rejectionOf(readChunkStrict(makeStream([])))
+    assert(error instanceof Error)
+    assert.strictEqual(error.message, 'stream has ended without data')
+    assert.strictEqual(error.chunk, undefined)
+  })
+
+  it('throws if stream ends with not enough data', async () => {
+    const error = await rejectionOf(readChunkStrict(makeStream(['foo', 'bar']), 10))
+    assert(error instanceof Error)
+    assert.strictEqual(error.message, 'stream has ended with not enough data (actual: 6, expected: 10)')
+    assert.deepEqual(error.chunk, Buffer.from('foobar'))
+  })
+})
+
+describe('skip', function () {
+  makeErrorTests(skip)
+
+  it('returns 0 if size is 0', async () => {
+    assert.strictEqual(await skip(makeStream(['foo']), 0), 0)
+  })
+
+  it('returns 0 if the stream is already ended', async () => {
+    const stream = await makeStream([])
+    await readChunk(stream)
+
+    assert.strictEqual(await skip(stream, 10), 0)
+  })
+
+  it('skips a number of bytes', async () => {
+    const stream = makeStream('foo bar')
+
+    assert.strictEqual(await skip(stream, 4), 4)
+    assert.deepEqual(await readChunk(stream, 4), Buffer.from('bar'))
+  })
+
+  it('returns less size if stream ends', async () => {
+    assert.deepEqual(await skip(makeStream('foo bar'), 10), 7)
+  })
+})
+
+describe('skipStrict', function () {
+  it('throws if stream ends with not enough data', async () => {
+    const error = await rejectionOf(skipStrict(makeStream('foo bar'), 10))
+
+    assert(error instanceof Error)
+    assert.strictEqual(error.message, 'stream has ended with not enough data (actual: 7, expected: 10)')
+    assert.deepEqual(error.bytesSkipped, 7)
+  })
+})