fix(@xen-orchestra/vmware-explorer): cleanup

.commitlintrc.json

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

.eslintrc.js

@@ -28,7 +28,7 @@ module.exports = {
       },
     },
     {
-      files: ['*.{integ,spec,test}.{,c,m}js'],
+      files: ['*.{spec,test}.{,c,m}js'],
       rules: {
         'n/no-unpublished-require': 'off',
         'n/no-unpublished-import': 'off',

.github/workflows/ci.yml

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

.github/workflows/push.yml

@@ -0,0 +1,12 @@
+name: CI
+on: push
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Build docker image
+        run: docker-compose -f docker/docker-compose.dev.yml build
+      - name: Create the container and start the tests
+        run: docker-compose -f docker/docker-compose.dev.yml up --exit-code-from xo

.husky/commit-msg

@@ -1,11 +0,0 @@
-#!/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

@vates/diff/.USAGE.md

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

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

@vates/diff/README.md

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

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

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

@@ -1,36 +0,0 @@
-{
-  "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/fuse-vhd/package.json

@@ -21,7 +21,7 @@
     "fuse-native": "^2.2.6",
     "lru-cache": "^7.14.0",
     "promise-toolbox": "^0.21.0",
-    "vhd-lib": "^4.4.1"
+    "vhd-lib": "^4.2.1"
   },
   "scripts": {
     "postversion": "npm publish --access public"

@vates/nbd-client/index.js

@@ -16,13 +16,9 @@ const {
   NBD_REPLY_MAGIC,
   NBD_REQUEST_MAGIC,
   OPTS_MAGIC,
-  NBD_CMD_DISC,
 } = require('./constants.js')
-const { fromCallback, pRetry, pDelay, pTimeout } = require('promise-toolbox')
+const { fromCallback } = require('promise-toolbox')
 const { readChunkStrict } = require('@vates/read-chunk')
-const { createLogger } = require('@xen-orchestra/log')
-
-const { warn } = createLogger('vates:nbd-client')
 
 // documentation is here : https://github.com/NetworkBlockDevice/nbd/blob/master/doc/proto.md
 
@@ -35,34 +31,18 @@ module.exports = class NbdClient {
   #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 } = {}
-  ) {
+  constructor({ address, port = NBD_DEFAULT_PORT, exportname, cert }) {
     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() {
@@ -97,55 +77,19 @@ module.exports = class NbdClient {
     })
   }
 
-  async #connect() {
-    // first we connect to the server without tls, and then we upgrade the connection
+  async connect() {
+    // first we connect to the serve 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
@@ -223,6 +167,7 @@ module.exports = class NbdClient {
     this.#commandQueryBacklog.forEach(({ reject }) => {
       reject(error)
     })
+    await this.disconnect()
   }
 
   async #readBlockResponse() {
@@ -230,6 +175,7 @@ module.exports = class NbdClient {
     if (this.#waitingForResponse) {
       return
     }
+
     try {
       this.#waitingForResponse = true
       const magic = await this.#readInt32()
@@ -254,8 +200,7 @@ module.exports = class NbdClient {
       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()
+        await this.#readBlockResponse()
       }
     } catch (error) {
       // reject all the promises
@@ -266,11 +211,6 @@ module.exports = class NbdClient {
   }
 
   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++
 
@@ -285,67 +225,19 @@ module.exports = class NbdClient {
     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,
+        reject,
       })
       // really send the command to the server
-      this.#write(buffer).catch(decoratedReject)
+      this.#write(buffer).catch(reject)
 
       // #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(exportSize / chunkSize)
-        for (let index = 0; 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

@@ -13,17 +13,16 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "1.2.0",
+  "version": "1.0.0",
   "engines": {
     "node": ">=14.0"
   },
   "dependencies": {
     "@vates/async-each": "^1.0.0",
-    "@vates/read-chunk": "^1.1.1",
+    "@vates/read-chunk": "^1.0.1",
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/log": "^0.6.0",
     "promise-toolbox": "^0.21.0",
-    "xen-api": "^1.3.1"
+    "xen-api": "^1.2.2"
   },
   "devDependencies": {
     "tap": "^16.3.0",
@@ -31,6 +30,6 @@
   },
   "scripts": {
     "postversion": "npm publish --access public",
-    "test-integration": "tap --lines 70 --functions 36 --branches 54 --statements 69 *.integ.js"
+    "test-integration": "tap *.spec.js"
   }
 }

@vates/read-chunk/.USAGE.md

@@ -24,25 +24,3 @@ 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

@@ -43,28 +43,6 @@ 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/index.js

@@ -1,36 +1,11 @@
 '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) =>
-  stream.errored != null
-    ? Promise.reject(stream.errored)
-    : stream.closed || stream.readableEnded
+  stream.closed || stream.readableEnded
     ? Promise.resolve(null)
+    : size === 0
+    ? Promise.resolve(Buffer.alloc(0))
     : 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()
@@ -58,21 +33,6 @@ const readChunk = (stream, size) =>
       })
 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) {
@@ -80,7 +40,7 @@ exports.readChunkStrict = async function readChunkStrict(stream, size) {
   }
 
   if (size !== undefined && chunk.length !== size) {
-    const error = new Error(`stream has ended with not enough data (actual: ${chunk.length}, expected: ${size})`)
+    const error = new Error('stream has ended with not enough data')
     Object.defineProperties(error, {
       chunk: {
         value: chunk,
@@ -91,69 +51,3 @@ exports.readChunkStrict = async function readChunkStrict(stream, size) {
 
   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.test.js

@@ -5,58 +5,12 @@ const assert = require('node:assert').strict
 
 const { Readable } = require('stream')
 
-const { readChunk, readChunkStrict, skip, skipStrict } = require('./')
+const { readChunk, readChunkStrict } = 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)
   })
@@ -84,6 +38,10 @@ describe('readChunk', () => {
     it('returns less data if stream ends', async () => {
       assert.deepEqual(await readChunk(makeStream(['foo', 'bar']), 10), Buffer.from('foobar'))
     })
+
+    it('returns an empty buffer if the specified size is 0', async () => {
+      assert.deepEqual(await readChunk(makeStream(['foo', 'bar']), 0), Buffer.alloc(0))
+    })
   })
 
   describe('with object stream', () => {
@@ -94,6 +52,14 @@ describe('readChunk', () => {
   })
 })
 
+const rejectionOf = promise =>
+  promise.then(
+    value => {
+      throw value
+    },
+    error => error
+  )
+
 describe('readChunkStrict', function () {
   it('throws if stream is empty', async () => {
     const error = await rejectionOf(readChunkStrict(makeStream([])))
@@ -105,43 +71,7 @@ describe('readChunkStrict', function () {
   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.strictEqual(error.message, 'stream has ended with not enough data')
     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)
-  })
-})

@vates/read-chunk/package.json

@@ -19,7 +19,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "1.1.1",
+  "version": "1.0.1",
   "engines": {
     "node": ">=8.10"
   },

@vates/stream-reader/.USAGE.md

@@ -1,42 +0,0 @@
-```js
-import StreamReader from '@vates/stream-reader'
-
-const reader = new StreamReader(stream)
-```
-
-### `.read([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
-const chunk = await reader.read(512)
-```
-
-### `.readStrict([size])`
-
-Similar behavior to `readChunk` but throws if the stream ended before the requested data could be read.
-
-```js
-const chunk = await reader.readStrict(512)
-```
-
-### `.skip(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
-const bytesSkipped = await reader.skip(2 * 1024 * 1024 * 1024)
-```
-
-### `.skipStrict(size)`
-
-Skips a given number of bytes from a stream and throws if the stream ended before enough stream has been skipped.
-
-```js
-await reader.skipStrict(2 * 1024 * 1024 * 1024)
-```

@vates/stream-reader/.npmignore

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

@vates/stream-reader/README.md

@@ -1,75 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/stream-reader
-
-[![Package Version](https://badgen.net/npm/v/@vates/stream-reader)](https://npmjs.org/package/@vates/stream-reader) ![License](https://badgen.net/npm/license/@vates/stream-reader) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/stream-reader)](https://bundlephobia.com/result?p=@vates/stream-reader) [![Node compatibility](https://badgen.net/npm/node/@vates/stream-reader)](https://npmjs.org/package/@vates/stream-reader)
-
-> Efficiently reads and skips chunks of a given size in a stream
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/stream-reader):
-
-```sh
-npm install --save @vates/stream-reader
-```
-
-## Usage
-
-```js
-import StreamReader from '@vates/stream-reader'
-
-const reader = new StreamReader(stream)
-```
-
-### `.read([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
-const chunk = await reader.read(512)
-```
-
-### `.readStrict([size])`
-
-Similar behavior to `readChunk` but throws if the stream ended before the requested data could be read.
-
-```js
-const chunk = await reader.readStrict(512)
-```
-
-### `.skip(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
-const bytesSkipped = await reader.skip(2 * 1024 * 1024 * 1024)
-```
-
-### `.skipStrict(size)`
-
-Skips a given number of bytes from a stream and throws if the stream ended before enough stream has been skipped.
-
-```js
-await reader.skipStrict(2 * 1024 * 1024 * 1024)
-```
-
-## 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/stream-reader/index.js

@@ -1,123 +0,0 @@
-'use strict'
-
-const assert = require('node:assert')
-const { finished, Readable } = require('node:stream')
-
-const noop = Function.prototype
-
-// Inspired by https://github.com/nodejs/node/blob/85705a47958c9ae5dbaa1f57456db19bdefdc494/lib/internal/streams/readable.js#L1107
-class StreamReader {
-  #ended = false
-  #error
-  #executor = resolve => {
-    this.#resolve = resolve
-  }
-  #stream
-  #resolve = noop
-
-  constructor(stream) {
-    stream = typeof stream.pipe === 'function' ? stream : Readable.from(stream)
-
-    this.#stream = stream
-
-    stream.on('readable', () => this.#resolve())
-
-    finished(stream, { writable: false }, error => {
-      this.#error = error
-      this.#ended = true
-      this.#resolve()
-    })
-  }
-
-  async read(size) {
-    if (size !== undefined) {
-      assert(size > 0)
-    }
-
-    do {
-      if (this.#ended) {
-        if (this.#error) {
-          throw this.#error
-        }
-        return null
-      }
-
-      const value = this.#stream.read(size)
-      if (value !== null) {
-        return value
-      }
-
-      await new Promise(this.#executor)
-    } while (true)
-  }
-
-  async readStrict(size) {
-    const chunk = await this.read(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
-  }
-
-  async skip(size) {
-    if (size === 0) {
-      return size
-    }
-
-    let toSkip = size
-    do {
-      if (this.#ended) {
-        if (this.#error) {
-          throw this.#error
-        }
-        return size - toSkip
-      }
-
-      const data = this.#stream.read()
-      if (data !== null) {
-        toSkip -= data === null ? 0 : data.length
-        if (toSkip > 0) {
-          // continue to read
-        } else {
-          // if more than wanted has been read, push back the rest
-          if (toSkip < 0) {
-            this.#stream.unshift(data.slice(toSkip))
-          }
-
-          return size
-        }
-      }
-
-      await new Promise(this.#executor)
-    } while (true)
-  }
-
-  async skipStrict(size) {
-    const bytesSkipped = await this.skip(size)
-    if (bytesSkipped !== size) {
-      const error = new Error(`stream has ended with not enough data (actual: ${bytesSkipped}, expected: ${size})`)
-      error.bytesSkipped = bytesSkipped
-      throw error
-    }
-  }
-}
-
-StreamReader.prototype[Symbol.asyncIterator] = async function* asyncIterator() {
-  let chunk
-  while ((chunk = await this.read()) !== null) {
-    yield chunk
-  }
-}
-
-module.exports = StreamReader

@vates/stream-reader/index.test.js

@@ -1,141 +0,0 @@
-'use strict'
-
-const { describe, it } = require('test')
-const assert = require('node:assert').strict
-
-const { Readable } = require('stream')
-
-const StreamReader = require('./index.js')
-
-const makeStream = it => Readable.from(it, { objectMode: false })
-makeStream.obj = Readable.from
-
-const rejectionOf = promise =>
-  promise.then(
-    value => {
-      throw value
-    },
-    error => error
-  )
-
-const makeErrorTests = method => {
-  it('rejects if the stream errors', async () => {
-    const error = new Error()
-    const stream = makeStream([])
-
-    const pError = rejectionOf(new StreamReader(stream)[method](10))
-    stream.destroy(error)
-
-    assert.strict(await pError, error)
-  })
-
-  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(new StreamReader(stream)[method](10)), error)
-  })
-}
-
-describe('read()', () => {
-  it('rejects if size is less than or equal to 0', async () => {
-    const error = await rejectionOf(new StreamReader(makeStream([])).read(0))
-    assert.strictEqual(error.code, 'ERR_ASSERTION')
-  })
-
-  it('returns null if stream is empty', async () => {
-    assert.strictEqual(await new StreamReader(makeStream([])).read(), null)
-  })
-
-  makeErrorTests('read')
-
-  it('returns null if the stream is already ended', async () => {
-    const reader = new StreamReader(makeStream([]))
-
-    await reader.read()
-
-    assert.strictEqual(await reader.read(), null)
-  })
-
-  describe('with binary stream', () => {
-    it('returns the first chunk of data', async () => {
-      assert.deepEqual(await new StreamReader(makeStream(['foo', 'bar'])).read(), Buffer.from('foo'))
-    })
-
-    it('returns a chunk of the specified size (smaller than first)', async () => {
-      assert.deepEqual(await new StreamReader(makeStream(['foo', 'bar'])).read(2), Buffer.from('fo'))
-    })
-
-    it('returns a chunk of the specified size (larger than first)', async () => {
-      assert.deepEqual(await new StreamReader(makeStream(['foo', 'bar'])).read(4), Buffer.from('foob'))
-    })
-
-    it('returns less data if stream ends', async () => {
-      assert.deepEqual(await new StreamReader(makeStream(['foo', 'bar'])).read(10), Buffer.from('foobar'))
-    })
-  })
-
-  describe('with object stream', () => {
-    it('returns the first chunk of data verbatim', async () => {
-      const chunks = [{}, {}]
-      assert.strictEqual(await new StreamReader(makeStream.obj(chunks)).read(), chunks[0])
-    })
-  })
-})
-
-describe('readStrict()', function () {
-  it('throws if stream is empty', async () => {
-    const error = await rejectionOf(new StreamReader(makeStream([])).readStrict())
-    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(new StreamReader(makeStream(['foo', 'bar'])).readStrict(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 new StreamReader(makeStream(['foo'])).skip(0), 0)
-  })
-
-  it('returns 0 if the stream is already ended', async () => {
-    const reader = new StreamReader(makeStream([]))
-
-    await reader.read()
-
-    assert.strictEqual(await reader.skip(10), 0)
-  })
-
-  it('skips a number of bytes', async () => {
-    const reader = new StreamReader(makeStream('foo bar'))
-
-    assert.strictEqual(await reader.skip(4), 4)
-    assert.deepEqual(await reader.read(4), Buffer.from('bar'))
-  })
-
-  it('returns less size if stream ends', async () => {
-    assert.deepEqual(await new StreamReader(makeStream('foo bar')).skip(10), 7)
-  })
-})
-
-describe('skipStrict()', function () {
-  it('throws if stream ends with not enough data', async () => {
-    const error = await rejectionOf(new StreamReader(makeStream('foo bar')).skipStrict(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)
-  })
-})

@vates/stream-reader/package.json

@@ -1,39 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/stream-reader",
-  "description": "Efficiently reads and skips chunks of a given size in a stream",
-  "keywords": [
-    "async",
-    "chunk",
-    "data",
-    "node",
-    "promise",
-    "read",
-    "reader",
-    "skip",
-    "stream"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/stream-reader",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/stream-reader",
-    "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": ">=10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "node--test"
-  },
-  "devDependencies": {
-    "test": "^3.3.0"
-  }
-}

@vates/task/.USAGE.md

@@ -2,12 +2,7 @@
 import { Task } from '@vates/task'
 
 const task = new Task({
-  // data in this object will be sent along the *start* event
-  //
-  // property names should be chosen as not to clash with properties used by `Task` or `combineEvents`
-  data: {
-    name: 'my task',
-  },
+  name: 'my task',
 
   // if defined, a new detached task is created
   //
@@ -30,19 +25,8 @@ const task = new Task({
 // this field is settable once before being observed
 task.id
 
-// contains the current status of the task
-//
-// possible statuses are:
-// - pending
-// - success
-// - failure
-// - aborted
 task.status
-
-// Triggers the abort signal associated to the task.
-//
-// This simply requests the task to abort, it will be up to the task to handle or not this signal.
-task.abort(reason)
+await task.abort()
 
 // if fn rejects, the task will be marked as failed
 const result = await task.runInside(fn)
@@ -50,11 +34,7 @@ const result = await task.runInside(fn)
 // if fn rejects, the task will be marked as failed
 // if fn resolves, the task will be marked as succeeded
 const result = await task.run(fn)
-```
 
-Inside a task:
-
-```js
 // the abort signal of the current task if any, otherwise is `undefined`
 Task.abortSignal
 
@@ -72,43 +52,3 @@ Task.warning(message, data)
 // - progress
 Task.set(property, value)
 ```
-
-### `combineEvents`
-
-Create a consolidated log from individual events.
-
-It can be used directly as an `onProgress` callback:
-
-```js
-import { makeOnProgress } from '@vates/task/combineEvents'
-
-const onProgress = makeOnProgress({
-  // This function is called each time a root task starts.
-  //
-  // It will be called for as many times as there are tasks created with this `onProgress` function.
-  onRootTaskStart(taskLog) {
-    // `taskLog` is an object reflecting the state of this task and all its subtasks,
-    // and will be mutated in real-time to reflect the changes of the task.
-  },
-
-  // This function is called each time a root task ends.
-  onRootTaskEnd(taskLog) {},
-
-  // This function is called each time a root task or a subtask is updated.
-  //
-  // `taskLog.$root` can be used to uncondionally access the root task.
-  onTaskUpdate(taskLog) {},
-})
-
-Task.run({ data: { name: 'my task' }, onProgress }, asyncFn)
-```
-
-It can also be fed event logs directly:
-
-```js
-import { makeOnProgress } from '@vates/task/combineEvents'
-
-const onProgress = makeOnProgress({ onRootTaskStart, onRootTaskEnd, onTaskUpdate })
-
-eventLogs.forEach(onProgress)
-```

@vates/task/README.md

@@ -18,12 +18,7 @@ npm install --save @vates/task
 import { Task } from '@vates/task'
 
 const task = new Task({
-  // data in this object will be sent along the *start* event
-  //
-  // property names should be chosen as not to clash with properties used by `Task` or `combineEvents`
-  data: {
-    name: 'my task',
-  },
+  name: 'my task',
 
   // if defined, a new detached task is created
   //
@@ -46,19 +41,8 @@ const task = new Task({
 // this field is settable once before being observed
 task.id
 
-// contains the current status of the task
-//
-// possible statuses are:
-// - pending
-// - success
-// - failure
-// - aborted
 task.status
-
-// Triggers the abort signal associated to the task.
-//
-// This simply requests the task to abort, it will be up to the task to handle or not this signal.
-task.abort(reason)
+await task.abort()
 
 // if fn rejects, the task will be marked as failed
 const result = await task.runInside(fn)
@@ -66,11 +50,7 @@ const result = await task.runInside(fn)
 // if fn rejects, the task will be marked as failed
 // if fn resolves, the task will be marked as succeeded
 const result = await task.run(fn)
-```
 
-Inside a task:
-
-```js
 // the abort signal of the current task if any, otherwise is `undefined`
 Task.abortSignal
 
@@ -89,46 +69,6 @@ Task.warning(message, data)
 Task.set(property, value)
 ```
 
-### `combineEvents`
-
-Create a consolidated log from individual events.
-
-It can be used directly as an `onProgress` callback:
-
-```js
-import { makeOnProgress } from '@vates/task/combineEvents'
-
-const onProgress = makeOnProgress({
-  // This function is called each time a root task starts.
-  //
-  // It will be called for as many times as there are tasks created with this `onProgress` function.
-  onRootTaskStart(taskLog) {
-    // `taskLog` is an object reflecting the state of this task and all its subtasks,
-    // and will be mutated in real-time to reflect the changes of the task.
-  },
-
-  // This function is called each time a root task ends.
-  onRootTaskEnd(taskLog) {},
-
-  // This function is called each time a root task or a subtask is updated.
-  //
-  // `taskLog.$root` can be used to uncondionally access the root task.
-  onTaskUpdate(taskLog) {},
-})
-
-Task.run({ data: { name: 'my task' }, onProgress }, asyncFn)
-```
-
-It can also be fed event logs directly:
-
-```js
-import { makeOnProgress } from '@vates/task/combineEvents'
-
-const onProgress = makeOnProgress({ onRootTaskStart, onRootTaskEnd, onTaskUpdate })
-
-eventLogs.forEach(onProgress)
-```
-
 ## Contributions
 
 Contributions are _very_ welcomed, either on the documentation or on

@vates/task/combineEvents.js

@@ -1,77 +0,0 @@
-'use strict'
-
-const assert = require('node:assert').strict
-
-const noop = Function.prototype
-
-function omit(source, keys, target = { __proto__: null }) {
-  for (const key of Object.keys(source)) {
-    if (!keys.has(key)) {
-      target[key] = source[key]
-    }
-  }
-  return target
-}
-
-const IGNORED_START_PROPS = new Set([
-  'end',
-  'infos',
-  'properties',
-  'result',
-  'status',
-  'tasks',
-  'timestamp',
-  'type',
-  'warnings',
-])
-
-exports.makeOnProgress = function ({ onRootTaskEnd = noop, onRootTaskStart = noop, onTaskUpdate = noop }) {
-  const taskLogs = new Map()
-  return function onProgress(event) {
-    const { id, type } = event
-    let taskLog
-    if (type === 'start') {
-      taskLog = omit(event, IGNORED_START_PROPS)
-      taskLog.start = event.timestamp
-      taskLog.status = 'pending'
-      taskLogs.set(id, taskLog)
-
-      const { parentId } = event
-      if (parentId === undefined) {
-        Object.defineProperty(taskLog, '$root', { value: taskLog })
-
-        // start of a root task
-        onRootTaskStart(taskLog)
-      } else {
-        // start of a subtask
-        const parent = taskLogs.get(parentId)
-        assert.notEqual(parent, undefined)
-
-        // inject a (non-enumerable) reference to the parent and the root task
-        Object.defineProperties(taskLog, { $parent: { value: parent }, $root: { value: parent.$root } })
-        ;(parent.tasks ?? (parent.tasks = [])).push(taskLog)
-      }
-    } else {
-      taskLog = taskLogs.get(id)
-      assert.notEqual(taskLog, undefined)
-
-      if (type === 'info' || type === 'warning') {
-        const key = type + 's'
-        const { data, message } = event
-        ;(taskLog[key] ?? (taskLog[key] = [])).push({ data, message })
-      } else if (type === 'property') {
-        ;(taskLog.properties ?? (taskLog.properties = { __proto__: null }))[event.name] = event.value
-      } else if (type === 'end') {
-        taskLog.end = event.timestamp
-        taskLog.result = event.result
-        taskLog.status = event.status
-      }
-
-      if (type === 'end' && taskLog.$root === taskLog) {
-        onRootTaskEnd(taskLog)
-      }
-    }
-
-    onTaskUpdate(taskLog)
-  }
-}

@vates/task/combineEvents.test.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const assert = require('node:assert').strict
-const { describe, it } = require('test')
-
-const { makeOnProgress } = require('./combineEvents.js')
-const { Task } = require('./index.js')
-
-describe('makeOnProgress()', function () {
-  it('works', async function () {
-    const events = []
-    let log
-    const task = new Task({
-      data: { name: 'task' },
-      onProgress: makeOnProgress({
-        onRootTaskStart(log_) {
-          assert.equal(log, undefined)
-          log = log_
-          events.push('onRootTaskStart')
-        },
-        onRootTaskEnd(log_) {
-          assert.equal(log_, log)
-          events.push('onRootTaskEnd')
-        },
-
-        onTaskUpdate(log_) {
-          assert.equal(log_.$root, log)
-          events.push('onTaskUpdate')
-        },
-      }),
-    })
-
-    assert.equal(events.length, 0)
-
-    await task.run(async () => {
-      assert.equal(events[0], 'onRootTaskStart')
-      assert.equal(events[1], 'onTaskUpdate')
-      assert.equal(log.name, 'task')
-
-      Task.set('progress', 0)
-      assert.equal(events[2], 'onTaskUpdate')
-      assert.equal(log.properties.progress, 0)
-
-      Task.info('foo', {})
-      assert.equal(events[3], 'onTaskUpdate')
-      assert.deepEqual(log.infos, [{ data: {}, message: 'foo' }])
-
-      await Task.run({ data: { name: 'subtask' } }, () => {
-        assert.equal(events[4], 'onTaskUpdate')
-        assert.equal(log.tasks[0].name, 'subtask')
-
-        Task.warning('bar', {})
-        assert.equal(events[5], 'onTaskUpdate')
-        assert.deepEqual(log.tasks[0].warnings, [{ data: {}, message: 'bar' }])
-      })
-      assert.equal(events[6], 'onTaskUpdate')
-      assert.equal(log.tasks[0].status, 'success')
-
-      Task.set('progress', 100)
-      assert.equal(events[7], 'onTaskUpdate')
-      assert.equal(log.properties.progress, 100)
-    })
-    assert.equal(events[8], 'onRootTaskEnd')
-    assert.equal(events[9], 'onTaskUpdate')
-    assert.equal(log.status, 'success')
-  })
-})

@vates/task/index.js

@@ -11,15 +11,13 @@ function define(object, property, value) {
 const noop = Function.prototype
 
 const ABORTED = 'aborted'
+const ABORTING = 'aborting'
 const FAILURE = 'failure'
 const PENDING = 'pending'
 const SUCCESS = 'success'
-exports.STATUS = { ABORTED, FAILURE, PENDING, SUCCESS }
-
-// stored in the global context so that various versions of the library can interact.
-const asyncStorageKey = '@vates/task@0'
-const asyncStorage = global[asyncStorageKey] ?? (global[asyncStorageKey] = new AsyncLocalStorage())
+exports.STATUS = { ABORTED, ABORTING, FAILURE, PENDING, SUCCESS }
 
+const asyncStorage = new AsyncLocalStorage()
 const getTask = () => asyncStorage.getStore()
 
 exports.Task = class Task {
@@ -68,6 +66,7 @@ exports.Task = class Task {
 
   #abortController = new AbortController()
   #onProgress
+  #parent
 
   get id() {
     return (this.id = Math.random().toString(36).slice(2))
@@ -83,14 +82,16 @@ exports.Task = class Task {
     return this.#status
   }
 
-  constructor({ data = {}, onProgress } = {}) {
-    this.#startData = data
+  constructor({ name, onProgress }) {
+    this.#startData = { name }
 
     if (onProgress !== undefined) {
       this.#onProgress = onProgress
     } else {
       const parent = getTask()
       if (parent !== undefined) {
+        this.#parent = parent
+
         const { signal } = parent.#abortController
         signal.addEventListener('abort', () => {
           this.#abortController.abort(signal.reason)
@@ -105,12 +106,8 @@ exports.Task = class Task {
 
     const { signal } = this.#abortController
     signal.addEventListener('abort', () => {
-      if (this.status === PENDING && !this.#running) {
-        this.#maybeStart()
-
-        const status = ABORTED
-        this.#status = status
-        this.#emit('end', { result: signal.reason, status })
+      if (this.status === PENDING) {
+        this.#status = this.#running ? ABORTING : ABORTED
       }
     })
   }
@@ -126,12 +123,14 @@ exports.Task = class Task {
     this.#onProgress(data)
   }
 
-  #maybeStart() {
-    const startData = this.#startData
-    if (startData !== undefined) {
-      this.#startData = undefined
-      this.#emit('start', startData)
+  #handleMaybeAbortion(result) {
+    if (this.status === ABORTING) {
+      this.#status = ABORTED
+      this.#emit('end', { status: ABORTED, result })
+      return true
     }
+
+    return false;
   }
 
   async run(fn) {
@@ -149,19 +148,22 @@ exports.Task = class Task {
     assert.equal(this.#running, false)
     this.#running = true
 
-    this.#maybeStart()
+    const startData = this.#startData
+    if (startData !== undefined) {
+      this.#startData = undefined
+      this.#emit('start', startData)
+    }
 
     try {
       const result = await asyncStorage.run(this, fn)
+      this.#handleMaybeAbortion(result)
       this.#running = false
       return result
     } catch (result) {
-      const { signal } = this.#abortController
-      const aborted = signal.aborted && result === signal.reason
-      const status = aborted ? ABORTED : FAILURE
-
-      this.#status = status
-      this.#emit('end', { status, result })
+      if (!this.#handleMaybeAbortion(result)) {
+        this.#status = FAILURE
+        this.#emit('end', { status: FAILURE, result })
+      }
       throw result
     }
   }

@vates/task/index.test.js

@@ -1,341 +0,0 @@
-'use strict'
-
-const assert = require('node:assert').strict
-const { describe, it } = require('test')
-
-const { Task } = require('./index.js')
-
-const noop = Function.prototype
-
-function assertEvent(task, expected, eventIndex = -1) {
-  const logs = task.$events
-  const actual = logs[eventIndex < 0 ? logs.length + eventIndex : eventIndex]
-
-  assert.equal(typeof actual, 'object')
-  assert.equal(typeof actual.id, 'string')
-  assert.equal(typeof actual.timestamp, 'number')
-  for (const keys of Object.keys(expected)) {
-    assert.equal(actual[keys], expected[keys])
-  }
-}
-
-// like new Task() but with a custom onProgress which adds event to task.$events
-function createTask(opts) {
-  const events = []
-  const task = new Task({ ...opts, onProgress: events.push.bind(events) })
-  task.$events = events
-  return task
-}
-
-describe('Task', function () {
-  describe('contructor', function () {
-    it('data properties are passed to the start event', async function () {
-      const data = { foo: 0, bar: 1 }
-      const task = createTask({ data })
-      await task.run(noop)
-      assertEvent(task, { ...data, type: 'start' }, 0)
-    })
-  })
-
-  it('subtasks events are passed to root task', async function () {
-    const task = createTask()
-    const result = {}
-
-    await task.run(async () => {
-      await new Task().run(() => result)
-    })
-
-    assert.equal(task.$events.length, 4)
-    assertEvent(task, { type: 'start', parentId: task.id }, 1)
-    assertEvent(task, { type: 'end', status: 'success', result }, 2)
-  })
-
-  describe('.abortSignal', function () {
-    it('is undefined when run outside a task', function () {
-      assert.equal(Task.abortSignal, undefined)
-    })
-
-    it('is the current abort signal when run inside a task', async function () {
-      const task = createTask()
-      await task.run(() => {
-        const { abortSignal } = Task
-        assert.equal(abortSignal.aborted, false)
-        task.abort()
-        assert.equal(abortSignal.aborted, true)
-      })
-    })
-  })
-
-  describe('.abort()', function () {
-    it('aborts if the task throws fails with the abort reason', async function () {
-      const task = createTask()
-      const reason = {}
-
-      await task
-        .run(() => {
-          task.abort(reason)
-
-          Task.abortSignal.throwIfAborted()
-        })
-        .catch(noop)
-
-      assert.equal(task.status, 'aborted')
-
-      assert.equal(task.$events.length, 2)
-      assertEvent(task, { type: 'start' }, 0)
-      assertEvent(task, { type: 'end', status: 'aborted', result: reason }, 1)
-    })
-
-    it('does not abort if the task fails without the abort reason', async function () {
-      const task = createTask()
-      const result = new Error()
-
-      await task
-        .run(() => {
-          task.abort({})
-
-          throw result
-        })
-        .catch(noop)
-
-      assert.equal(task.status, 'failure')
-
-      assert.equal(task.$events.length, 2)
-      assertEvent(task, { type: 'start' }, 0)
-      assertEvent(task, { type: 'end', status: 'failure', result }, 1)
-    })
-
-    it('does not abort if the task succeed', async function () {
-      const task = createTask()
-      const result = {}
-
-      await task
-        .run(() => {
-          task.abort({})
-
-          return result
-        })
-        .catch(noop)
-
-      assert.equal(task.status, 'success')
-
-      assert.equal(task.$events.length, 2)
-      assertEvent(task, { type: 'start' }, 0)
-      assertEvent(task, { type: 'end', status: 'success', result }, 1)
-    })
-
-    it('aborts before task is running', function () {
-      const task = createTask()
-      const reason = {}
-
-      task.abort(reason)
-
-      assert.equal(task.status, 'aborted')
-
-      assert.equal(task.$events.length, 2)
-      assertEvent(task, { type: 'start' }, 0)
-      assertEvent(task, { type: 'end', status: 'aborted', result: reason }, 1)
-    })
-  })
-
-  describe('.info()', function () {
-    it('does nothing when run outside a task', function () {
-      Task.info('foo')
-    })
-
-    it('emits an info message when run inside a task', async function () {
-      const task = createTask()
-      await task.run(() => {
-        Task.info('foo')
-        assertEvent(task, {
-          data: undefined,
-          message: 'foo',
-          type: 'info',
-        })
-      })
-    })
-  })
-
-  describe('.set()', function () {
-    it('does nothing when run outside a task', function () {
-      Task.set('progress', 10)
-    })
-
-    it('emits an info message when run inside a task', async function () {
-      const task = createTask()
-      await task.run(() => {
-        Task.set('progress', 10)
-        assertEvent(task, {
-          name: 'progress',
-          type: 'property',
-          value: 10,
-        })
-      })
-    })
-  })
-
-  describe('.warning()', function () {
-    it('does nothing when run outside a task', function () {
-      Task.warning('foo')
-    })
-
-    it('emits an warning message when run inside a task', async function () {
-      const task = createTask()
-      await task.run(() => {
-        Task.warning('foo')
-        assertEvent(task, {
-          data: undefined,
-          message: 'foo',
-          type: 'warning',
-        })
-      })
-    })
-  })
-
-  describe('#id', function () {
-    it('can be set', function () {
-      const task = createTask()
-      task.id = 'foo'
-      assert.equal(task.id, 'foo')
-    })
-
-    it('cannot be set more than once', function () {
-      const task = createTask()
-      task.id = 'foo'
-
-      assert.throws(() => {
-        task.id = 'bar'
-      }, TypeError)
-    })
-
-    it('is randomly generated if not set', function () {
-      assert.notEqual(createTask().id, createTask().id)
-    })
-
-    it('cannot be set after being observed', function () {
-      const task = createTask()
-      noop(task.id)
-
-      assert.throws(() => {
-        task.id = 'bar'
-      }, TypeError)
-    })
-  })
-
-  describe('#status', function () {
-    it('starts as pending', function () {
-      assert.equal(createTask().status, 'pending')
-    })
-
-    it('changes to success when finish without error', async function () {
-      const task = createTask()
-      await task.run(noop)
-      assert.equal(task.status, 'success')
-    })
-
-    it('changes to failure when finish with error', async function () {
-      const task = createTask()
-      await task
-        .run(() => {
-          throw Error()
-        })
-        .catch(noop)
-      assert.equal(task.status, 'failure')
-    })
-
-    it('changes to aborted after run is complete', async function () {
-      const task = createTask()
-      await task
-        .run(() => {
-          task.abort()
-          assert.equal(task.status, 'pending')
-          Task.abortSignal.throwIfAborted()
-        })
-        .catch(noop)
-      assert.equal(task.status, 'aborted')
-    })
-
-    it('changes to aborted if aborted when not running', async function () {
-      const task = createTask()
-      task.abort()
-      assert.equal(task.status, 'aborted')
-    })
-  })
-
-  function makeRunTests(run) {
-    it('starts the task', async function () {
-      const task = createTask()
-      await run(task, () => {
-        assertEvent(task, { type: 'start' })
-      })
-    })
-
-    it('finishes the task on success', async function () {
-      const task = createTask()
-      await run(task, () => 'foo')
-      assert.equal(task.status, 'success')
-      assertEvent(task, {
-        status: 'success',
-        result: 'foo',
-        type: 'end',
-      })
-    })
-
-    it('fails the task on error', async function () {
-      const task = createTask()
-      const e = new Error()
-      await run(task, () => {
-        throw e
-      }).catch(noop)
-
-      assert.equal(task.status, 'failure')
-      assertEvent(task, {
-        status: 'failure',
-        result: e,
-        type: 'end',
-      })
-    })
-  }
-  describe('.run', function () {
-    makeRunTests((task, fn) => task.run(fn))
-  })
-  describe('.wrap', function () {
-    makeRunTests((task, fn) => task.wrap(fn)())
-  })
-
-  function makeRunInsideTests(run) {
-    it('starts the task', async function () {
-      const task = createTask()
-      await run(task, () => {
-        assertEvent(task, { type: 'start' })
-      })
-    })
-
-    it('does not finish the task on success', async function () {
-      const task = createTask()
-      await run(task, () => 'foo')
-      assert.equal(task.status, 'pending')
-    })
-
-    it('fails the task on error', async function () {
-      const task = createTask()
-      const e = new Error()
-      await run(task, () => {
-        throw e
-      }).catch(noop)
-
-      assert.equal(task.status, 'failure')
-      assertEvent(task, {
-        status: 'failure',
-        result: e,
-        type: 'end',
-      })
-    })
-  }
-  describe('.runInside', function () {
-    makeRunInsideTests((task, fn) => task.runInside(fn))
-  })
-  describe('.wrapInside', function () {
-    makeRunInsideTests((task, fn) => task.wrapInside(fn)())
-  })
-})

@vates/task/package.json

@@ -13,19 +13,11 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "0.1.2",
+  "version": "0.0.1",
   "engines": {
     "node": ">=14"
   },
-  "devDependencies": {
-    "test": "^3.3.0"
-  },
   "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "node--test"
-  },
-  "exports": {
-    ".": "./index.js",
-    "./combineEvents": "./combineEvents.js"
+    "postversion": "npm publish --access public"
   }
 }

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

@@ -7,8 +7,8 @@
   "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
   "dependencies": {
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/backups": "^0.37.0",
-    "@xen-orchestra/fs": "^4.0.0",
+    "@xen-orchestra/backups": "^0.29.5",
+    "@xen-orchestra/fs": "^3.3.1",
     "filenamify": "^4.1.0",
     "getopts": "^2.2.5",
     "lodash": "^4.17.15",
@@ -27,7 +27,7 @@
   "scripts": {
     "postversion": "npm publish --access public"
   },
-  "version": "1.0.7",
+  "version": "1.0.0",
   "license": "AGPL-3.0-or-later",
   "author": {
     "name": "Vates SAS",

@xen-orchestra/backups/Backup.js

@@ -1,16 +1,292 @@
 'use strict'
 
-const { Metadata } = require('./_runners/Metadata.js')
-const { VmsXapi } = require('./_runners/VmsXapi.js')
+const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
+const Disposable = require('promise-toolbox/Disposable')
+const ignoreErrors = require('promise-toolbox/ignoreErrors')
+const { compileTemplate } = require('@xen-orchestra/template')
+const { limitConcurrency } = require('limit-concurrency-decorator')
 
-exports.createRunner = function createRunner(opts) {
-  const { type } = opts.job
-  switch (type) {
-    case 'backup':
-      return new VmsXapi(opts)
-    case 'metadataBackup':
-      return new Metadata(opts)
-    default:
+const { extractIdsFromSimplePattern } = require('./extractIdsFromSimplePattern.js')
+const { PoolMetadataBackup } = require('./_PoolMetadataBackup.js')
+const { Task } = require('./Task.js')
+const { VmBackup } = require('./_VmBackup.js')
+const { XoMetadataBackup } = require('./_XoMetadataBackup.js')
+
+const noop = Function.prototype
+
+const getAdaptersByRemote = adapters => {
+  const adaptersByRemote = {}
+  adapters.forEach(({ adapter, remoteId }) => {
+    adaptersByRemote[remoteId] = adapter
+  })
+  return adaptersByRemote
+}
+
+const runTask = (...args) => Task.run(...args).catch(noop) // errors are handled by logs
+
+const DEFAULT_SETTINGS = {
+  reportWhen: 'failure',
+}
+
+const DEFAULT_VM_SETTINGS = {
+  bypassVdiChainsCheck: false,
+  checkpointSnapshot: false,
+  concurrency: 2,
+  copyRetention: 0,
+  deleteFirst: false,
+  exportRetention: 0,
+  fullInterval: 0,
+  healthCheckSr: undefined,
+  healthCheckVmsWithTags: [],
+  maxMergedDeltasPerRun: Infinity,
+  offlineBackup: false,
+  offlineSnapshot: false,
+  snapshotRetention: 0,
+  timeout: 0,
+  useNbd: false,
+  unconditionalSnapshot: false,
+  vmTimeout: 0,
+}
+
+const DEFAULT_METADATA_SETTINGS = {
+  retentionPoolMetadata: 0,
+  retentionXoMetadata: 0,
+}
+
+exports.Backup = class Backup {
+  constructor({ config, getAdapter, getConnectedRecord, job, schedule }) {
+    this._config = config
+    this._getRecord = getConnectedRecord
+    this._job = job
+    this._schedule = schedule
+
+    this._getAdapter = Disposable.factory(function* (remoteId) {
+      return {
+        adapter: yield getAdapter(remoteId),
+        remoteId,
+      }
+    })
+
+    this._getSnapshotNameLabel = compileTemplate(config.snapshotNameLabelTpl, {
+      '{job.name}': job.name,
+      '{vm.name_label}': vm => vm.name_label,
+    })
+
+    const { type } = job
+    const baseSettings = { ...DEFAULT_SETTINGS }
+    if (type === 'backup') {
+      Object.assign(baseSettings, DEFAULT_VM_SETTINGS, config.defaultSettings, config.vm?.defaultSettings)
+      this.run = this._runVmBackup
+    } else if (type === 'metadataBackup') {
+      Object.assign(baseSettings, DEFAULT_METADATA_SETTINGS, config.defaultSettings, config.metadata?.defaultSettings)
+      this.run = this._runMetadataBackup
+    } else {
       throw new Error(`No runner for the backup type ${type}`)
+    }
+    Object.assign(baseSettings, job.settings[''])
+
+    this._baseSettings = baseSettings
+    this._settings = { ...baseSettings, ...job.settings[schedule.id] }
+  }
+
+  async _runMetadataBackup() {
+    const schedule = this._schedule
+    const job = this._job
+    const remoteIds = extractIdsFromSimplePattern(job.remotes)
+    if (remoteIds.length === 0) {
+      throw new Error('metadata backup job cannot run without remotes')
+    }
+
+    const config = this._config
+    const poolIds = extractIdsFromSimplePattern(job.pools)
+    const isEmptyPools = poolIds.length === 0
+    const isXoMetadata = job.xoMetadata !== undefined
+    if (!isXoMetadata && isEmptyPools) {
+      throw new Error('no metadata mode found')
+    }
+
+    const settings = this._settings
+
+    const { retentionPoolMetadata, retentionXoMetadata } = settings
+
+    if (
+      (retentionPoolMetadata === 0 && retentionXoMetadata === 0) ||
+      (!isXoMetadata && retentionPoolMetadata === 0) ||
+      (isEmptyPools && retentionXoMetadata === 0)
+    ) {
+      throw new Error('no retentions corresponding to the metadata modes found')
+    }
+
+    await Disposable.use(
+      Disposable.all(
+        poolIds.map(id =>
+          this._getRecord('pool', id).catch(error => {
+            // See https://github.com/vatesfr/xen-orchestra/commit/6aa6cfba8ec939c0288f0fa740f6dfad98c43cbb
+            runTask(
+              {
+                name: 'get pool record',
+                data: { type: 'pool', id },
+              },
+              () => Promise.reject(error)
+            )
+          })
+        )
+      ),
+      Disposable.all(
+        remoteIds.map(id =>
+          this._getAdapter(id).catch(error => {
+            // See https://github.com/vatesfr/xen-orchestra/commit/6aa6cfba8ec939c0288f0fa740f6dfad98c43cbb
+            runTask(
+              {
+                name: 'get remote adapter',
+                data: { type: 'remote', id },
+              },
+              () => Promise.reject(error)
+            )
+          })
+        )
+      ),
+      async (pools, remoteAdapters) => {
+        // remove adapters that failed (already handled)
+        remoteAdapters = remoteAdapters.filter(_ => _ !== undefined)
+        if (remoteAdapters.length === 0) {
+          return
+        }
+        remoteAdapters = getAdaptersByRemote(remoteAdapters)
+
+        // remove pools that failed (already handled)
+        pools = pools.filter(_ => _ !== undefined)
+
+        const promises = []
+        if (pools.length !== 0 && settings.retentionPoolMetadata !== 0) {
+          promises.push(
+            asyncMap(pools, async pool =>
+              runTask(
+                {
+                  name: `Starting metadata backup for the pool (${pool.$id}). (${job.id})`,
+                  data: {
+                    id: pool.$id,
+                    pool,
+                    poolMaster: await ignoreErrors.call(pool.$xapi.getRecord('host', pool.master)),
+                    type: 'pool',
+                  },
+                },
+                () =>
+                  new PoolMetadataBackup({
+                    config,
+                    job,
+                    pool,
+                    remoteAdapters,
+                    schedule,
+                    settings,
+                  }).run()
+              )
+            )
+          )
+        }
+
+        if (job.xoMetadata !== undefined && settings.retentionXoMetadata !== 0) {
+          promises.push(
+            runTask(
+              {
+                name: `Starting XO metadata backup. (${job.id})`,
+                data: {
+                  type: 'xo',
+                },
+              },
+              () =>
+                new XoMetadataBackup({
+                  config,
+                  job,
+                  remoteAdapters,
+                  schedule,
+                  settings,
+                }).run()
+            )
+          )
+        }
+        await Promise.all(promises)
+      }
+    )
+  }
+
+  async _runVmBackup() {
+    const job = this._job
+
+    // FIXME: proper SimpleIdPattern handling
+    const getSnapshotNameLabel = this._getSnapshotNameLabel
+    const schedule = this._schedule
+
+    const config = this._config
+    const settings = this._settings
+    await Disposable.use(
+      Disposable.all(
+        extractIdsFromSimplePattern(job.srs).map(id =>
+          this._getRecord('SR', id).catch(error => {
+            runTask(
+              {
+                name: 'get SR record',
+                data: { type: 'SR', id },
+              },
+              () => Promise.reject(error)
+            )
+          })
+        )
+      ),
+      Disposable.all(
+        extractIdsFromSimplePattern(job.remotes).map(id =>
+          this._getAdapter(id).catch(error => {
+            runTask(
+              {
+                name: 'get remote adapter',
+                data: { type: 'remote', id },
+              },
+              () => Promise.reject(error)
+            )
+          })
+        )
+      ),
+      () => (settings.healthCheckSr !== undefined ? this._getRecord('SR', settings.healthCheckSr) : undefined),
+      async (srs, remoteAdapters, healthCheckSr) => {
+        // remove adapters that failed (already handled)
+        remoteAdapters = remoteAdapters.filter(_ => _ !== undefined)
+
+        // remove srs that failed (already handled)
+        srs = srs.filter(_ => _ !== undefined)
+
+        if (remoteAdapters.length === 0 && srs.length === 0 && settings.snapshotRetention === 0) {
+          return
+        }
+
+        const vmIds = extractIdsFromSimplePattern(job.vms)
+
+        Task.info('vms', { vms: vmIds })
+
+        remoteAdapters = getAdaptersByRemote(remoteAdapters)
+
+        const allSettings = this._job.settings
+        const baseSettings = this._baseSettings
+
+        const handleVm = vmUuid =>
+          runTask({ name: 'backup VM', data: { type: 'VM', id: vmUuid } }, () =>
+            Disposable.use(this._getRecord('VM', vmUuid), vm =>
+              new VmBackup({
+                baseSettings,
+                config,
+                getSnapshotNameLabel,
+                healthCheckSr,
+                job,
+                remoteAdapters,
+                schedule,
+                settings: { ...settings, ...allSettings[vm.uuid] },
+                srs,
+                vm,
+              }).run()
+            )
+          )
+        const { concurrency } = settings
+        await asyncMapSettled(vmIds, concurrency === 0 ? handleVm : limitConcurrency(concurrency)(handleVm))
+      }
+    )
   }
 }

@xen-orchestra/backups/HealthCheckVmBackup.js

@@ -3,14 +3,12 @@
 const { Task } = require('./Task')
 
 exports.HealthCheckVmBackup = class HealthCheckVmBackup {
-  #restoredVm
-  #timeout
   #xapi
+  #restoredVm
 
-  constructor({ restoredVm, timeout = 10 * 60 * 1000, xapi }) {
+  constructor({ restoredVm, xapi }) {
     this.#restoredVm = restoredVm
     this.#xapi = xapi
-    this.#timeout = timeout
   }
 
   async run() {
@@ -25,12 +23,7 @@ exports.HealthCheckVmBackup = class HealthCheckVmBackup {
 
         // remove vifs
         await Promise.all(restoredVm.$VIFs.map(vif => xapi.callAsync('VIF.destroy', vif.$ref)))
-        const waitForScript = restoredVm.tags.includes('xo-backup-health-check-xenstore')
-        if (waitForScript) {
-          await restoredVm.set_xenstore_data({
-            'vm-data/xo-backup-health-check': 'planned',
-          })
-        }
+
         const start = new Date()
         // start Vm
 
@@ -41,7 +34,7 @@ exports.HealthCheckVmBackup = class HealthCheckVmBackup {
           false // Skip pre-boot checks?
         )
         const started = new Date()
-        const timeout = this.#timeout
+        const timeout = 10 * 60 * 1000
         const startDuration = started - start
 
         let remainingTimeout = timeout - startDuration
@@ -59,52 +52,12 @@ exports.HealthCheckVmBackup = class HealthCheckVmBackup {
         remainingTimeout -= running - started
 
         if (remainingTimeout < 0) {
-          throw new Error(`local xapi  did not get Running state for VM ${restoredId} after ${timeout / 1000} second`)
+          throw new Error(`local xapi  did not get Runnig state for VM ${restoredId} after ${timeout / 1000} second`)
         }
         // wait for the guest tool version to be defined
         await xapi.waitObjectState(restoredVm.guest_metrics, gm => gm?.PV_drivers_version?.major !== undefined, {
           timeout: remainingTimeout,
         })
-
-        const guestToolsReady = new Date()
-        remainingTimeout -= guestToolsReady - running
-        if (remainingTimeout < 0) {
-          throw new Error(`local xapi  did not get he guest tools check ${restoredId} after ${timeout / 1000} second`)
-        }
-
-        if (waitForScript) {
-          const startedRestoredVm = await xapi.waitObjectState(
-            restoredVm.$ref,
-            vm =>
-              vm?.xenstore_data !== undefined &&
-              (vm.xenstore_data['vm-data/xo-backup-health-check'] === 'success' ||
-                vm.xenstore_data['vm-data/xo-backup-health-check'] === 'failure'),
-            {
-              timeout: remainingTimeout,
-            }
-          )
-          const scriptOk = new Date()
-          remainingTimeout -= scriptOk - guestToolsReady
-          if (remainingTimeout < 0) {
-            throw new Error(
-              `Backup health check script did not update vm-data/xo-backup-health-check of ${restoredId} after ${
-                timeout / 1000
-              } second, got ${
-                startedRestoredVm.xenstore_data['vm-data/xo-backup-health-check']
-              } instead of 'success' or 'failure'`
-            )
-          }
-
-          if (startedRestoredVm.xenstore_data['vm-data/xo-backup-health-check'] !== 'success') {
-            const message = startedRestoredVm.xenstore_data['vm-data/xo-backup-health-check-error']
-            if (message) {
-              throw new Error(`Backup health check script failed with message ${message} for VM ${restoredId} `)
-            } else {
-              throw new Error(`Backup health check script failed for VM ${restoredId} `)
-            }
-          }
-          Task.info('Backup health check script successfully executed')
-        }
       }
     )
   }

@xen-orchestra/backups/ImportVmBackup.js

@@ -3,14 +3,14 @@
 const assert = require('assert')
 
 const { formatFilenameDate } = require('./_filenameDate.js')
-const { importIncrementalVm } = require('./_incrementalVm.js')
+const { importDeltaVm } = require('./_deltaVm.js')
 const { Task } = require('./Task.js')
 const { watchStreamSize } = require('./_watchStreamSize.js')
 
 exports.ImportVmBackup = class ImportVmBackup {
   constructor({ adapter, metadata, srUuid, xapi, settings: { newMacAddresses, mapVdisSrs = {} } = {} }) {
     this._adapter = adapter
-    this._importIncrementalVmSettings = { newMacAddresses, mapVdisSrs }
+    this._importDeltaVmSettings = { newMacAddresses, mapVdisSrs }
     this._metadata = metadata
     this._srUuid = srUuid
     this._xapi = xapi
@@ -31,11 +31,11 @@ exports.ImportVmBackup = class ImportVmBackup {
       assert.strictEqual(metadata.mode, 'delta')
 
       const ignoredVdis = new Set(
-        Object.entries(this._importIncrementalVmSettings.mapVdisSrs)
+        Object.entries(this._importDeltaVmSettings.mapVdisSrs)
           .filter(([_, srUuid]) => srUuid === null)
           .map(([vdiUuid]) => vdiUuid)
       )
-      backup = await adapter.readIncrementalVmBackup(metadata, ignoredVdis)
+      backup = await adapter.readDeltaVmBackup(metadata, ignoredVdis)
       Object.values(backup.streams).forEach(stream => watchStreamSize(stream, sizeContainer))
     }
 
@@ -49,8 +49,8 @@ exports.ImportVmBackup = class ImportVmBackup {
 
         const vmRef = isFull
           ? await xapi.VM_import(backup, srRef)
-          : await importIncrementalVm(backup, await xapi.getRecord('SR', srRef), {
-              ...this._importIncrementalVmSettings,
+          : await importDeltaVm(backup, await xapi.getRecord('SR', srRef), {
+              ...this._importDeltaVmSettings,
               detectBase: false,
             })
 

@xen-orchestra/backups/RemoteAdapter.js

@@ -209,8 +209,8 @@ class RemoteAdapter {
 
       const isVhdDirectory = vhd instanceof VhdDirectory
       return isVhdDirectory
-        ? this.useVhdDirectory() && this.#getCompressionType() === vhd.compressionType
-        : !this.useVhdDirectory()
+        ? this.#useVhdDirectory() && this.#getCompressionType() === vhd.compressionType
+        : !this.#useVhdDirectory()
     })
   }
 
@@ -321,19 +321,19 @@ class RemoteAdapter {
     return this._vhdDirectoryCompression
   }
 
-  useVhdDirectory() {
+  #useVhdDirectory() {
     return this.handler.useVhdDirectory()
   }
 
   #useAlias() {
-    return this.useVhdDirectory()
+    return this.#useVhdDirectory()
   }
 
   async *#getDiskLegacy(diskId) {
     const RE_VHDI = /^vhdi(\d+)$/
     const handler = this._handler
 
-    const diskPath = handler.getFilePath('/' + diskId)
+    const diskPath = handler._getFilePath('/' + diskId)
     const mountDir = yield getTmpDir()
     await fromCallback(execFile, 'vhdimount', [diskPath, mountDir])
     try {
@@ -404,27 +404,20 @@ class RemoteAdapter {
     return `${baseName}.vhd`
   }
 
-  async listAllVms() {
+  async listAllVmBackups() {
     const handler = this._handler
-    const vmsUuids = []
-    await asyncEach(await handler.list(BACKUP_DIR), async entry => {
+
+    const backups = { __proto__: null }
+    await asyncMap(await handler.list(BACKUP_DIR), async entry => {
       // ignore hidden and lock files
       if (entry[0] !== '.' && !entry.endsWith('.lock')) {
-        vmsUuids.push(entry)
+        const vmBackups = await this.listVmBackups(entry)
+        if (vmBackups.length !== 0) {
+          backups[entry] = vmBackups
+        }
       }
     })
-    return vmsUuids
-  }
 
-  async listAllVmBackups() {
-    const vmsUuids = await this.listAllVms()
-    const backups = { __proto__: null }
-    await asyncEach(vmsUuids, async vmUuid => {
-      const vmBackups = await this.listVmBackups(vmUuid)
-      if (vmBackups.length !== 0) {
-        backups[vmUuid] = vmBackups
-      }
-    })
     return backups
   }
 
@@ -665,9 +658,9 @@ class RemoteAdapter {
     return path
   }
 
-  async writeVhd(path, input, { checksum = true, validator = noop, writeBlockConcurrency } = {}) {
+  async writeVhd(path, input, { checksum = true, validator = noop, writeBlockConcurrency, nbdClient } = {}) {
     const handler = this._handler
-    if (this.useVhdDirectory()) {
+    if (this.#useVhdDirectory()) {
       const dataPath = `${dirname(path)}/data/${uuidv4()}.vhd`
       const size = await createVhdDirectoryFromStream(handler, dataPath, input, {
         concurrency: writeBlockConcurrency,
@@ -676,6 +669,7 @@ class RemoteAdapter {
           await input.task
           return validator.apply(this, arguments)
         },
+        nbdClient,
       })
       await VhdAbstract.createAlias(handler, path, dataPath)
       return size
@@ -698,8 +692,8 @@ class RemoteAdapter {
   }
 
   // open the  hierarchy of ancestors until we find a full one
-  async _createVhdStream(handler, path, { useChain }) {
-    const disposableSynthetic = useChain ? await VhdSynthetic.fromVhdChain(handler, path) : await openVhd(handler, path)
+  async _createSyntheticStream(handler, path) {
+    const disposableSynthetic = await VhdSynthetic.fromVhdChain(handler, path)
     // I don't want the vhds to be disposed on return
     // but only when the stream is done ( or failed )
 
@@ -724,15 +718,15 @@ class RemoteAdapter {
     return stream
   }
 
-  async readIncrementalVmBackup(metadata, ignoredVdis, { useChain = true } = {}) {
+  async readDeltaVmBackup(metadata, ignoredVdis) {
     const handler = this._handler
-    const { vbds, vhds, vifs, vm, vmSnapshot } = metadata
+    const { vbds, vhds, vifs, vm } = metadata
     const dir = dirname(metadata._filename)
     const vdis = ignoredVdis === undefined ? metadata.vdis : pickBy(metadata.vdis, vdi => !ignoredVdis.has(vdi.uuid))
 
     const streams = {}
     await asyncMapSettled(Object.keys(vdis), async ref => {
-      streams[`${ref}.vhd`] = await this._createVhdStream(handler, join(dir, vhds[ref]), { useChain })
+      streams[`${ref}.vhd`] = await this._createSyntheticStream(handler, join(dir, vhds[ref]))
     })
 
     return {
@@ -741,7 +735,7 @@ class RemoteAdapter {
       vdis,
       version: '1.0.0',
       vifs,
-      vm: { ...vm, suspend_VDI: vmSnapshot.suspend_VDI },
+      vm,
     }
   }
 
@@ -753,49 +747,7 @@ class RemoteAdapter {
     // _filename is a private field used to compute the backup id
     //
     // it's enumerable to make it cacheable
-    const metadata = { ...JSON.parse(await this._handler.readFile(path)), _filename: path }
-
-    // backups created on XenServer < 7.1 via JSON in XML-RPC transports have boolean values encoded as integers, which make them unusable with more recent XAPIs
-    if (typeof metadata.vm.is_a_template === 'number') {
-      const properties = {
-        vbds: ['bootable', 'unpluggable', 'storage_lock', 'empty', 'currently_attached'],
-        vdis: [
-          'sharable',
-          'read_only',
-          'storage_lock',
-          'managed',
-          'missing',
-          'is_a_snapshot',
-          'allow_caching',
-          'metadata_latest',
-        ],
-        vifs: ['currently_attached', 'MAC_autogenerated'],
-        vm: ['is_a_template', 'is_control_domain', 'ha_always_run', 'is_a_snapshot', 'is_snapshot_from_vmpp'],
-        vmSnapshot: ['is_a_template', 'is_control_domain', 'ha_always_run', 'is_snapshot_from_vmpp'],
-      }
-
-      function fixBooleans(obj, properties) {
-        properties.forEach(property => {
-          if (typeof obj[property] === 'number') {
-            obj[property] = obj[property] === 1
-          }
-        })
-      }
-
-      for (const [key, propertiesInKey] of Object.entries(properties)) {
-        const value = metadata[key]
-        if (value !== undefined) {
-          // some properties of the metadata are collections indexed by the opaqueRef
-          const isCollection = Object.keys(value).some(subKey => subKey.startsWith('OpaqueRef:'))
-          if (isCollection) {
-            Object.values(value).forEach(subValue => fixBooleans(subValue, propertiesInKey))
-          } else {
-            fixBooleans(value, propertiesInKey)
-          }
-        }
-      }
-    }
-    return metadata
+    return { ...JSON.parse(await this._handler.readFile(path)), _filename: path }
   }
 }
 

@xen-orchestra/backups/RestoreMetadataBackup.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { DIR_XO_POOL_METADATA_BACKUPS } = require('./RemoteAdapter.js')
-const { PATH_DB_DUMP } = require('./_runners/_PoolMetadataBackup.js')
+const { PATH_DB_DUMP } = require('./_PoolMetadataBackup.js')
 
 exports.RestoreMetadataBackup = class RestoreMetadataBackup {
   constructor({ backupId, handler, xapi }) {

@xen-orchestra/backups/_PoolMetadataBackup.js

@@ -2,10 +2,10 @@
 
 const { asyncMap } = require('@xen-orchestra/async-map')
 
-const { DIR_XO_POOL_METADATA_BACKUPS } = require('../RemoteAdapter.js')
+const { DIR_XO_POOL_METADATA_BACKUPS } = require('./RemoteAdapter.js')
 const { forkStreamUnpipe } = require('./_forkStreamUnpipe.js')
-const { formatFilenameDate } = require('../_filenameDate.js')
-const { Task } = require('../Task.js')
+const { formatFilenameDate } = require('./_filenameDate.js')
+const { Task } = require('./Task.js')
 
 const PATH_DB_DUMP = '/pool/xmldbdump'
 exports.PATH_DB_DUMP = PATH_DB_DUMP

@xen-orchestra/backups/_VmBackup.js

@@ -0,0 +1,496 @@
+'use strict'
+
+const assert = require('assert')
+const findLast = require('lodash/findLast.js')
+const groupBy = require('lodash/groupBy.js')
+const ignoreErrors = require('promise-toolbox/ignoreErrors')
+const keyBy = require('lodash/keyBy.js')
+const mapValues = require('lodash/mapValues.js')
+const { asyncMap } = require('@xen-orchestra/async-map')
+const { createLogger } = require('@xen-orchestra/log')
+const { decorateMethodsWith } = require('@vates/decorate-with')
+const { defer } = require('golike-defer')
+const { formatDateTime } = require('@xen-orchestra/xapi')
+
+const { DeltaBackupWriter } = require('./writers/DeltaBackupWriter.js')
+const { DeltaReplicationWriter } = require('./writers/DeltaReplicationWriter.js')
+const { exportDeltaVm } = require('./_deltaVm.js')
+const { forkStreamUnpipe } = require('./_forkStreamUnpipe.js')
+const { FullBackupWriter } = require('./writers/FullBackupWriter.js')
+const { FullReplicationWriter } = require('./writers/FullReplicationWriter.js')
+const { getOldEntries } = require('./_getOldEntries.js')
+const { Task } = require('./Task.js')
+const { watchStreamSize } = require('./_watchStreamSize.js')
+
+const { debug, warn } = createLogger('xo:backups:VmBackup')
+
+class AggregateError extends Error {
+  constructor(errors, message) {
+    super(message)
+    this.errors = errors
+  }
+}
+
+const asyncEach = async (iterable, fn, thisArg = iterable) => {
+  for (const item of iterable) {
+    await fn.call(thisArg, item)
+  }
+}
+
+const forkDeltaExport = deltaExport =>
+  Object.create(deltaExport, {
+    streams: {
+      value: mapValues(deltaExport.streams, forkStreamUnpipe),
+    },
+  })
+
+class VmBackup {
+  constructor({
+    config,
+    getSnapshotNameLabel,
+    healthCheckSr,
+    job,
+    remoteAdapters,
+    remotes,
+    schedule,
+    settings,
+    srs,
+    vm,
+  }) {
+    if (vm.other_config['xo:backup:job'] === job.id && 'start' in vm.blocked_operations) {
+      // don't match replicated VMs created by this very job otherwise they
+      // will be replicated again and again
+      throw new Error('cannot backup a VM created by this very job')
+    }
+
+    this.config = config
+    this.job = job
+    this.remoteAdapters = remoteAdapters
+    this.scheduleId = schedule.id
+    this.timestamp = undefined
+
+    // VM currently backed up
+    this.vm = vm
+    const { tags } = this.vm
+
+    // VM (snapshot) that is really exported
+    this.exportedVm = undefined
+
+    this._fullVdisRequired = undefined
+    this._getSnapshotNameLabel = getSnapshotNameLabel
+    this._isDelta = job.mode === 'delta'
+    this._healthCheckSr = healthCheckSr
+    this._jobId = job.id
+    this._jobSnapshots = undefined
+    this._xapi = vm.$xapi
+
+    // Base VM for the export
+    this._baseVm = undefined
+
+    // Settings for this specific run (job, schedule, VM)
+    if (tags.includes('xo-memory-backup')) {
+      settings.checkpointSnapshot = true
+    }
+    if (tags.includes('xo-offline-backup')) {
+      settings.offlineSnapshot = true
+    }
+    this._settings = settings
+
+    // Create writers
+    {
+      const writers = new Set()
+      this._writers = writers
+
+      const [BackupWriter, ReplicationWriter] = this._isDelta
+        ? [DeltaBackupWriter, DeltaReplicationWriter]
+        : [FullBackupWriter, FullReplicationWriter]
+
+      const allSettings = job.settings
+      Object.keys(remoteAdapters).forEach(remoteId => {
+        const targetSettings = {
+          ...settings,
+          ...allSettings[remoteId],
+        }
+        if (targetSettings.exportRetention !== 0) {
+          writers.add(new BackupWriter({ backup: this, remoteId, settings: targetSettings }))
+        }
+      })
+      srs.forEach(sr => {
+        const targetSettings = {
+          ...settings,
+          ...allSettings[sr.uuid],
+        }
+        if (targetSettings.copyRetention !== 0) {
+          writers.add(new ReplicationWriter({ backup: this, sr, settings: targetSettings }))
+        }
+      })
+    }
+  }
+
+  // calls fn for each function, warns of any errors, and throws only if there are no writers left
+  async _callWriters(fn, step, parallel = true) {
+    const writers = this._writers
+    const n = writers.size
+    if (n === 0) {
+      return
+    }
+
+    async function callWriter(writer) {
+      const { name } = writer.constructor
+      try {
+        debug('writer step starting', { step, writer: name })
+        await fn(writer)
+        debug('writer step succeeded', { duration: step, writer: name })
+      } catch (error) {
+        writers.delete(writer)
+
+        warn('writer step failed', { error, step, writer: name })
+
+        // these two steps are the only one that are not already in their own sub tasks
+        if (step === 'writer.checkBaseVdis()' || step === 'writer.beforeBackup()') {
+          Task.warning(
+            `the writer ${name} has failed the step ${step} with error ${error.message}. It won't be used anymore in this job execution.`
+          )
+        }
+
+        throw error
+      }
+    }
+    if (n === 1) {
+      const [writer] = writers
+      return callWriter(writer)
+    }
+
+    const errors = []
+    await (parallel ? asyncMap : asyncEach)(writers, async function (writer) {
+      try {
+        await callWriter(writer)
+      } catch (error) {
+        errors.push(error)
+      }
+    })
+    if (writers.size === 0) {
+      throw new AggregateError(errors, 'all targets have failed, step: ' + step)
+    }
+  }
+
+  // ensure the VM itself does not have any backup metadata which would be
+  // copied on manual snapshots and interfere with the backup jobs
+  async _cleanMetadata() {
+    const { vm } = this
+    if ('xo:backup:job' in vm.other_config) {
+      await vm.update_other_config({
+        'xo:backup:datetime': null,
+        'xo:backup:deltaChainLength': null,
+        'xo:backup:exported': null,
+        'xo:backup:job': null,
+        'xo:backup:schedule': null,
+        'xo:backup:vm': null,
+      })
+    }
+  }
+
+  async _snapshot() {
+    const { vm } = this
+    const xapi = this._xapi
+
+    const settings = this._settings
+
+    const doSnapshot =
+      settings.unconditionalSnapshot ||
+      this._isDelta ||
+      (!settings.offlineBackup && vm.power_state === 'Running') ||
+      settings.snapshotRetention !== 0
+    if (doSnapshot) {
+      await Task.run({ name: 'snapshot' }, async () => {
+        if (!settings.bypassVdiChainsCheck) {
+          await vm.$assertHealthyVdiChains()
+        }
+
+        const snapshotRef = await vm[settings.checkpointSnapshot ? '$checkpoint' : '$snapshot']({
+          ignoreNobakVdis: true,
+          name_label: this._getSnapshotNameLabel(vm),
+          unplugVusbs: true,
+        })
+        this.timestamp = Date.now()
+
+        await xapi.setFieldEntries('VM', snapshotRef, 'other_config', {
+          'xo:backup:datetime': formatDateTime(this.timestamp),
+          'xo:backup:job': this._jobId,
+          'xo:backup:schedule': this.scheduleId,
+          'xo:backup:vm': vm.uuid,
+        })
+
+        this.exportedVm = await xapi.getRecord('VM', snapshotRef)
+
+        return this.exportedVm.uuid
+      })
+    } else {
+      this.exportedVm = vm
+      this.timestamp = Date.now()
+    }
+  }
+
+  async _copyDelta() {
+    const { exportedVm } = this
+    const baseVm = this._baseVm
+    const fullVdisRequired = this._fullVdisRequired
+
+    const isFull = fullVdisRequired === undefined || fullVdisRequired.size !== 0
+
+    await this._callWriters(writer => writer.prepare({ isFull }), 'writer.prepare()')
+
+    const deltaExport = await exportDeltaVm(exportedVm, baseVm, {
+      fullVdisRequired,
+    })
+    const sizeContainers = mapValues(deltaExport.streams, stream => watchStreamSize(stream))
+
+    const timestamp = Date.now()
+
+    await this._callWriters(
+      writer =>
+        writer.transfer({
+          deltaExport: forkDeltaExport(deltaExport),
+          sizeContainers,
+          timestamp,
+        }),
+      'writer.transfer()'
+    )
+
+    this._baseVm = exportedVm
+
+    if (baseVm !== undefined) {
+      await exportedVm.update_other_config(
+        'xo:backup:deltaChainLength',
+        String(+(baseVm.other_config['xo:backup:deltaChainLength'] ?? 0) + 1)
+      )
+    }
+
+    // not the case if offlineBackup
+    if (exportedVm.is_a_snapshot) {
+      await exportedVm.update_other_config('xo:backup:exported', 'true')
+    }
+
+    const size = Object.values(sizeContainers).reduce((sum, { size }) => sum + size, 0)
+    const end = Date.now()
+    const duration = end - timestamp
+    debug('transfer complete', {
+      duration,
+      speed: duration !== 0 ? (size * 1e3) / 1024 / 1024 / duration : 0,
+      size,
+    })
+
+    await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
+  }
+
+  async _copyFull() {
+    const { compression } = this.job
+    const stream = await this._xapi.VM_export(this.exportedVm.$ref, {
+      compress: Boolean(compression) && (compression === 'native' ? 'gzip' : 'zstd'),
+      useSnapshot: false,
+    })
+    const sizeContainer = watchStreamSize(stream)
+
+    const timestamp = Date.now()
+
+    await this._callWriters(
+      writer =>
+        writer.run({
+          sizeContainer,
+          stream: forkStreamUnpipe(stream),
+          timestamp,
+        }),
+      'writer.run()'
+    )
+
+    const { size } = sizeContainer
+    const end = Date.now()
+    const duration = end - timestamp
+    debug('transfer complete', {
+      duration,
+      speed: duration !== 0 ? (size * 1e3) / 1024 / 1024 / duration : 0,
+      size,
+    })
+  }
+
+  async _fetchJobSnapshots() {
+    const jobId = this._jobId
+    const vmRef = this.vm.$ref
+    const xapi = this._xapi
+
+    const snapshotsRef = await xapi.getField('VM', vmRef, 'snapshots')
+    const snapshotsOtherConfig = await asyncMap(snapshotsRef, ref => xapi.getField('VM', ref, 'other_config'))
+
+    const snapshots = []
+    snapshotsOtherConfig.forEach((other_config, i) => {
+      if (other_config['xo:backup:job'] === jobId) {
+        snapshots.push({ other_config, $ref: snapshotsRef[i] })
+      }
+    })
+    snapshots.sort((a, b) => (a.other_config['xo:backup:datetime'] < b.other_config['xo:backup:datetime'] ? -1 : 1))
+    this._jobSnapshots = snapshots
+  }
+
+  async _removeUnusedSnapshots() {
+    const allSettings = this.job.settings
+    const baseSettings = this._baseSettings
+    const baseVmRef = this._baseVm?.$ref
+
+    const snapshotsPerSchedule = groupBy(this._jobSnapshots, _ => _.other_config['xo:backup:schedule'])
+    const xapi = this._xapi
+    await asyncMap(Object.entries(snapshotsPerSchedule), ([scheduleId, snapshots]) => {
+      const settings = {
+        ...baseSettings,
+        ...allSettings[scheduleId],
+        ...allSettings[this.vm.uuid],
+      }
+      return asyncMap(getOldEntries(settings.snapshotRetention, snapshots), ({ $ref }) => {
+        if ($ref !== baseVmRef) {
+          return xapi.VM_destroy($ref)
+        }
+      })
+    })
+  }
+
+  async _selectBaseVm() {
+    const xapi = this._xapi
+
+    let baseVm = findLast(this._jobSnapshots, _ => 'xo:backup:exported' in _.other_config)
+    if (baseVm === undefined) {
+      debug('no base VM found')
+      return
+    }
+
+    const fullInterval = this._settings.fullInterval
+    const deltaChainLength = +(baseVm.other_config['xo:backup:deltaChainLength'] ?? 0) + 1
+    if (!(fullInterval === 0 || fullInterval > deltaChainLength)) {
+      debug('not using base VM becaust fullInterval reached')
+      return
+    }
+
+    const srcVdis = keyBy(await xapi.getRecords('VDI', await this.vm.$getDisks()), '$ref')
+
+    // resolve full record
+    baseVm = await xapi.getRecord('VM', baseVm.$ref)
+
+    const baseUuidToSrcVdi = new Map()
+    await asyncMap(await baseVm.$getDisks(), async baseRef => {
+      const [baseUuid, snapshotOf] = await Promise.all([
+        xapi.getField('VDI', baseRef, 'uuid'),
+        xapi.getField('VDI', baseRef, 'snapshot_of'),
+      ])
+      const srcVdi = srcVdis[snapshotOf]
+      if (srcVdi !== undefined) {
+        baseUuidToSrcVdi.set(baseUuid, srcVdi)
+      } else {
+        debug('ignore snapshot VDI because no longer present on VM', {
+          vdi: baseUuid,
+        })
+      }
+    })
+
+    const presentBaseVdis = new Map(baseUuidToSrcVdi)
+    await this._callWriters(
+      writer => presentBaseVdis.size !== 0 && writer.checkBaseVdis(presentBaseVdis, baseVm),
+      'writer.checkBaseVdis()',
+      false
+    )
+
+    if (presentBaseVdis.size === 0) {
+      debug('no base VM found')
+      return
+    }
+
+    const fullVdisRequired = new Set()
+    baseUuidToSrcVdi.forEach((srcVdi, baseUuid) => {
+      if (presentBaseVdis.has(baseUuid)) {
+        debug('found base VDI', {
+          base: baseUuid,
+          vdi: srcVdi.uuid,
+        })
+      } else {
+        debug('missing base VDI', {
+          base: baseUuid,
+          vdi: srcVdi.uuid,
+        })
+        fullVdisRequired.add(srcVdi.uuid)
+      }
+    })
+
+    this._baseVm = baseVm
+    this._fullVdisRequired = fullVdisRequired
+  }
+
+  async _healthCheck() {
+    const settings = this._settings
+
+    if (this._healthCheckSr === undefined) {
+      return
+    }
+
+    // check if current VM has tags
+    const { tags } = this.vm
+    const intersect = settings.healthCheckVmsWithTags.some(t => tags.includes(t))
+
+    if (settings.healthCheckVmsWithTags.length !== 0 && !intersect) {
+      return
+    }
+
+    await this._callWriters(writer => writer.healthCheck(this._healthCheckSr), 'writer.healthCheck()')
+  }
+
+  async run($defer) {
+    const settings = this._settings
+    assert(
+      !settings.offlineBackup || settings.snapshotRetention === 0,
+      'offlineBackup is not compatible with snapshotRetention'
+    )
+
+    await this._callWriters(async writer => {
+      await writer.beforeBackup()
+      $defer(async () => {
+        await writer.afterBackup()
+      })
+    }, 'writer.beforeBackup()')
+
+    await this._fetchJobSnapshots()
+
+    if (this._isDelta) {
+      await this._selectBaseVm()
+    }
+
+    await this._cleanMetadata()
+    await this._removeUnusedSnapshots()
+
+    const { vm } = this
+    const isRunning = vm.power_state === 'Running'
+    const startAfter = isRunning && (settings.offlineBackup ? 'backup' : settings.offlineSnapshot && 'snapshot')
+    if (startAfter) {
+      await vm.$callAsync('clean_shutdown')
+    }
+
+    try {
+      await this._snapshot()
+      if (startAfter === 'snapshot') {
+        ignoreErrors.call(vm.$callAsync('start', false, false))
+      }
+
+      if (this._writers.size !== 0) {
+        await (this._isDelta ? this._copyDelta() : this._copyFull())
+      }
+    } finally {
+      if (startAfter) {
+        ignoreErrors.call(vm.$callAsync('start', false, false))
+      }
+
+      await this._fetchJobSnapshots()
+      await this._removeUnusedSnapshots()
+    }
+    await this._healthCheck()
+  }
+}
+exports.VmBackup = VmBackup
+
+decorateMethodsWith(VmBackup, {
+  run: defer,
+})

@xen-orchestra/backups/_XoMetadataBackup.js

@@ -2,9 +2,9 @@
 
 const { asyncMap } = require('@xen-orchestra/async-map')
 
-const { DIR_XO_CONFIG_BACKUPS } = require('../RemoteAdapter.js')
-const { formatFilenameDate } = require('../_filenameDate.js')
-const { Task } = require('../Task.js')
+const { DIR_XO_CONFIG_BACKUPS } = require('./RemoteAdapter.js')
+const { formatFilenameDate } = require('./_filenameDate.js')
+const { Task } = require('./Task.js')
 
 exports.XoMetadataBackup = class XoMetadataBackup {
   constructor({ config, job, remoteAdapters, schedule, settings }) {

@xen-orchestra/backups/_backupWorker.js

@@ -1,8 +1,8 @@
 'use strict'
 
-const logger = require('@xen-orchestra/log').createLogger('xo:backups:worker')
-
-require('@xen-orchestra/log/configure').catchGlobalErrors(logger)
+require('@xen-orchestra/log/configure').catchGlobalErrors(
+  require('@xen-orchestra/log').createLogger('xo:backups:worker')
+)
 
 require('@vates/cached-dns.lookup').createCachedLookup().patchGlobal()
 
@@ -13,15 +13,13 @@ const { createDebounceResource } = require('@vates/disposable/debounceResource.j
 const { decorateMethodsWith } = require('@vates/decorate-with')
 const { deduped } = require('@vates/disposable/deduped.js')
 const { getHandler } = require('@xen-orchestra/fs')
-const { createRunner } = require('./Backup.js')
 const { parseDuration } = require('@vates/parse-duration')
 const { Xapi } = require('@xen-orchestra/xapi')
 
+const { Backup } = require('./Backup.js')
 const { RemoteAdapter } = require('./RemoteAdapter.js')
 const { Task } = require('./Task.js')
 
-const { debug } = logger
-
 class BackupWorker {
   #config
   #job
@@ -48,7 +46,7 @@ class BackupWorker {
   }
 
   run() {
-    return createRunner({
+    return new Backup({
       config: this.#config,
       getAdapter: remoteId => this.getAdapter(this.#remotes[remoteId]),
       getConnectedRecord: Disposable.factory(async function* getConnectedRecord(type, uuid) {
@@ -124,11 +122,6 @@ decorateMethodsWith(BackupWorker, {
   ]),
 })
 
-const emitMessage = message => {
-  debug('message emitted', { message })
-  process.send(message)
-}
-
 // Received message:
 //
 // Message {
@@ -146,8 +139,6 @@ const emitMessage = message => {
 //   result?: any
 // }
 process.on('message', async message => {
-  debug('message received', { message })
-
   if (message.action === 'run') {
     const backupWorker = new BackupWorker(message.data)
     try {
@@ -156,7 +147,7 @@ process.on('message', async message => {
             {
               name: 'backup run',
               onLog: data =>
-                emitMessage({
+                process.send({
                   data,
                   type: 'log',
                 }),
@@ -165,13 +156,13 @@ process.on('message', async message => {
           )
         : await backupWorker.run()
 
-      emitMessage({
+      process.send({
         type: 'result',
         result,
         status: 'success',
       })
     } catch (error) {
-      emitMessage({
+      process.send({
         type: 'result',
         result: error,
         status: 'failure',

@xen-orchestra/backups/_cleanVm.js

@@ -541,8 +541,7 @@ exports.cleanVm = async function cleanVm(
 
         // don't warn if the size has changed after a merge
         if (!merged && fileSystemSize !== size) {
-          // FIXME: figure out why it occurs so often and, once fixed, log the real problems with `logWarn`
-          console.warn('cleanVm: incorrect backup size in metadata', {
+          logWarn('incorrect backup size in metadata', {
             path: metadataPath,
             actual: size ?? 'none',
             expected: fileSystemSize,

@xen-orchestra/backups/_cleanVm.test.js

@@ -3,6 +3,7 @@
 const { beforeEach, afterEach, test, describe } = require('test')
 const assert = require('assert').strict
 
+const rimraf = require('rimraf')
 const tmp = require('tmp')
 const fs = require('fs-extra')
 const uuid = require('uuid')
@@ -13,7 +14,6 @@ const { VHDFOOTER, VHDHEADER } = require('./tests.fixtures.js')
 const { VhdFile, Constants, VhdDirectory, VhdAbstract } = require('vhd-lib')
 const { checkAliases } = require('./_cleanVm')
 const { dirname, basename } = require('path')
-const { rimraf } = require('rimraf')
 
 let tempDir, adapter, handler, jobId, vdiId, basePath, relativePath
 const rootPath = 'xo-vm-backups/VMUUID/'

@xen-orchestra/backups/_deltaVm.js

@@ -12,7 +12,7 @@ const { defer } = require('golike-defer')
 
 const { cancelableMap } = require('./_cancelableMap.js')
 const { Task } = require('./Task.js')
-const pick = require('lodash/pick.js')
+const { pick } = require('lodash')
 
 const TAG_BASE_DELTA = 'xo:base_delta'
 exports.TAG_BASE_DELTA = TAG_BASE_DELTA
@@ -33,7 +33,7 @@ const resolveUuid = async (xapi, cache, uuid, type) => {
   return ref
 }
 
-exports.exportIncrementalVm = async function exportIncrementalVm(
+exports.exportDeltaVm = async function exportDeltaVm(
   vm,
   baseVm,
   {
@@ -143,18 +143,18 @@ exports.exportIncrementalVm = async function exportIncrementalVm(
   )
 }
 
-exports.importIncrementalVm = defer(async function importIncrementalVm(
+exports.importDeltaVm = defer(async function importDeltaVm(
   $defer,
-  incrementalVm,
+  deltaVm,
   sr,
   { cancelToken = CancelToken.none, detectBase = true, mapVdisSrs = {}, newMacAddresses = false } = {}
 ) {
-  const { version } = incrementalVm
+  const { version } = deltaVm
   if (compareVersions(version, '1.0.0') < 0) {
     throw new Error(`Unsupported delta backup version: ${version}`)
   }
 
-  const vmRecord = incrementalVm.vm
+  const vmRecord = deltaVm.vm
   const xapi = sr.$xapi
 
   let baseVm
@@ -183,15 +183,15 @@ exports.importIncrementalVm = defer(async function importIncrementalVm(
         baseVdis[vbd.VDI] = vbd.$VDI
       }
     })
-  const vdiRecords = incrementalVm.vdis
+  const vdiRecords = deltaVm.vdis
 
   // 0. Create suspend_VDI
   let suspendVdi
-  if (vmRecord.suspend_VDI !== undefined && vmRecord.suspend_VDI !== 'OpaqueRef:NULL') {
+  if (vmRecord.power_state === 'Suspended') {
     const vdi = vdiRecords[vmRecord.suspend_VDI]
     if (vdi === undefined) {
       Task.warning('Suspend VDI not available for this suspended VM', {
-        vm: pick(vmRecord, 'uuid', 'name_label', 'suspend_VDI'),
+        vm: pick(vmRecord, 'uuid', 'name_label'),
       })
     } else {
       suspendVdi = await xapi.getRecord(
@@ -240,7 +240,7 @@ exports.importIncrementalVm = defer(async function importIncrementalVm(
   await asyncMap(await xapi.getField('VM', vmRef, 'VBDs'), ref => ignoreErrors.call(xapi.call('VBD.destroy', ref)))
 
   // 3. Create VDIs & VBDs.
-  const vbdRecords = incrementalVm.vbds
+  const vbdRecords = deltaVm.vbds
   const vbds = groupBy(vbdRecords, 'VDI')
   const newVdis = {}
   await asyncMap(Object.keys(vdiRecords), async vdiRef => {
@@ -309,7 +309,7 @@ exports.importIncrementalVm = defer(async function importIncrementalVm(
     }
   })
 
-  const { streams } = incrementalVm
+  const { streams } = deltaVm
 
   await Promise.all([
     // Import VDI contents.
@@ -326,7 +326,7 @@ exports.importIncrementalVm = defer(async function importIncrementalVm(
     }),
 
     // Create VIFs.
-    asyncMap(Object.values(incrementalVm.vifs), vif => {
+    asyncMap(Object.values(deltaVm.vifs), vif => {
       let network = vif.$network$uuid && xapi.getObjectByUuid(vif.$network$uuid, undefined)
 
       if (network === undefined) {
@@ -358,8 +358,8 @@ exports.importIncrementalVm = defer(async function importIncrementalVm(
   ])
 
   await Promise.all([
-    incrementalVm.vm.ha_always_run && xapi.setField('VM', vmRef, 'ha_always_run', true),
-    xapi.setField('VM', vmRef, 'name_label', incrementalVm.vm.name_label),
+    deltaVm.vm.ha_always_run && xapi.setField('VM', vmRef, 'ha_always_run', true),
+    xapi.setField('VM', vmRef, 'name_label', deltaVm.vm.name_label),
   ])
 
   return vmRef

@xen-orchestra/backups/_forkStreamUnpipe.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const eos = require('end-of-stream')
+const { PassThrough } = require('stream')
+
+const { debug } = require('@xen-orchestra/log').createLogger('xo:backups:forkStreamUnpipe')
+
+// create a new readable stream from an existing one which may be piped later
+//
+// in case of error in the new readable stream, it will simply be unpiped
+// from the original one
+exports.forkStreamUnpipe = function forkStreamUnpipe(stream) {
+  const { forks = 0 } = stream
+  stream.forks = forks + 1
+
+  debug('forking', { forks: stream.forks })
+
+  const proxy = new PassThrough()
+  stream.pipe(proxy)
+  eos(stream, error => {
+    if (error !== undefined) {
+      debug('error on original stream, destroying fork', { error })
+      proxy.destroy(error)
+    }
+  })
+  eos(proxy, error => {
+    debug('end of stream, unpiping', { error, forks: --stream.forks })
+
+    stream.unpipe(proxy)
+
+    if (stream.forks === 0) {
+      debug('no more forks, destroying original stream')
+      stream.destroy(new Error('no more consumers for this stream'))
+    }
+  })
+  return proxy
+}

@xen-orchestra/backups/_runners/Metadata.js

@@ -1,134 +0,0 @@
-'use strict'
-
-const { asyncMap } = require('@xen-orchestra/async-map')
-const Disposable = require('promise-toolbox/Disposable')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
-
-const { extractIdsFromSimplePattern } = require('../extractIdsFromSimplePattern.js')
-const { PoolMetadataBackup } = require('./_PoolMetadataBackup.js')
-const { XoMetadataBackup } = require('./_XoMetadataBackup.js')
-const { DEFAULT_SETTINGS, Abstract } = require('./_Abstract.js')
-const { runTask } = require('./_runTask.js')
-const { getAdaptersByRemote } = require('./_getAdaptersByRemote.js')
-
-const DEFAULT_METADATA_SETTINGS = {
-  retentionPoolMetadata: 0,
-  retentionXoMetadata: 0,
-}
-
-exports.Metadata = class MetadataBackupRunner extends Abstract {
-  _computeBaseSettings(config, job) {
-    const baseSettings = { ...DEFAULT_SETTINGS }
-    Object.assign(baseSettings, DEFAULT_METADATA_SETTINGS, config.defaultSettings, config.metadata?.defaultSettings)
-    Object.assign(baseSettings, job.settings[''])
-    return baseSettings
-  }
-
-  async run() {
-    const schedule = this._schedule
-    const job = this._job
-    const remoteIds = extractIdsFromSimplePattern(job.remotes)
-    if (remoteIds.length === 0) {
-      throw new Error('metadata backup job cannot run without remotes')
-    }
-
-    const config = this._config
-    const poolIds = extractIdsFromSimplePattern(job.pools)
-    const isEmptyPools = poolIds.length === 0
-    const isXoMetadata = job.xoMetadata !== undefined
-    if (!isXoMetadata && isEmptyPools) {
-      throw new Error('no metadata mode found')
-    }
-
-    const settings = this._settings
-
-    const { retentionPoolMetadata, retentionXoMetadata } = settings
-
-    if (
-      (retentionPoolMetadata === 0 && retentionXoMetadata === 0) ||
-      (!isXoMetadata && retentionPoolMetadata === 0) ||
-      (isEmptyPools && retentionXoMetadata === 0)
-    ) {
-      throw new Error('no retentions corresponding to the metadata modes found')
-    }
-
-    await Disposable.use(
-      Disposable.all(
-        poolIds.map(id =>
-          this._getRecord('pool', id).catch(error => {
-            // See https://github.com/vatesfr/xen-orchestra/commit/6aa6cfba8ec939c0288f0fa740f6dfad98c43cbb
-            runTask(
-              {
-                name: 'get pool record',
-                data: { type: 'pool', id },
-              },
-              () => Promise.reject(error)
-            )
-          })
-        )
-      ),
-      Disposable.all(remoteIds.map(id => this._getAdapter(id))),
-      async (pools, remoteAdapters) => {
-        // remove adapters that failed (already handled)
-        remoteAdapters = remoteAdapters.filter(_ => _ !== undefined)
-        if (remoteAdapters.length === 0) {
-          return
-        }
-        remoteAdapters = getAdaptersByRemote(remoteAdapters)
-
-        // remove pools that failed (already handled)
-        pools = pools.filter(_ => _ !== undefined)
-
-        const promises = []
-        if (pools.length !== 0 && settings.retentionPoolMetadata !== 0) {
-          promises.push(
-            asyncMap(pools, async pool =>
-              runTask(
-                {
-                  name: `Starting metadata backup for the pool (${pool.$id}). (${job.id})`,
-                  data: {
-                    id: pool.$id,
-                    pool,
-                    poolMaster: await ignoreErrors.call(pool.$xapi.getRecord('host', pool.master)),
-                    type: 'pool',
-                  },
-                },
-                () =>
-                  new PoolMetadataBackup({
-                    config,
-                    job,
-                    pool,
-                    remoteAdapters,
-                    schedule,
-                    settings,
-                  }).run()
-              )
-            )
-          )
-        }
-
-        if (job.xoMetadata !== undefined && settings.retentionXoMetadata !== 0) {
-          promises.push(
-            runTask(
-              {
-                name: `Starting XO metadata backup. (${job.id})`,
-                data: {
-                  type: 'xo',
-                },
-              },
-              () =>
-                new XoMetadataBackup({
-                  config,
-                  job,
-                  remoteAdapters,
-                  schedule,
-                  settings,
-                }).run()
-            )
-          )
-        }
-        await Promise.all(promises)
-      }
-    )
-  }
-}

@xen-orchestra/backups/_runners/VmsXapi.js

@@ -1,138 +0,0 @@
-'use strict'
-
-const { asyncMapSettled } = require('@xen-orchestra/async-map')
-const Disposable = require('promise-toolbox/Disposable')
-const { limitConcurrency } = require('limit-concurrency-decorator')
-
-const { extractIdsFromSimplePattern } = require('../extractIdsFromSimplePattern.js')
-const { Task } = require('../Task.js')
-const createStreamThrottle = require('./_createStreamThrottle.js')
-const { DEFAULT_SETTINGS, Abstract } = require('./_Abstract.js')
-const { runTask } = require('./_runTask.js')
-const { getAdaptersByRemote } = require('./_getAdaptersByRemote.js')
-const { IncrementalXapi } = require('./_vmRunners/IncrementalXapi.js')
-const { FullXapi } = require('./_vmRunners/FullXapi.js')
-
-const DEFAULT_XAPI_VM_SETTINGS = {
-  bypassVdiChainsCheck: false,
-  checkpointSnapshot: false,
-  concurrency: 2,
-  copyRetention: 0,
-  deleteFirst: false,
-  exportRetention: 0,
-  fullInterval: 0,
-  healthCheckSr: undefined,
-  healthCheckVmsWithTags: [],
-  maxExportRate: 0,
-  maxMergedDeltasPerRun: Infinity,
-  offlineBackup: false,
-  offlineSnapshot: false,
-  snapshotRetention: 0,
-  timeout: 0,
-  useNbd: false,
-  unconditionalSnapshot: false,
-  validateVhdStreams: false,
-  vmTimeout: 0,
-}
-
-exports.VmsXapi = class VmsXapiBackupRunner extends Abstract {
-  _computeBaseSettings(config, job) {
-    const baseSettings = { ...DEFAULT_SETTINGS }
-    Object.assign(baseSettings, DEFAULT_XAPI_VM_SETTINGS, config.defaultSettings, config.vm?.defaultSettings)
-    Object.assign(baseSettings, job.settings[''])
-    return baseSettings
-  }
-
-  async run() {
-    const job = this._job
-
-    // FIXME: proper SimpleIdPattern handling
-    const getSnapshotNameLabel = this._getSnapshotNameLabel
-    const schedule = this._schedule
-    const settings = this._settings
-
-    const throttleStream = createStreamThrottle(settings.maxExportRate)
-
-    const config = this._config
-    await Disposable.use(
-      Disposable.all(
-        extractIdsFromSimplePattern(job.srs).map(id =>
-          this._getRecord('SR', id).catch(error => {
-            runTask(
-              {
-                name: 'get SR record',
-                data: { type: 'SR', id },
-              },
-              () => Promise.reject(error)
-            )
-          })
-        )
-      ),
-      Disposable.all(extractIdsFromSimplePattern(job.remotes).map(id => this._getAdapter(id))),
-      () => (settings.healthCheckSr !== undefined ? this._getRecord('SR', settings.healthCheckSr) : undefined),
-      async (srs, remoteAdapters, healthCheckSr) => {
-        // remove adapters that failed (already handled)
-        remoteAdapters = remoteAdapters.filter(_ => _ !== undefined)
-
-        // remove srs that failed (already handled)
-        srs = srs.filter(_ => _ !== undefined)
-
-        if (remoteAdapters.length === 0 && srs.length === 0 && settings.snapshotRetention === 0) {
-          return
-        }
-
-        const vmIds = extractIdsFromSimplePattern(job.vms)
-
-        Task.info('vms', { vms: vmIds })
-
-        remoteAdapters = getAdaptersByRemote(remoteAdapters)
-
-        const allSettings = this._job.settings
-        const baseSettings = this._baseSettings
-
-        const handleVm = vmUuid => {
-          const taskStart = { name: 'backup VM', data: { type: 'VM', id: vmUuid } }
-
-          return this._getRecord('VM', vmUuid).then(
-            disposableVm =>
-              Disposable.use(disposableVm, vm => {
-                taskStart.data.name_label = vm.name_label
-                return runTask(taskStart, () => {
-                  const opts = {
-                    baseSettings,
-                    config,
-                    getSnapshotNameLabel,
-                    healthCheckSr,
-                    job,
-                    remoteAdapters,
-                    schedule,
-                    settings: { ...settings, ...allSettings[vm.uuid] },
-                    srs,
-                    throttleStream,
-                    vm,
-                  }
-                  let vmBackup
-                  if (job.mode === 'delta') {
-                    vmBackup = new IncrementalXapi(opts)
-                  } else {
-                    if (job.mode === 'full') {
-                      vmBackup = new FullXapi(opts)
-                    } else {
-                      throw new Error(`Job mode ${job.mode} not implemented`)
-                    }
-                  }
-                  return vmBackup.run()
-                })
-              }),
-            error =>
-              runTask(taskStart, () => {
-                throw error
-              })
-          )
-        }
-        const { concurrency } = settings
-        await asyncMapSettled(vmIds, concurrency === 0 ? handleVm : limitConcurrency(concurrency)(handleVm))
-      }
-    )
-  }
-}

@xen-orchestra/backups/_runners/_Abstract.js

@@ -1,51 +0,0 @@
-'use strict'
-
-const Disposable = require('promise-toolbox/Disposable')
-const pTimeout = require('promise-toolbox/timeout')
-const { compileTemplate } = require('@xen-orchestra/template')
-const { runTask } = require('./_runTask.js')
-const { RemoteTimeoutError } = require('./_RemoteTimeoutError.js')
-
-exports.DEFAULT_SETTINGS = {
-  getRemoteTimeout: 300e3,
-  reportWhen: 'failure',
-}
-
-exports.Abstract = class AbstractRunner {
-  constructor({ config, getAdapter, getConnectedRecord, job, schedule }) {
-    this._config = config
-    this._getRecord = getConnectedRecord
-    this._job = job
-    this._schedule = schedule
-
-    this._getSnapshotNameLabel = compileTemplate(config.snapshotNameLabelTpl, {
-      '{job.name}': job.name,
-      '{vm.name_label}': vm => vm.name_label,
-    })
-
-    const baseSettings = this._computeBaseSettings(config, job)
-    this._baseSettings = baseSettings
-    this._settings = { ...baseSettings, ...job.settings[schedule.id] }
-
-    const { getRemoteTimeout } = this._settings
-    this._getAdapter = async function (remoteId) {
-      try {
-        const disposable = await pTimeout.call(getAdapter(remoteId), getRemoteTimeout, new RemoteTimeoutError(remoteId))
-
-        return new Disposable(() => disposable.dispose(), {
-          adapter: disposable.value,
-          remoteId,
-        })
-      } catch (error) {
-        // See https://github.com/vatesfr/xen-orchestra/commit/6aa6cfba8ec939c0288f0fa740f6dfad98c43cbb
-        runTask(
-          {
-            name: 'get remote adapter',
-            data: { type: 'remote', id: remoteId },
-          },
-          () => Promise.reject(error)
-        )
-      }
-    }
-  }
-}

@xen-orchestra/backups/_runners/_RemoteTimeoutError.js

@@ -1,8 +0,0 @@
-'use strict'
-class RemoteTimeoutError extends Error {
-  constructor(remoteId) {
-    super('timeout while getting the remote ' + remoteId)
-    this.remoteId = remoteId
-  }
-}
-exports.RemoteTimeoutError = RemoteTimeoutError

@xen-orchestra/backups/_runners/_createStreamThrottle.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { pipeline } = require('node:stream')
-const { ThrottleGroup } = require('@kldzj/stream-throttle')
-const identity = require('lodash/identity.js')
-
-const noop = Function.prototype
-
-module.exports = function createStreamThrottle(rate) {
-  if (rate === 0) {
-    return identity
-  }
-  const group = new ThrottleGroup({ rate })
-  return function throttleStream(stream) {
-    return pipeline(stream, group.createThrottle(), noop)
-  }
-}

@xen-orchestra/backups/_runners/_forkStreamUnpipe.js

@@ -1,36 +0,0 @@
-'use strict'
-
-const { finished, PassThrough } = require('node:stream')
-
-const { debug } = require('@xen-orchestra/log').createLogger('xo:backups:forkStreamUnpipe')
-
-// create a new readable stream from an existing one which may be piped later
-//
-// in case of error in the new readable stream, it will simply be unpiped
-// from the original one
-exports.forkStreamUnpipe = function forkStreamUnpipe(source) {
-  const { forks = 0 } = source
-  source.forks = forks + 1
-
-  debug('forking', { forks: source.forks })
-
-  const fork = new PassThrough()
-  source.pipe(fork)
-  finished(source, { writable: false }, error => {
-    if (error !== undefined) {
-      debug('error on original stream, destroying fork', { error })
-      fork.destroy(error)
-    }
-  })
-  finished(fork, { readable: false }, error => {
-    debug('end of stream, unpiping', { error, forks: --source.forks })
-
-    source.unpipe(fork)
-
-    if (source.forks === 0) {
-      debug('no more forks, destroying original stream')
-      source.destroy(new Error('no more consumers for this stream'))
-    }
-  })
-  return fork
-}

@xen-orchestra/backups/_runners/_getAdaptersByRemote.js

@@ -1,9 +0,0 @@
-'use strict'
-const getAdaptersByRemote = adapters => {
-  const adaptersByRemote = {}
-  adapters.forEach(({ adapter, remoteId }) => {
-    adaptersByRemote[remoteId] = adapter
-  })
-  return adaptersByRemote
-}
-exports.getAdaptersByRemote = getAdaptersByRemote

@xen-orchestra/backups/_runners/_runTask.js

@@ -1,6 +0,0 @@
-'use strict'
-const { Task } = require('../Task.js')
-const noop = Function.prototype
-const runTask = (...args) => Task.run(...args).catch(noop) // errors are handled by logs
-
-exports.runTask = runTask

@xen-orchestra/backups/_runners/_vmRunners/FullXapi.js

@@ -1,61 +0,0 @@
-'use strict'
-
-const { createLogger } = require('@xen-orchestra/log')
-
-const { forkStreamUnpipe } = require('../_forkStreamUnpipe.js')
-const { FullRemoteWriter } = require('../_writers/FullRemoteWriter.js')
-const { FullXapiWriter } = require('../_writers/FullXapiWriter.js')
-const { watchStreamSize } = require('../../_watchStreamSize.js')
-const { AbstractXapi } = require('./_AbstractXapi.js')
-
-const { debug } = createLogger('xo:backups:FullXapiVmBackup')
-
-exports.FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
-  _getWriters() {
-    return [FullRemoteWriter, FullXapiWriter]
-  }
-
-  _mustDoSnapshot() {
-    const { vm } = this
-
-    const settings = this._settings
-    return (
-      settings.unconditionalSnapshot ||
-      (!settings.offlineBackup && vm.power_state === 'Running') ||
-      settings.snapshotRetention !== 0
-    )
-  }
-  _selectBaseVm() {}
-
-  async _copy() {
-    const { compression } = this.job
-    const stream = this._throttleStream(
-      await this._xapi.VM_export(this.exportedVm.$ref, {
-        compress: Boolean(compression) && (compression === 'native' ? 'gzip' : 'zstd'),
-        useSnapshot: false,
-      })
-    )
-    const sizeContainer = watchStreamSize(stream)
-
-    const timestamp = Date.now()
-
-    await this._callWriters(
-      writer =>
-        writer.run({
-          sizeContainer,
-          stream: forkStreamUnpipe(stream),
-          timestamp,
-        }),
-      'writer.run()'
-    )
-
-    const { size } = sizeContainer
-    const end = Date.now()
-    const duration = end - timestamp
-    debug('transfer complete', {
-      duration,
-      speed: duration !== 0 ? (size * 1e3) / 1024 / 1024 / duration : 0,
-      size,
-    })
-  }
-}

@xen-orchestra/backups/_runners/_vmRunners/IncrementalXapi.js

@@ -1,163 +0,0 @@
-'use strict'
-
-const findLast = require('lodash/findLast.js')
-const keyBy = require('lodash/keyBy.js')
-const mapValues = require('lodash/mapValues.js')
-const vhdStreamValidator = require('vhd-lib/vhdStreamValidator.js')
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { createLogger } = require('@xen-orchestra/log')
-const { pipeline } = require('node:stream')
-
-const { IncrementalRemoteWriter } = require('../_writers/IncrementalRemoteWriter.js')
-const { IncrementalXapiWriter } = require('../_writers/IncrementalXapiWriter.js')
-const { exportIncrementalVm } = require('../../_incrementalVm.js')
-const { Task } = require('../../Task.js')
-const { watchStreamSize } = require('../../_watchStreamSize.js')
-const { AbstractXapi } = require('./_AbstractXapi.js')
-const { forkDeltaExport } = require('./_forkDeltaExport.js')
-
-const { debug } = createLogger('xo:backups:IncrementalXapiVmBackup')
-
-const noop = Function.prototype
-
-exports.IncrementalXapi = class IncrementalXapiVmBackupRunner extends AbstractXapi {
-  _getWriters() {
-    return [IncrementalRemoteWriter, IncrementalXapiWriter]
-  }
-
-  _mustDoSnapshot() {
-    return true
-  }
-
-  async _copy() {
-    const { exportedVm } = this
-    const baseVm = this._baseVm
-    const fullVdisRequired = this._fullVdisRequired
-
-    const isFull = fullVdisRequired === undefined || fullVdisRequired.size !== 0
-
-    await this._callWriters(writer => writer.prepare({ isFull }), 'writer.prepare()')
-
-    const deltaExport = await exportIncrementalVm(exportedVm, baseVm, {
-      fullVdisRequired,
-    })
-    // since NBD is network based, if one disk use nbd , all the disk use them
-    // except the suspended VDI
-    if (Object.values(deltaExport.streams).some(({ _nbd }) => _nbd)) {
-      Task.info('Transfer data using NBD')
-    }
-    const sizeContainers = mapValues(deltaExport.streams, stream => watchStreamSize(stream))
-
-    if (this._settings.validateVhdStreams) {
-      deltaExport.streams = mapValues(deltaExport.streams, stream => pipeline(stream, vhdStreamValidator, noop))
-    }
-
-    deltaExport.streams = mapValues(deltaExport.streams, this._throttleStream)
-
-    const timestamp = Date.now()
-
-    await this._callWriters(
-      writer =>
-        writer.transfer({
-          deltaExport: forkDeltaExport(deltaExport),
-          sizeContainers,
-          timestamp,
-        }),
-      'writer.transfer()'
-    )
-
-    this._baseVm = exportedVm
-
-    if (baseVm !== undefined) {
-      await exportedVm.update_other_config(
-        'xo:backup:deltaChainLength',
-        String(+(baseVm.other_config['xo:backup:deltaChainLength'] ?? 0) + 1)
-      )
-    }
-
-    // not the case if offlineBackup
-    if (exportedVm.is_a_snapshot) {
-      await exportedVm.update_other_config('xo:backup:exported', 'true')
-    }
-
-    const size = Object.values(sizeContainers).reduce((sum, { size }) => sum + size, 0)
-    const end = Date.now()
-    const duration = end - timestamp
-    debug('transfer complete', {
-      duration,
-      speed: duration !== 0 ? (size * 1e3) / 1024 / 1024 / duration : 0,
-      size,
-    })
-
-    await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
-  }
-
-  async _selectBaseVm() {
-    const xapi = this._xapi
-
-    let baseVm = findLast(this._jobSnapshots, _ => 'xo:backup:exported' in _.other_config)
-    if (baseVm === undefined) {
-      debug('no base VM found')
-      return
-    }
-
-    const fullInterval = this._settings.fullInterval
-    const deltaChainLength = +(baseVm.other_config['xo:backup:deltaChainLength'] ?? 0) + 1
-    if (!(fullInterval === 0 || fullInterval > deltaChainLength)) {
-      debug('not using base VM becaust fullInterval reached')
-      return
-    }
-
-    const srcVdis = keyBy(await xapi.getRecords('VDI', await this.vm.$getDisks()), '$ref')
-
-    // resolve full record
-    baseVm = await xapi.getRecord('VM', baseVm.$ref)
-
-    const baseUuidToSrcVdi = new Map()
-    await asyncMap(await baseVm.$getDisks(), async baseRef => {
-      const [baseUuid, snapshotOf] = await Promise.all([
-        xapi.getField('VDI', baseRef, 'uuid'),
-        xapi.getField('VDI', baseRef, 'snapshot_of'),
-      ])
-      const srcVdi = srcVdis[snapshotOf]
-      if (srcVdi !== undefined) {
-        baseUuidToSrcVdi.set(baseUuid, srcVdi)
-      } else {
-        debug('ignore snapshot VDI because no longer present on VM', {
-          vdi: baseUuid,
-        })
-      }
-    })
-
-    const presentBaseVdis = new Map(baseUuidToSrcVdi)
-    await this._callWriters(
-      writer => presentBaseVdis.size !== 0 && writer.checkBaseVdis(presentBaseVdis, baseVm),
-      'writer.checkBaseVdis()',
-      false
-    )
-
-    if (presentBaseVdis.size === 0) {
-      debug('no base VM found')
-      return
-    }
-
-    const fullVdisRequired = new Set()
-    baseUuidToSrcVdi.forEach((srcVdi, baseUuid) => {
-      if (presentBaseVdis.has(baseUuid)) {
-        debug('found base VDI', {
-          base: baseUuid,
-          vdi: srcVdi.uuid,
-        })
-      } else {
-        debug('missing base VDI', {
-          base: baseUuid,
-          vdi: srcVdi.uuid,
-        })
-        fullVdisRequired.add(srcVdi.uuid)
-      }
-    })
-
-    this._baseVm = baseVm
-    this._fullVdisRequired = fullVdisRequired
-  }
-}

@xen-orchestra/backups/_runners/_vmRunners/_Abstract.js

@@ -1,87 +0,0 @@
-'use strict'
-
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { createLogger } = require('@xen-orchestra/log')
-const { Task } = require('../../Task.js')
-
-const { debug, warn } = createLogger('xo:backups:AbstractVmRunner')
-
-class AggregateError extends Error {
-  constructor(errors, message) {
-    super(message)
-    this.errors = errors
-  }
-}
-
-const asyncEach = async (iterable, fn, thisArg = iterable) => {
-  for (const item of iterable) {
-    await fn.call(thisArg, item)
-  }
-}
-
-exports.Abstract = class AbstractVmBackupRunner {
-  // calls fn for each function, warns of any errors, and throws only if there are no writers left
-  async _callWriters(fn, step, parallel = true) {
-    const writers = this._writers
-    const n = writers.size
-    if (n === 0) {
-      return
-    }
-
-    async function callWriter(writer) {
-      const { name } = writer.constructor
-      try {
-        debug('writer step starting', { step, writer: name })
-        await fn(writer)
-        debug('writer step succeeded', { duration: step, writer: name })
-      } catch (error) {
-        writers.delete(writer)
-
-        warn('writer step failed', { error, step, writer: name })
-
-        // these two steps are the only one that are not already in their own sub tasks
-        if (step === 'writer.checkBaseVdis()' || step === 'writer.beforeBackup()') {
-          Task.warning(
-            `the writer ${name} has failed the step ${step} with error ${error.message}. It won't be used anymore in this job execution.`
-          )
-        }
-
-        throw error
-      }
-    }
-    if (n === 1) {
-      const [writer] = writers
-      return callWriter(writer)
-    }
-
-    const errors = []
-    await (parallel ? asyncMap : asyncEach)(writers, async function (writer) {
-      try {
-        await callWriter(writer)
-      } catch (error) {
-        errors.push(error)
-      }
-    })
-    if (writers.size === 0) {
-      throw new AggregateError(errors, 'all targets have failed, step: ' + step)
-    }
-  }
-
-  async _healthCheck() {
-    const settings = this._settings
-
-    if (this._healthCheckSr === undefined) {
-      return
-    }
-
-    // check if current VM has tags
-    const { tags } = this.vm
-    const intersect = settings.healthCheckVmsWithTags.some(t => tags.includes(t))
-
-    if (settings.healthCheckVmsWithTags.length !== 0 && !intersect) {
-      return
-    }
-
-    await this._callWriters(writer => writer.healthCheck(this._healthCheckSr), 'writer.healthCheck()')
-  }
-}

@xen-orchestra/backups/_runners/_vmRunners/_AbstractXapi.js

@@ -1,258 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const groupBy = require('lodash/groupBy.js')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { decorateMethodsWith } = require('@vates/decorate-with')
-const { defer } = require('golike-defer')
-const { formatDateTime } = require('@xen-orchestra/xapi')
-
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { Task } = require('../../Task.js')
-const { Abstract } = require('./_Abstract.js')
-
-class AbstractXapiVmBackupRunner extends Abstract {
-  constructor({
-    config,
-    getSnapshotNameLabel,
-    healthCheckSr,
-    job,
-    remoteAdapters,
-    remotes,
-    schedule,
-    settings,
-    srs,
-    throttleStream,
-    vm,
-  }) {
-    super()
-    if (vm.other_config['xo:backup:job'] === job.id && 'start' in vm.blocked_operations) {
-      // don't match replicated VMs created by this very job otherwise they
-      // will be replicated again and again
-      throw new Error('cannot backup a VM created by this very job')
-    }
-
-    this.config = config
-    this.job = job
-    this.remoteAdapters = remoteAdapters
-    this.scheduleId = schedule.id
-    this.timestamp = undefined
-
-    // VM currently backed up
-    this.vm = vm
-    const { tags } = this.vm
-
-    // VM (snapshot) that is really exported
-    this.exportedVm = undefined
-
-    this._fullVdisRequired = undefined
-    this._getSnapshotNameLabel = getSnapshotNameLabel
-    this._isIncremental = job.mode === 'delta'
-    this._healthCheckSr = healthCheckSr
-    this._jobId = job.id
-    this._jobSnapshots = undefined
-    this._throttleStream = throttleStream
-    this._xapi = vm.$xapi
-
-    // Base VM for the export
-    this._baseVm = undefined
-
-    // Settings for this specific run (job, schedule, VM)
-    if (tags.includes('xo-memory-backup')) {
-      settings.checkpointSnapshot = true
-    }
-    if (tags.includes('xo-offline-backup')) {
-      settings.offlineSnapshot = true
-    }
-    this._settings = settings
-
-    // Create writers
-    {
-      const writers = new Set()
-      this._writers = writers
-
-      const [BackupWriter, ReplicationWriter] = this._getWriters()
-
-      const allSettings = job.settings
-      Object.keys(remoteAdapters).forEach(remoteId => {
-        const targetSettings = {
-          ...settings,
-          ...allSettings[remoteId],
-        }
-        if (targetSettings.exportRetention !== 0) {
-          writers.add(new BackupWriter({ backup: this, remoteId, settings: targetSettings }))
-        }
-      })
-      srs.forEach(sr => {
-        const targetSettings = {
-          ...settings,
-          ...allSettings[sr.uuid],
-        }
-        if (targetSettings.copyRetention !== 0) {
-          writers.add(new ReplicationWriter({ backup: this, sr, settings: targetSettings }))
-        }
-      })
-    }
-  }
-
-  // ensure the VM itself does not have any backup metadata which would be
-  // copied on manual snapshots and interfere with the backup jobs
-  async _cleanMetadata() {
-    const { vm } = this
-    if ('xo:backup:job' in vm.other_config) {
-      await vm.update_other_config({
-        'xo:backup:datetime': null,
-        'xo:backup:deltaChainLength': null,
-        'xo:backup:exported': null,
-        'xo:backup:job': null,
-        'xo:backup:schedule': null,
-        'xo:backup:vm': null,
-      })
-    }
-  }
-
-  async _snapshot() {
-    const { vm } = this
-    const xapi = this._xapi
-
-    const settings = this._settings
-
-    if (this._mustDoSnapshot()) {
-      await Task.run({ name: 'snapshot' }, async () => {
-        if (!settings.bypassVdiChainsCheck) {
-          await vm.$assertHealthyVdiChains()
-        }
-
-        const snapshotRef = await vm[settings.checkpointSnapshot ? '$checkpoint' : '$snapshot']({
-          ignoreNobakVdis: true,
-          name_label: this._getSnapshotNameLabel(vm),
-          unplugVusbs: true,
-        })
-        this.timestamp = Date.now()
-
-        await xapi.setFieldEntries('VM', snapshotRef, 'other_config', {
-          'xo:backup:datetime': formatDateTime(this.timestamp),
-          'xo:backup:job': this._jobId,
-          'xo:backup:schedule': this.scheduleId,
-          'xo:backup:vm': vm.uuid,
-        })
-
-        this.exportedVm = await xapi.getRecord('VM', snapshotRef)
-
-        return this.exportedVm.uuid
-      })
-    } else {
-      this.exportedVm = vm
-      this.timestamp = Date.now()
-    }
-  }
-
-  async _fetchJobSnapshots() {
-    const jobId = this._jobId
-    const vmRef = this.vm.$ref
-    const xapi = this._xapi
-
-    const snapshotsRef = await xapi.getField('VM', vmRef, 'snapshots')
-    const snapshotsOtherConfig = await asyncMap(snapshotsRef, ref => xapi.getField('VM', ref, 'other_config'))
-
-    const snapshots = []
-    snapshotsOtherConfig.forEach((other_config, i) => {
-      if (other_config['xo:backup:job'] === jobId) {
-        snapshots.push({ other_config, $ref: snapshotsRef[i] })
-      }
-    })
-    snapshots.sort((a, b) => (a.other_config['xo:backup:datetime'] < b.other_config['xo:backup:datetime'] ? -1 : 1))
-    this._jobSnapshots = snapshots
-  }
-
-  async _removeUnusedSnapshots() {
-    const allSettings = this.job.settings
-    const baseSettings = this._baseSettings
-    const baseVmRef = this._baseVm?.$ref
-
-    const snapshotsPerSchedule = groupBy(this._jobSnapshots, _ => _.other_config['xo:backup:schedule'])
-    const xapi = this._xapi
-    await asyncMap(Object.entries(snapshotsPerSchedule), ([scheduleId, snapshots]) => {
-      const settings = {
-        ...baseSettings,
-        ...allSettings[scheduleId],
-        ...allSettings[this.vm.uuid],
-      }
-      return asyncMap(getOldEntries(settings.snapshotRetention, snapshots), ({ $ref }) => {
-        if ($ref !== baseVmRef) {
-          return xapi.VM_destroy($ref)
-        }
-      })
-    })
-  }
-
-  async copy() {
-    throw new Error('Not implemented')
-  }
-
-  _getWriters() {
-    throw new Error('Not implemented')
-  }
-
-  _mustDoSnapshot() {
-    throw new Error('Not implemented')
-  }
-
-  async _selectBaseVm() {
-    throw new Error('Not implemented')
-  }
-
-  async run($defer) {
-    const settings = this._settings
-    assert(
-      !settings.offlineBackup || settings.snapshotRetention === 0,
-      'offlineBackup is not compatible with snapshotRetention'
-    )
-
-    await this._callWriters(async writer => {
-      await writer.beforeBackup()
-      $defer(async () => {
-        await writer.afterBackup()
-      })
-    }, 'writer.beforeBackup()')
-
-    await this._fetchJobSnapshots()
-
-    await this._selectBaseVm()
-
-    await this._cleanMetadata()
-    await this._removeUnusedSnapshots()
-
-    const { vm } = this
-    const isRunning = vm.power_state === 'Running'
-    const startAfter = isRunning && (settings.offlineBackup ? 'backup' : settings.offlineSnapshot && 'snapshot')
-    if (startAfter) {
-      await vm.$callAsync('clean_shutdown')
-    }
-
-    try {
-      await this._snapshot()
-      if (startAfter === 'snapshot') {
-        ignoreErrors.call(vm.$callAsync('start', false, false))
-      }
-
-      if (this._writers.size !== 0) {
-        await this._copy()
-      }
-    } finally {
-      if (startAfter) {
-        ignoreErrors.call(vm.$callAsync('start', false, false))
-      }
-
-      await this._fetchJobSnapshots()
-      await this._removeUnusedSnapshots()
-    }
-    await this._healthCheck()
-  }
-}
-exports.AbstractXapi = AbstractXapiVmBackupRunner
-
-decorateMethodsWith(AbstractXapiVmBackupRunner, {
-  run: defer,
-})

@xen-orchestra/backups/_runners/_vmRunners/_forkDeltaExport.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { mapValues } = require('lodash')
-const { forkStreamUnpipe } = require('../_forkStreamUnpipe')
-
-exports.forkDeltaExport = function forkDeltaExport(deltaExport) {
-  return Object.create(deltaExport, {
-    streams: {
-      value: mapValues(deltaExport.streams, forkStreamUnpipe),
-    },
-  })
-}

@xen-orchestra/backups/_runners/_writers/_MixinXapiWriter.js

@@ -1,44 +0,0 @@
-'use strict'
-
-const { extractOpaqueRef } = require('@xen-orchestra/xapi')
-
-const { Task } = require('../../Task')
-const assert = require('node:assert/strict')
-const { HealthCheckVmBackup } = require('../../HealthCheckVmBackup')
-
-exports.MixinXapiWriter = (BaseClass = Object) =>
-  class MixinXapiWriter extends BaseClass {
-    constructor({ sr, ...rest }) {
-      super(rest)
-
-      this._sr = sr
-    }
-
-    healthCheck(sr) {
-      assert.notEqual(this._targetVmRef, undefined, 'A vm should have been transfered to be health checked')
-      // copy VM
-      return Task.run(
-        {
-          name: 'health check',
-        },
-        async () => {
-          const { $xapi: xapi } = sr
-          let clonedVm
-          try {
-            const baseVm = xapi.getObject(this._targetVmRef) ?? (await xapi.waitObject(this._targetVmRef))
-            const clonedRef = await xapi
-              .callAsync('VM.clone', this._targetVmRef, `Health Check - ${baseVm.name_label}`)
-              .then(extractOpaqueRef)
-            clonedVm = xapi.getObject(clonedRef) ?? (await xapi.waitObject(clonedRef))
-
-            await new HealthCheckVmBackup({
-              restoredVm: clonedVm,
-              xapi,
-            }).run()
-          } finally {
-            clonedVm && (await xapi.VM_destroy(clonedVm.$ref))
-          }
-        }
-      )
-    }
-  }

@xen-orchestra/backups/docs/VM backups/README.md

@@ -94,13 +94,13 @@ In case any incoherence is detected, the file is deleted so it will be fully gen
 job.start(data: { mode: Mode, reportWhen: ReportWhen })
 ├─ task.info(message: 'vms', data: { vms: string[] })
 ├─ task.warning(message: string)
-├─ task.start(data: { type: 'VM', id: string, name_label?: string })
+├─ task.start(data: { type: 'VM', id: string })
 │  ├─ task.warning(message: string)
 |  ├─ task.start(message: 'clean-vm')
 │  │  └─ task.end
 │  ├─ task.start(message: 'snapshot')
 │  │  └─ task.end
-│  ├─ task.start(message: 'export', data: { type: 'SR' | 'remote', id: string, name_label?: string, isFull: boolean })
+│  ├─ task.start(message: 'export', data: { type: 'SR' | 'remote', id: string, isFull: boolean })
 │  │  ├─ task.warning(message: string)
 │  │  ├─ task.start(message: 'transfer')
 │  │  │  ├─ task.warning(message: string)

@xen-orchestra/backups/docs/healthcheck/example.sh

@@ -1,35 +0,0 @@
-#!/bin/sh
-
-# This script must be executed at the start of the machine.
-#
-# It must run as root to be able to use xenstore-read and xenstore-write
-
-# fail in case of error or undefined variable
-set -eu
-
-# stop there if a health check is not in progress
-if [ "$(xenstore-read vm-data/xo-backup-health-check 2>&1)" != planned ]
-then
-  exit
-fi
-
-# not necessary, but informs XO that this script has started which helps diagnose issues
-xenstore-write vm-data/xo-backup-health-check running
-
-# put your test here
-#
-# in this example, the command `sqlite3` is used to validate the health of a database
-# and its output is captured and passed to XO via the XenStore in case of error
-if output=$(sqlite3 ~/my-database.sqlite3 .table 2>&1)
-then
-  # inform XO everything is ok
-  xenstore-write vm-data/xo-backup-health-check success
-else
-  # inform XO there is an issue
-  xenstore-write vm-data/xo-backup-health-check failure
-
-  # more info about the issue can be written to `vm-data/health-check-error`
-  #
-  # it will be shown in XO
-  xenstore-write vm-data/xo-backup-health-check-error "$output"
-fi

@xen-orchestra/backups/package.json

@@ -8,31 +8,31 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.37.0",
+  "version": "0.29.5",
   "engines": {
     "node": ">=14.6"
   },
   "scripts": {
     "postversion": "npm publish --access public",
-    "test-integration": "node--test *.integ.js"
+    "test": "node--test"
   },
   "dependencies": {
-    "@kldzj/stream-throttle": "^1.1.1",
     "@vates/async-each": "^1.0.0",
     "@vates/cached-dns.lookup": "^1.0.0",
     "@vates/compose": "^2.1.0",
     "@vates/decorate-with": "^2.0.0",
     "@vates/disposable": "^0.1.4",
     "@vates/fuse-vhd": "^1.0.0",
-    "@vates/nbd-client": "^1.2.0",
+    "@vates/nbd-client": "*",
     "@vates/parse-duration": "^0.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/fs": "^4.0.0",
+    "@xen-orchestra/fs": "^3.3.1",
     "@xen-orchestra/log": "^0.6.0",
     "@xen-orchestra/template": "^0.1.0",
     "compare-versions": "^5.0.1",
     "d3-time-format": "^3.0.0",
     "decorator-synchronized": "^0.6.0",
+    "end-of-stream": "^1.4.4",
     "fs-extra": "^11.1.0",
     "golike-defer": "^0.5.1",
     "limit-concurrency-decorator": "^0.5.0",
@@ -42,17 +42,17 @@
     "promise-toolbox": "^0.21.0",
     "proper-lockfile": "^4.1.2",
     "uuid": "^9.0.0",
-    "vhd-lib": "^4.4.1",
+    "vhd-lib": "^4.2.1",
     "yazl": "^2.5.1"
   },
   "devDependencies": {
-    "rimraf": "^5.0.1",
+    "rimraf": "^4.1.1",
     "sinon": "^15.0.1",
     "test": "^3.2.1",
     "tmp": "^0.2.1"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^2.2.1"
+    "@xen-orchestra/xapi": "^1.6.1"
   },
   "license": "AGPL-3.0-or-later",
   "author": {

@xen-orchestra/backups/runBackupWorker.js

@@ -12,7 +12,7 @@ exports.runBackupWorker = function runBackupWorker(params, onLog) {
   return new Promise((resolve, reject) => {
     const worker = fork(PATH)
 
-    worker.on('exit', (code, signal) => reject(new Error(`worker exited with code ${code} and signal ${signal}`)))
+    worker.on('exit', code => reject(new Error(`worker exited with code ${code}`)))
     worker.on('error', reject)
 
     worker.on('message', message => {

@xen-orchestra/backups/writers/DeltaBackupWriter.js

@@ -7,23 +7,22 @@ const ignoreErrors = require('promise-toolbox/ignoreErrors')
 const { asyncMap } = require('@xen-orchestra/async-map')
 const { chainVhd, checkVhdChain, openVhd, VhdAbstract } = require('vhd-lib')
 const { createLogger } = require('@xen-orchestra/log')
-const { decorateClass } = require('@vates/decorate-with')
-const { defer } = require('golike-defer')
 const { dirname } = require('path')
 
-const { formatFilenameDate } = require('../../_filenameDate.js')
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { Task } = require('../../Task.js')
+const { formatFilenameDate } = require('../_filenameDate.js')
+const { getOldEntries } = require('../_getOldEntries.js')
+const { Task } = require('../Task.js')
 
-const { MixinRemoteWriter } = require('./_MixinRemoteWriter.js')
-const { AbstractIncrementalWriter } = require('./_AbstractIncrementalWriter.js')
+const { MixinBackupWriter } = require('./_MixinBackupWriter.js')
+const { AbstractDeltaWriter } = require('./_AbstractDeltaWriter.js')
 const { checkVhd } = require('./_checkVhd.js')
 const { packUuid } = require('./_packUuid.js')
 const { Disposable } = require('promise-toolbox')
+const NbdClient = require('@vates/nbd-client')
 
-const { warn } = createLogger('xo:backups:DeltaBackupWriter')
+const { debug, warn, info } = createLogger('xo:backups:DeltaBackupWriter')
 
-class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWriter) {
+exports.DeltaBackupWriter = class DeltaBackupWriter extends MixinBackupWriter(AbstractDeltaWriter) {
   async checkBaseVdis(baseUuidToSrcVdi) {
     const { handler } = this._adapter
     const backup = this._backup
@@ -134,7 +133,7 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
     }
   }
 
-  async _transfer($defer, { timestamp, deltaExport }) {
+  async _transfer({ timestamp, deltaExport }) {
     const adapter = this._adapter
     const backup = this._backup
 
@@ -199,12 +198,34 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
             await checkVhd(handler, parentPath)
           }
 
+          const vdiRef = vm.$xapi.getObject(vdi.uuid).$ref
+
+          let nbdClient
+          if (this._backup.config.useNbd) {
+            debug('useNbd is enabled', { vdi: id, path })
+            // get nbd if possible
+            try {
+              // this will always take the first host in the list
+              const [nbdInfo] = await vm.$xapi.call('VDI.get_nbd_info', vdiRef)
+              debug('got NBD info', { nbdInfo, vdi: id, path })
+              nbdClient = new NbdClient(nbdInfo)
+              await nbdClient.connect()
+              info('NBD client ready', { vdi: id, path })
+            } catch (error) {
+              nbdClient = undefined
+              warn('error connecting to NBD server', { error, vdi: id, path })
+            }
+          } else {
+            debug('useNbd is disabled', { vdi: id, path })
+          }
+
           transferSize += await adapter.writeVhd(path, deltaExport.streams[`${id}.vhd`], {
             // no checksum for VHDs, because they will be invalidated by
             // merges and chainings
             checksum: false,
             validator: tmpPath => checkVhd(handler, tmpPath),
             writeBlockConcurrency: this._backup.config.writeBlockConcurrency,
+            nbdClient,
           })
 
           if (isDelta) {
@@ -227,6 +248,3 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
     // TODO: run cleanup?
   }
 }
-exports.IncrementalRemoteWriter = decorateClass(IncrementalRemoteWriter, {
-  _transfer: defer,
-})

@xen-orchestra/backups/writers/DeltaReplicationWriter.js

@@ -4,16 +4,16 @@ const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
 const ignoreErrors = require('promise-toolbox/ignoreErrors')
 const { formatDateTime } = require('@xen-orchestra/xapi')
 
-const { formatFilenameDate } = require('../../_filenameDate.js')
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { importIncrementalVm, TAG_COPY_SRC } = require('../../_incrementalVm.js')
-const { Task } = require('../../Task.js')
+const { formatFilenameDate } = require('../_filenameDate.js')
+const { getOldEntries } = require('../_getOldEntries.js')
+const { importDeltaVm, TAG_COPY_SRC } = require('../_deltaVm.js')
+const { Task } = require('../Task.js')
 
-const { AbstractIncrementalWriter } = require('./_AbstractIncrementalWriter.js')
-const { MixinXapiWriter } = require('./_MixinXapiWriter.js')
+const { AbstractDeltaWriter } = require('./_AbstractDeltaWriter.js')
+const { MixinReplicationWriter } = require('./_MixinReplicationWriter.js')
 const { listReplicatedVms } = require('./_listReplicatedVms.js')
 
-exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
+exports.DeltaReplicationWriter = class DeltaReplicationWriter extends MixinReplicationWriter(AbstractDeltaWriter) {
   async checkBaseVdis(baseUuidToSrcVdi, baseVm) {
     const sr = this._sr
     const replicatedVm = listReplicatedVms(sr.$xapi, this._backup.job.id, sr.uuid, this._backup.vm.uuid).find(
@@ -45,13 +45,11 @@ exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWri
       data: {
         id: this._sr.uuid,
         isFull,
-        name_label: this._sr.name_label,
         type: 'SR',
       },
     })
     this.transfer = task.wrapFn(this.transfer)
-    this.cleanup = task.wrapFn(this.cleanup)
-    this.healthCheck = task.wrapFn(this.healthCheck, true)
+    this.cleanup = task.wrapFn(this.cleanup, true)
 
     return task.run(() => this._prepare())
   }
@@ -82,7 +80,6 @@ exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWri
   }
 
   async _transfer({ timestamp, deltaExport, sizeContainers }) {
-    const { _warmMigration } = this._settings
     const sr = this._sr
     const { job, scheduleId, vm } = this._backup
 
@@ -90,12 +87,12 @@ exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWri
 
     let targetVmRef
     await Task.run({ name: 'transfer' }, async () => {
-      targetVmRef = await importIncrementalVm(
+      targetVmRef = await importDeltaVm(
         {
           __proto__: deltaExport,
           vm: {
             ...deltaExport.vm,
-            tags: _warmMigration ? deltaExport.vm.tags : [...deltaExport.vm.tags, 'Continuous Replication'],
+            tags: [...deltaExport.vm.tags, 'Continuous Replication'],
           },
         },
         sr
@@ -104,13 +101,11 @@ exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWri
         size: Object.values(sizeContainers).reduce((sum, { size }) => sum + size, 0),
       }
     })
-    this._targetVmRef = targetVmRef
+
     const targetVm = await xapi.getRecord('VM', targetVmRef)
 
     await Promise.all([
-      // warm migration does not disable HA , since the goal is to start the new VM in production
-      !_warmMigration &&
-        targetVm.ha_restart_priority !== '' &&
+      targetVm.ha_restart_priority !== '' &&
         Promise.all([targetVm.set_ha_restart_priority(''), targetVm.add_tags('HA disabled')]),
       targetVm.set_name_label(`${vm.name_label} - ${job.name} - (${formatFilenameDate(timestamp)})`),
       asyncMap(['start', 'start_on'], op =>

@xen-orchestra/backups/writers/FullBackupWriter.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const { formatFilenameDate } = require('../../_filenameDate.js')
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { Task } = require('../../Task.js')
+const { formatFilenameDate } = require('../_filenameDate.js')
+const { getOldEntries } = require('../_getOldEntries.js')
+const { Task } = require('../Task.js')
 
-const { MixinRemoteWriter } = require('./_MixinRemoteWriter.js')
+const { MixinBackupWriter } = require('./_MixinBackupWriter.js')
 const { AbstractFullWriter } = require('./_AbstractFullWriter.js')
 
-exports.FullRemoteWriter = class FullRemoteWriter extends MixinRemoteWriter(AbstractFullWriter) {
+exports.FullBackupWriter = class FullBackupWriter extends MixinBackupWriter(AbstractFullWriter) {
   constructor(props) {
     super(props)
 

@xen-orchestra/backups/writers/FullReplicationWriter.js

@@ -4,15 +4,15 @@ const ignoreErrors = require('promise-toolbox/ignoreErrors')
 const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
 const { formatDateTime } = require('@xen-orchestra/xapi')
 
-const { formatFilenameDate } = require('../../_filenameDate.js')
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { Task } = require('../../Task.js')
+const { formatFilenameDate } = require('../_filenameDate.js')
+const { getOldEntries } = require('../_getOldEntries.js')
+const { Task } = require('../Task.js')
 
 const { AbstractFullWriter } = require('./_AbstractFullWriter.js')
-const { MixinXapiWriter } = require('./_MixinXapiWriter.js')
+const { MixinReplicationWriter } = require('./_MixinReplicationWriter.js')
 const { listReplicatedVms } = require('./_listReplicatedVms.js')
 
-exports.FullXapiWriter = class FullXapiWriter extends MixinXapiWriter(AbstractFullWriter) {
+exports.FullReplicationWriter = class FullReplicationWriter extends MixinReplicationWriter(AbstractFullWriter) {
   constructor(props) {
     super(props)
 
@@ -21,7 +21,6 @@ exports.FullXapiWriter = class FullXapiWriter extends MixinXapiWriter(AbstractFu
         name: 'export',
         data: {
           id: props.sr.uuid,
-          name_label: this._sr.name_label,
           type: 'SR',
 
           // necessary?
@@ -47,7 +46,7 @@ exports.FullXapiWriter = class FullXapiWriter extends MixinXapiWriter(AbstractFu
     const oldVms = getOldEntries(settings.copyRetention - 1, listReplicatedVms(xapi, scheduleId, srUuid, vm.uuid))
 
     const deleteOldBackups = () => asyncMapSettled(oldVms, vm => xapi.VM_destroy(vm.$ref))
-    const { deleteFirst, _warmMigration } = settings
+    const { deleteFirst } = settings
     if (deleteFirst) {
       await deleteOldBackups()
     }
@@ -56,18 +55,14 @@ exports.FullXapiWriter = class FullXapiWriter extends MixinXapiWriter(AbstractFu
     await Task.run({ name: 'transfer' }, async () => {
       targetVmRef = await xapi.VM_import(stream, sr.$ref, vm =>
         Promise.all([
-          !_warmMigration && vm.add_tags('Disaster Recovery'),
-          // warm migration does not disable HA , since the goal is to start the new VM in production
-          !_warmMigration &&
-            vm.ha_restart_priority !== '' &&
-            Promise.all([vm.set_ha_restart_priority(''), vm.add_tags('HA disabled')]),
+          vm.add_tags('Disaster Recovery'),
+          vm.ha_restart_priority !== '' && Promise.all([vm.set_ha_restart_priority(''), vm.add_tags('HA disabled')]),
           vm.set_name_label(`${vm.name_label} - ${job.name} - (${formatFilenameDate(timestamp)})`),
         ])
       )
       return { size: sizeContainer.size }
     })
 
-    this._targetVmRef = targetVmRef
     const targetVm = await xapi.getRecord('VM', targetVmRef)
 
     await Promise.all([

@xen-orchestra/backups/writers/_AbstractDeltaWriter.js

@@ -2,7 +2,7 @@
 
 const { AbstractWriter } = require('./_AbstractWriter.js')
 
-exports.AbstractIncrementalWriter = class AbstractIncrementalWriter extends AbstractWriter {
+exports.AbstractDeltaWriter = class AbstractDeltaWriter extends AbstractWriter {
   checkBaseVdis(baseUuidToSrcVdi, baseVm) {
     throw new Error('Not implemented')
   }

@xen-orchestra/backups/writers/_MixinBackupWriter.js

@@ -4,17 +4,17 @@ const { createLogger } = require('@xen-orchestra/log')
 const { join } = require('path')
 
 const assert = require('assert')
-const { formatFilenameDate } = require('../../_filenameDate.js')
-const { getVmBackupDir } = require('../../_getVmBackupDir.js')
-const { HealthCheckVmBackup } = require('../../HealthCheckVmBackup.js')
-const { ImportVmBackup } = require('../../ImportVmBackup.js')
-const { Task } = require('../../Task.js')
-const MergeWorker = require('../../merge-worker/index.js')
+const { formatFilenameDate } = require('../_filenameDate.js')
+const { getVmBackupDir } = require('../_getVmBackupDir.js')
+const { HealthCheckVmBackup } = require('../HealthCheckVmBackup.js')
+const { ImportVmBackup } = require('../ImportVmBackup.js')
+const { Task } = require('../Task.js')
+const MergeWorker = require('../merge-worker/index.js')
 
 const { info, warn } = createLogger('xo:backups:MixinBackupWriter')
 
-exports.MixinRemoteWriter = (BaseClass = Object) =>
-  class MixinRemoteWriter extends BaseClass {
+exports.MixinBackupWriter = (BaseClass = Object) =>
+  class MixinBackupWriter extends BaseClass {
     #lock
 
     constructor({ remoteId, ...rest }) {
@@ -58,7 +58,7 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
       const { disableMergeWorker } = this._backup.config
       // merge worker only compatible with local remotes
       const { handler } = this._adapter
-      const willMergeInWorker = !disableMergeWorker && typeof handler.getRealPath === 'function'
+      const willMergeInWorker = !disableMergeWorker && typeof handler._getRealPath === 'function'
 
       const { merge } = await this._cleanVm({ remove: true, merge: !willMergeInWorker })
       await this.#lock.dispose()
@@ -71,7 +71,7 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
           Math.random().toString(36).slice(2)
 
         await handler.outputFile(taskFile, this._backup.vm.uuid)
-        const remotePath = handler.getRealPath()
+        const remotePath = handler._getRealPath()
         await MergeWorker.run(remotePath)
       }
     }
@@ -80,7 +80,7 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
       assert.notStrictEqual(
         this._metadataFileName,
         undefined,
-        'Metadata file name should be defined before making a health check'
+        'Metadata file name should be defined before making a healthcheck'
       )
       return Task.run(
         {

@xen-orchestra/backups/writers/_MixinReplicationWriter.js

@@ -0,0 +1,10 @@
+'use strict'
+
+exports.MixinReplicationWriter = (BaseClass = Object) =>
+  class MixinReplicationWriter extends BaseClass {
+    constructor({ sr, ...rest }) {
+      super(rest)
+
+      this._sr = sr
+    }
+  }

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

@@ -18,7 +18,7 @@
   "preferGlobal": true,
   "dependencies": {
     "golike-defer": "^0.5.1",
-    "xen-api": "^1.3.1"
+    "xen-api": "^1.2.2"
   },
   "scripts": {
     "postversion": "npm publish"

@xen-orchestra/fs/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@xen-orchestra/fs",
-  "version": "4.0.0",
+  "version": "3.3.1",
   "license": "AGPL-3.0-or-later",
   "description": "The File System for Xen Orchestra backups.",
   "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/fs",
@@ -20,7 +20,6 @@
     "node": ">=14.13"
   },
   "dependencies": {
-    "@aws-sdk/abort-controller": "^3.272.0",
     "@aws-sdk/client-s3": "^3.54.0",
     "@aws-sdk/lib-storage": "^3.54.0",
     "@aws-sdk/middleware-apply-body-checksum": "^3.58.0",
@@ -29,7 +28,7 @@
     "@vates/async-each": "^1.0.0",
     "@vates/coalesce-calls": "^0.1.0",
     "@vates/decorate-with": "^2.0.0",
-    "@vates/read-chunk": "^1.1.1",
+    "@vates/read-chunk": "^1.0.1",
     "@xen-orchestra/async-map": "^0.1.2",
     "@xen-orchestra/log": "^0.6.0",
     "bind-property-descriptor": "^2.0.0",
@@ -51,11 +50,10 @@
     "@babel/plugin-proposal-decorators": "^7.1.6",
     "@babel/plugin-proposal-function-bind": "^7.0.0",
     "@babel/preset-env": "^7.8.0",
+    "babel-plugin-lodash": "^3.3.2",
     "cross-env": "^7.0.2",
     "dotenv": "^16.0.0",
-    "rimraf": "^5.0.1",
-    "sinon": "^15.0.4",
-    "test": "^3.3.0",
+    "rimraf": "^4.1.1",
     "tmp": "^0.2.1"
   },
   "scripts": {
@@ -65,9 +63,7 @@
     "prebuild": "yarn run clean",
     "predev": "yarn run clean",
     "prepublishOnly": "yarn run build",
-    "pretest": "yarn run build",
-    "postversion": "npm publish",
-    "test": "node--test ./dist/"
+    "postversion": "npm publish"
   },
   "author": {
     "name": "Vates SAS",

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

@@ -1,5 +1,4 @@
-import { describe, it } from 'test'
-import { strict as assert } from 'assert'
+/* eslint-env jest */
 
 import { Readable } from 'readable-stream'
 import copyStreamToBuffer from './_copyStreamToBuffer.js'
@@ -17,6 +16,6 @@ describe('copyStreamToBuffer', () => {
 
     await copyStreamToBuffer(stream, buffer)
 
-    assert.equal(buffer.toString(), 'hel')
+    expect(buffer.toString()).toBe('hel')
   })
 })

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

@@ -1,5 +1,4 @@
-import { describe, it } from 'test'
-import { strict as assert } from 'assert'
+/* eslint-env jest */
 
 import { Readable } from 'readable-stream'
 import createBufferFromStream from './_createBufferFromStream.js'
@@ -15,6 +14,6 @@ describe('createBufferFromStream', () => {
 
     const buffer = await createBufferFromStream(stream)
 
-    assert.equal(buffer.toString(), 'hello')
+    expect(buffer.toString()).toBe('hello')
   })
 })

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

@@ -1,6 +1,4 @@
-import { describe, it } from 'test'
-import { strict as assert } from 'assert'
-
+/* eslint-env jest */
 import { Readable } from 'node:stream'
 import { _getEncryptor } from './_encryptor'
 import crypto from 'crypto'
@@ -27,13 +25,13 @@ algorithms.forEach(algorithm => {
     it('handle buffer', () => {
       const encrypted = encryptor.encryptData(buffer)
       if (algorithm !== 'none') {
-        assert.equal(encrypted.equals(buffer), false) // encrypted should be different
+        expect(encrypted.equals(buffer)).toEqual(false) // encrypted should be different
         // ivlength, auth tag, padding
-        assert.notEqual(encrypted.length, buffer.length)
+        expect(encrypted.length).not.toEqual(buffer.length)
       }
 
       const decrypted = encryptor.decryptData(encrypted)
-      assert.equal(decrypted.equals(buffer), true)
+      expect(decrypted.equals(buffer)).toEqual(true)
     })
 
     it('handle stream', async () => {
@@ -41,12 +39,12 @@ algorithms.forEach(algorithm => {
       stream.length = buffer.length
       const encrypted = encryptor.encryptStream(stream)
       if (algorithm !== 'none') {
-        assert.equal(encrypted.length, undefined)
+        expect(encrypted.length).toEqual(undefined)
       }
 
       const decrypted = encryptor.decryptStream(encrypted)
       const decryptedBuffer = await streamToBuffer(decrypted)
-      assert.equal(decryptedBuffer.equals(buffer), true)
+      expect(decryptedBuffer.equals(buffer)).toEqual(true)
     })
   })
 })

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

@@ -1,5 +1,4 @@
-import { describe, it } from 'test'
-import { strict as assert } from 'assert'
+/* eslint-env jest */
 
 import guessAwsRegion from './_guessAwsRegion.js'
 
@@ -7,12 +6,12 @@ describe('guessAwsRegion', () => {
   it('should return region from AWS URL', async () => {
     const region = guessAwsRegion('s3.test-region.amazonaws.com')
 
-    assert.equal(region, 'test-region')
+    expect(region).toBe('test-region')
   })
 
   it('should return default region if none is found is AWS URL', async () => {
     const region = guessAwsRegion('s3.amazonaws.com')
 
-    assert.equal(region, 'us-east-1')
+    expect(region).toBe('us-east-1')
   })
 })

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

@@ -9,32 +9,28 @@ import LocalHandler from './local'
 const sudoExeca = (command, args, opts) => execa('sudo', [command, ...args], opts)
 
 export default class MountHandler extends LocalHandler {
-  #execa
-  #keeper
-  #params
-  #realPath
-
   constructor(remote, { mountsDir = join(tmpdir(), 'xo-fs-mounts'), useSudo = false, ...opts } = {}, params) {
     super(remote, opts)
 
-    this.#execa = useSudo ? sudoExeca : execa
-    this.#params = {
+    this._execa = useSudo ? sudoExeca : execa
+    this._keeper = undefined
+    this._params = {
       ...params,
       options: [params.options, remote.options ?? params.defaultOptions].filter(_ => _ !== undefined).join(','),
     }
-    this.#realPath = join(mountsDir, remote.id || Math.random().toString(36).slice(2))
+    this._realPath = join(mountsDir, remote.id || Math.random().toString(36).slice(2))
   }
 
   async _forget() {
-    const keeper = this.#keeper
+    const keeper = this._keeper
     if (keeper === undefined) {
       return
     }
-    this.#keeper = undefined
+    this._keeper = undefined
     await fs.close(keeper)
 
     await ignoreErrors.call(
-      this.#execa('umount', [this.getRealPath()], {
+      this._execa('umount', [this._getRealPath()], {
         env: {
           LANG: 'C',
         },
@@ -42,30 +38,30 @@ export default class MountHandler extends LocalHandler {
     )
   }
 
-  getRealPath() {
-    return this.#realPath
+  _getRealPath() {
+    return this._realPath
   }
 
   async _sync() {
     // in case of multiple `sync`s, ensure we properly close previous keeper
     {
-      const keeper = this.#keeper
+      const keeper = this._keeper
       if (keeper !== undefined) {
-        this.#keeper = undefined
+        this._keeper = undefined
         ignoreErrors.call(fs.close(keeper))
       }
     }
 
-    const realPath = this.getRealPath()
+    const realPath = this._getRealPath()
 
     await fs.ensureDir(realPath)
 
     try {
-      const { type, device, options, env } = this.#params
+      const { type, device, options, env } = this._params
 
       // Linux mount is more flexible in which order the mount arguments appear.
       // But FreeBSD requires this order of the arguments.
-      await this.#execa('mount', ['-o', options, '-t', type, device, realPath], {
+      await this._execa('mount', ['-o', options, '-t', type, device, realPath], {
         env: {
           LANG: 'C',
           ...env,
@@ -75,7 +71,7 @@ export default class MountHandler extends LocalHandler {
       try {
         // the failure may mean it's already mounted, use `findmnt` to check
         // that's the case
-        await this.#execa('findmnt', [realPath], {
+        await this._execa('findmnt', [realPath], {
           stdio: 'ignore',
         })
       } catch (_) {
@@ -86,7 +82,7 @@ export default class MountHandler extends LocalHandler {
     // keep an open file on the mount to prevent it from being unmounted if used
     // by another handler/process
     const keeperPath = `${realPath}/.keeper_${Math.random().toString(36).slice(2)}`
-    this.#keeper = await fs.open(keeperPath, 'w')
+    this._keeper = await fs.open(keeperPath, 'w')
     ignoreErrors.call(fs.unlink(keeperPath))
   }
 }

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

@@ -37,13 +37,8 @@ const ignoreEnoent = error => {
 const noop = Function.prototype
 
 class PrefixWrapper {
-  #prefix
-
   constructor(handler, prefix) {
-    this.#prefix = prefix
-
-    // cannot be a private field because used by methods dynamically added
-    // outside of the class
+    this._prefix = prefix
     this._handler = handler
   }
 
@@ -55,7 +50,7 @@ class PrefixWrapper {
   async list(dir, opts) {
     const entries = await this._handler.list(this._resolve(dir), opts)
     if (opts != null && opts.prependDir) {
-      const n = this.#prefix.length
+      const n = this._prefix.length
       entries.forEach((entry, i, entries) => {
         entries[i] = entry.slice(n)
       })
@@ -67,21 +62,19 @@ class PrefixWrapper {
     return this._handler.rename(this._resolve(oldPath), this._resolve(newPath))
   }
 
-  // cannot be a private method because used by methods dynamically added
-  // outside of the class
   _resolve(path) {
-    return this.#prefix + normalizePath(path)
+    return this._prefix + normalizePath(path)
   }
 }
 
 export default class RemoteHandlerAbstract {
-  #rawEncryptor
+  #encryptor
 
-  get #encryptor() {
-    if (this.#rawEncryptor === undefined) {
+  get _encryptor() {
+    if (this.#encryptor === undefined) {
       throw new Error(`Can't access to encryptor before remote synchronization`)
     }
-    return this.#rawEncryptor
+    return this.#encryptor
   }
 
   constructor(remote, options = {}) {
@@ -118,10 +111,6 @@ export default class RemoteHandlerAbstract {
   }
 
   // Public members
-  //
-  // Should not be called directly because:
-  // - some concurrency limits may be applied which may lead to deadlocks
-  // - some preprocessing may be applied on parameters that should not be done multiple times (e.g. prefixing paths)
 
   get type() {
     throw new Error('Not implemented')
@@ -132,6 +121,10 @@ export default class RemoteHandlerAbstract {
     return prefix === '/' ? this : new PrefixWrapper(this, prefix)
   }
 
+  async closeFile(fd) {
+    await this.__closeFile(fd)
+  }
+
   async createReadStream(file, { checksum = false, ignoreMissingChecksum = false, ...options } = {}) {
     if (options.end !== undefined || options.start !== undefined) {
       assert.strictEqual(this.isEncrypted, false, `Can't read part of a file when encryption is active ${file}`)
@@ -164,7 +157,7 @@ export default class RemoteHandlerAbstract {
     }
 
     if (this.isEncrypted) {
-      stream = this.#encryptor.decryptStream(stream)
+      stream = this._encryptor.decryptStream(stream)
     } else {
       // try to add the length prop if missing and not a range stream
       if (stream.length === undefined && options.end === undefined && options.start === undefined) {
@@ -193,7 +186,7 @@ export default class RemoteHandlerAbstract {
     path = normalizePath(path)
     let checksumStream
 
-    input = this.#encryptor.encryptStream(input)
+    input = this._encryptor.encryptStream(input)
     if (checksum) {
       checksumStream = createChecksumStream()
       pipeline(input, checksumStream, noop)
@@ -231,10 +224,10 @@ export default class RemoteHandlerAbstract {
     assert.strictEqual(this.isEncrypted, false, `Can't compute size of an encrypted file ${file}`)
 
     const size = await timeout.call(this._getSize(typeof file === 'string' ? normalizePath(file) : file), this._timeout)
-    return size - this.#encryptor.ivLength
+    return size - this._encryptor.ivLength
   }
 
-  async __list(dir, { filter, ignoreMissing = false, prependDir = false } = {}) {
+  async list(dir, { filter, ignoreMissing = false, prependDir = false } = {}) {
     try {
       const virtualDir = normalizePath(dir)
       dir = normalizePath(dir)
@@ -264,12 +257,20 @@ export default class RemoteHandlerAbstract {
     return { dispose: await this._lock(path) }
   }
 
+  async mkdir(dir, { mode } = {}) {
+    await this.__mkdir(normalizePath(dir), { mode })
+  }
+
   async mktree(dir, { mode } = {}) {
     await this._mktree(normalizePath(dir), { mode })
   }
 
+  openFile(path, flags) {
+    return this.__openFile(path, flags)
+  }
+
   async outputFile(file, data, { dirMode, flags = 'wx' } = {}) {
-    const encryptedData = this.#encryptor.encryptData(data)
+    const encryptedData = this._encryptor.encryptData(data)
     await this._outputFile(normalizePath(file), encryptedData, { dirMode, flags })
   }
 
@@ -278,9 +279,9 @@ export default class RemoteHandlerAbstract {
     return this._read(typeof file === 'string' ? normalizePath(file) : file, buffer, position)
   }
 
-  async __readFile(file, { flags = 'r' } = {}) {
+  async readFile(file, { flags = 'r' } = {}) {
     const data = await this._readFile(normalizePath(file), { flags })
-    return this.#encryptor.decryptData(data)
+    return this._encryptor.decryptData(data)
   }
 
   async #rename(oldPath, newPath, { checksum }, createTree = true) {
@@ -300,11 +301,11 @@ export default class RemoteHandlerAbstract {
     }
   }
 
-  __rename(oldPath, newPath, { checksum = false } = {}) {
+  rename(oldPath, newPath, { checksum = false } = {}) {
     return this.#rename(normalizePath(oldPath), normalizePath(newPath), { checksum })
   }
 
-  async __copy(oldPath, newPath, { checksum = false } = {}) {
+  async copy(oldPath, newPath, { checksum = false } = {}) {
     oldPath = normalizePath(oldPath)
     newPath = normalizePath(newPath)
 
@@ -331,33 +332,33 @@ export default class RemoteHandlerAbstract {
   async sync() {
     await this._sync()
     try {
-      await this.#checkMetadata()
+      await this._checkMetadata()
     } catch (error) {
       await this._forget()
       throw error
     }
   }
 
-  async #canWriteMetadata() {
-    const list = await this.__list('/', {
+  async _canWriteMetadata() {
+    const list = await this.list('/', {
       filter: e => !e.startsWith('.') && e !== ENCRYPTION_DESC_FILENAME && e !== ENCRYPTION_METADATA_FILENAME,
     })
     return list.length === 0
   }
 
-  async #createMetadata() {
+  async _createMetadata() {
     const encryptionAlgorithm = this._remote.encryptionKey === undefined ? 'none' : DEFAULT_ENCRYPTION_ALGORITHM
-    this.#rawEncryptor = _getEncryptor(encryptionAlgorithm, this._remote.encryptionKey)
+    this.#encryptor = _getEncryptor(encryptionAlgorithm, this._remote.encryptionKey)
 
     await Promise.all([
       this._writeFile(normalizePath(ENCRYPTION_DESC_FILENAME), JSON.stringify({ algorithm: encryptionAlgorithm }), {
         flags: 'w',
       }), // not encrypted
-      this.__writeFile(ENCRYPTION_METADATA_FILENAME, `{"random":"${randomUUID()}"}`, { flags: 'w' }), // encrypted
+      this.writeFile(ENCRYPTION_METADATA_FILENAME, `{"random":"${randomUUID()}"}`, { flags: 'w' }), // encrypted
     ])
   }
 
-  async #checkMetadata() {
+  async _checkMetadata() {
     let encryptionAlgorithm = 'none'
     let data
     try {
@@ -373,18 +374,18 @@ export default class RemoteHandlerAbstract {
     }
 
     try {
-      this.#rawEncryptor = _getEncryptor(encryptionAlgorithm, this._remote.encryptionKey)
+      this.#encryptor = _getEncryptor(encryptionAlgorithm, this._remote.encryptionKey)
       // this file is encrypted
-      const data = await this.__readFile(ENCRYPTION_METADATA_FILENAME, 'utf-8')
+      const data = await this.readFile(ENCRYPTION_METADATA_FILENAME, 'utf-8')
       JSON.parse(data)
     } catch (error) {
       // can be enoent, bad algorithm, or broeken json ( bad key or algorithm)
       if (encryptionAlgorithm !== 'none') {
-        if (await this.#canWriteMetadata()) {
+        if (await this._canWriteMetadata()) {
           // any other error , but on empty remote => update with remote settings
 
           info('will update metadata of this remote')
-          return this.#createMetadata()
+          return this._createMetadata()
         } else {
           warn(
             `The encryptionKey settings of this remote does not match the key used to create it. You won't be able to read any data from this remote`,
@@ -437,7 +438,7 @@ export default class RemoteHandlerAbstract {
     await this._truncate(file, len)
   }
 
-  async __unlink(file, { checksum = true } = {}) {
+  async unlink(file, { checksum = true } = {}) {
     file = normalizePath(file)
 
     if (checksum) {
@@ -452,8 +453,8 @@ export default class RemoteHandlerAbstract {
     await this._write(typeof file === 'string' ? normalizePath(file) : file, buffer, position)
   }
 
-  async __writeFile(file, data, { flags = 'wx' } = {}) {
-    const encryptedData = this.#encryptor.encryptData(data)
+  async writeFile(file, data, { flags = 'wx' } = {}) {
+    const encryptedData = this._encryptor.encryptData(data)
     await this._writeFile(normalizePath(file), encryptedData, { flags })
   }
 
@@ -464,8 +465,6 @@ export default class RemoteHandlerAbstract {
   }
 
   async __mkdir(dir, { mode } = {}) {
-    dir = normalizePath(dir)
-
     try {
       await this._mkdir(dir, { mode })
     } catch (error) {
@@ -587,9 +586,9 @@ export default class RemoteHandlerAbstract {
       if (validator !== undefined) {
         await validator.call(this, tmpPath)
       }
-      await this.__rename(tmpPath, path)
+      await this.rename(tmpPath, path)
     } catch (error) {
-      await this.__unlink(tmpPath)
+      await this.unlink(tmpPath)
       throw error
     }
   }
@@ -666,22 +665,7 @@ export default class RemoteHandlerAbstract {
   }
 
   get isEncrypted() {
-    return this.#encryptor.id !== 'NULL_ENCRYPTOR'
-  }
-}
-
-// from implementation methods, which names start with `__`, create public
-// accessors on which external behaviors can be added (e.g. concurrency limits, path rewriting)
-{
-  const proto = RemoteHandlerAbstract.prototype
-  for (const method of Object.getOwnPropertyNames(proto)) {
-    if (method.startsWith('__')) {
-      const publicName = method.slice(2)
-
-      assert(!Object.hasOwn(proto, publicName))
-
-      Object.defineProperty(proto, publicName, Object.getOwnPropertyDescriptor(proto, method))
-    }
+    return this._encryptor.id !== 'NULL_ENCRYPTOR'
   }
 }
 

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

@@ -1,13 +1,11 @@
-import { after, beforeEach, describe, it } from 'test'
-import { strict as assert } from 'assert'
-import sinon from 'sinon'
+/* eslint-env jest */
 
 import { DEFAULT_ENCRYPTION_ALGORITHM, _getEncryptor } from './_encryptor'
 import { Disposable, pFromCallback, TimeoutError } from 'promise-toolbox'
 import { getSyncedHandler } from '.'
-import { rimraf } from 'rimraf'
 import AbstractHandler from './abstract'
 import fs from 'fs-extra'
+import rimraf from 'rimraf'
 import tmp from 'tmp'
 
 const TIMEOUT = 10e3
@@ -26,7 +24,7 @@ class TestHandler extends AbstractHandler {
 
 const noop = Function.prototype
 
-const clock = sinon.useFakeTimers()
+jest.useFakeTimers()
 
 describe('closeFile()', () => {
   it(`throws in case of timeout`, async () => {
@@ -35,8 +33,8 @@ describe('closeFile()', () => {
     })
 
     const promise = testHandler.closeFile({ fd: undefined, path: '' })
-    clock.tick(TIMEOUT)
-    await assert.rejects(promise, TimeoutError)
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
   })
 })
 
@@ -47,8 +45,8 @@ describe('getInfo()', () => {
     })
 
     const promise = testHandler.getInfo()
-    clock.tick(TIMEOUT)
-    await assert.rejects(promise, TimeoutError)
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
   })
 })
 
@@ -59,8 +57,8 @@ describe('getSize()', () => {
     })
 
     const promise = testHandler.getSize('')
-    clock.tick(TIMEOUT)
-    await assert.rejects(promise, TimeoutError)
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
   })
 })
 
@@ -71,8 +69,8 @@ describe('list()', () => {
     })
 
     const promise = testHandler.list('.')
-    clock.tick(TIMEOUT)
-    await assert.rejects(promise, TimeoutError)
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
   })
 })
 
@@ -83,8 +81,8 @@ describe('openFile()', () => {
     })
 
     const promise = testHandler.openFile('path')
-    clock.tick(TIMEOUT)
-    await assert.rejects(promise, TimeoutError)
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
   })
 })
 
@@ -95,8 +93,8 @@ describe('rename()', () => {
     })
 
     const promise = testHandler.rename('oldPath', 'newPath')
-    clock.tick(TIMEOUT)
-    await assert.rejects(promise, TimeoutError)
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
   })
 })
 
@@ -107,8 +105,8 @@ describe('rmdir()', () => {
     })
 
     const promise = testHandler.rmdir('dir')
-    clock.tick(TIMEOUT)
-    await assert.rejects(promise, TimeoutError)
+    jest.advanceTimersByTime(TIMEOUT)
+    await expect(promise).rejects.toThrowError(TimeoutError)
   })
 })
 
@@ -117,14 +115,14 @@ describe('encryption', () => {
   beforeEach(async () => {
     dir = await pFromCallback(cb => tmp.dir(cb))
   })
-  after(async () => {
+  afterAll(async () => {
     await rimraf(dir)
   })
 
   it('sync should NOT create metadata if missing (not encrypted)', async () => {
     await Disposable.use(getSyncedHandler({ url: `file://${dir}` }), noop)
 
-    assert.deepEqual(await fs.readdir(dir), [])
+    expect(await fs.readdir(dir)).toEqual([])
   })
 
   it('sync should create metadata if missing (encrypted)', async () => {
@@ -133,12 +131,12 @@ describe('encryption', () => {
       noop
     )
 
-    assert.deepEqual(await fs.readdir(dir), ['encryption.json', 'metadata.json'])
+    expect(await fs.readdir(dir)).toEqual(['encryption.json', 'metadata.json'])
 
     const encryption = JSON.parse(await fs.readFile(`${dir}/encryption.json`, 'utf-8'))
-    assert.equal(encryption.algorithm, DEFAULT_ENCRYPTION_ALGORITHM)
+    expect(encryption.algorithm).toEqual(DEFAULT_ENCRYPTION_ALGORITHM)
     // encrypted , should not be parsable
-    assert.rejects(async () => JSON.parse(await fs.readFile(`${dir}/metadata.json`)))
+    expect(async () => JSON.parse(await fs.readFile(`${dir}/metadata.json`))).rejects.toThrowError()
   })
 
   it('sync should not modify existing metadata', async () => {
@@ -148,9 +146,9 @@ describe('encryption', () => {
     await Disposable.use(await getSyncedHandler({ url: `file://${dir}` }), noop)
 
     const encryption = JSON.parse(await fs.readFile(`${dir}/encryption.json`, 'utf-8'))
-    assert.equal(encryption.algorithm, 'none')
+    expect(encryption.algorithm).toEqual('none')
     const metadata = JSON.parse(await fs.readFile(`${dir}/metadata.json`, 'utf-8'))
-    assert.equal(metadata.random, 'NOTSORANDOM')
+    expect(metadata.random).toEqual('NOTSORANDOM')
   })
 
   it('should modify metadata if empty', async () => {
@@ -162,11 +160,11 @@ describe('encryption', () => {
       noop
     )
     let encryption = JSON.parse(await fs.readFile(`${dir}/encryption.json`, 'utf-8'))
-    assert.equal(encryption.algorithm, DEFAULT_ENCRYPTION_ALGORITHM)
+    expect(encryption.algorithm).toEqual(DEFAULT_ENCRYPTION_ALGORITHM)
 
     await Disposable.use(getSyncedHandler({ url: `file://${dir}` }), noop)
     encryption = JSON.parse(await fs.readFile(`${dir}/encryption.json`, 'utf-8'))
-    assert.equal(encryption.algorithm, 'none')
+    expect(encryption.algorithm).toEqual('none')
   })
 
   it(
@@ -180,9 +178,9 @@ describe('encryption', () => {
       const handler = yield getSyncedHandler({ url: `file://${dir}?encryptionKey="73c1838d7d8a6088ca2317fb5f29cd91"` })
 
       const encryption = JSON.parse(await fs.readFile(`${dir}/encryption.json`, 'utf-8'))
-      assert.equal(encryption.algorithm, DEFAULT_ENCRYPTION_ALGORITHM)
+      expect(encryption.algorithm).toEqual(DEFAULT_ENCRYPTION_ALGORITHM)
       const metadata = JSON.parse(await handler.readFile(`./metadata.json`))
-      assert.equal(metadata.random, 'NOTSORANDOM')
+      expect(metadata.random).toEqual('NOTSORANDOM')
     })
   )
 
@@ -200,9 +198,9 @@ describe('encryption', () => {
 
     // remote is now non empty : can't modify key anymore
     await fs.writeFile(`${dir}/nonempty.json`, 'content')
-    await assert.rejects(
+    await expect(
       Disposable.use(getSyncedHandler({ url: `file://${dir}?encryptionKey="73c1838d7d8a6088ca2317fb5f29cd10"` }), noop)
-    )
+    ).rejects.toThrowError()
   })
 
   it('sync should fail when changing algorithm', async () => {
@@ -215,8 +213,8 @@ describe('encryption', () => {
     // remote is now non empty : can't modify key anymore
     await fs.writeFile(`${dir}/nonempty.json`, 'content')
 
-    await assert.rejects(
+    await expect(
       Disposable.use(getSyncedHandler({ url: `file://${dir}?encryptionKey="73c1838d7d8a6088ca2317fb5f29cd91"` }), noop)
-    )
+    ).rejects.toThrowError()
   })
 })

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

@@ -1,7 +1,7 @@
 import through2 from 'through2'
 import { createHash } from 'crypto'
 import { defer, fromEvent } from 'promise-toolbox'
-import invert from 'lodash/invert.js'
+import { invert } from 'lodash'
 
 // Format: $<algorithm>$<salt>$<encrypted>
 //

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

@@ -1,5 +1,4 @@
-import { after, afterEach, before, beforeEach, describe, it } from 'test'
-import { strict as assert } from 'assert'
+/* eslint-env jest */
 
 import 'dotenv/config'
 import { forOwn, random } from 'lodash'
@@ -54,11 +53,11 @@ handlers.forEach(url => {
       })
     }
 
-    before(async () => {
+    beforeAll(async () => {
       handler = getHandler({ url }).addPrefix(`xo-fs-tests-${Date.now()}`)
       await handler.sync()
     })
-    after(async () => {
+    afterAll(async () => {
       await handler.forget()
       handler = undefined
     })
@@ -73,63 +72,67 @@ handlers.forEach(url => {
 
     describe('#type', () => {
       it('returns the type of the remote', () => {
-        assert.equal(typeof handler.type, 'string')
+        expect(typeof handler.type).toBe('string')
       })
     })
 
     describe('#getInfo()', () => {
       let info
-      before(async () => {
+      beforeAll(async () => {
         info = await handler.getInfo()
       })
 
       it('should return an object with info', async () => {
-        assert.equal(typeof info, 'object')
+        expect(typeof info).toBe('object')
       })
 
       it('should return correct type of attribute', async () => {
         if (info.size !== undefined) {
-          assert.equal(typeof info.size, 'number')
+          expect(typeof info.size).toBe('number')
         }
         if (info.used !== undefined) {
-          assert.equal(typeof info.used, 'number')
+          expect(typeof info.used).toBe('number')
         }
       })
     })
 
     describe('#getSize()', () => {
-      before(() => handler.outputFile('file', TEST_DATA))
+      beforeEach(() => handler.outputFile('file', TEST_DATA))
 
       testWithFileDescriptor('file', 'r', async () => {
-        assert.equal(await handler.getSize('file'), TEST_DATA_LEN)
+        expect(await handler.getSize('file')).toEqual(TEST_DATA_LEN)
       })
     })
 
     describe('#list()', () => {
       it(`should list the content of folder`, async () => {
         await handler.outputFile('file', TEST_DATA)
-        assert.deepEqual(await handler.list('.'), ['file'])
+        await expect(await handler.list('.')).toEqual(['file'])
       })
 
       it('can prepend the directory to entries', async () => {
         await handler.outputFile('dir/file', '')
-        assert.deepEqual(await handler.list('dir', { prependDir: true }), ['/dir/file'])
+        expect(await handler.list('dir', { prependDir: true })).toEqual(['/dir/file'])
+      })
+
+      it('can prepend the directory to entries', async () => {
+        await handler.outputFile('dir/file', '')
+        expect(await handler.list('dir', { prependDir: true })).toEqual(['/dir/file'])
       })
 
       it('throws ENOENT if no such directory', async () => {
-        await handler.rmtree('dir')
-        assert.equal((await rejectionOf(handler.list('dir'))).code, 'ENOENT')
+        expect((await rejectionOf(handler.list('dir'))).code).toBe('ENOENT')
       })
 
       it('can returns empty for missing directory', async () => {
-        assert.deepEqual(await handler.list('dir', { ignoreMissing: true }), [])
+        expect(await handler.list('dir', { ignoreMissing: true })).toEqual([])
       })
     })
 
     describe('#mkdir()', () => {
       it('creates a directory', async () => {
         await handler.mkdir('dir')
-        assert.deepEqual(await handler.list('.'), ['dir'])
+        await expect(await handler.list('.')).toEqual(['dir'])
       })
 
       it('does not throw on existing directory', async () => {
@@ -140,15 +143,15 @@ handlers.forEach(url => {
       it('throws ENOTDIR on existing file', async () => {
         await handler.outputFile('file', '')
         const error = await rejectionOf(handler.mkdir('file'))
-        assert.equal(error.code, 'ENOTDIR')
+        expect(error.code).toBe('ENOTDIR')
       })
     })
 
     describe('#mktree()', () => {
       it('creates a tree of directories', async () => {
         await handler.mktree('dir/dir')
-        assert.deepEqual(await handler.list('.'), ['dir'])
-        assert.deepEqual(await handler.list('dir'), ['dir'])
+        await expect(await handler.list('.')).toEqual(['dir'])
+        await expect(await handler.list('dir')).toEqual(['dir'])
       })
 
       it('does not throw on existing directory', async () => {
@@ -159,27 +162,26 @@ handlers.forEach(url => {
       it('throws ENOTDIR on existing file', async () => {
         await handler.outputFile('dir/file', '')
         const error = await rejectionOf(handler.mktree('dir/file'))
-        assert.equal(error.code, 'ENOTDIR')
+        expect(error.code).toBe('ENOTDIR')
       })
 
       it('throws ENOTDIR on existing file in path', async () => {
         await handler.outputFile('file', '')
         const error = await rejectionOf(handler.mktree('file/dir'))
-        assert.equal(error.code, 'ENOTDIR')
+        expect(error.code).toBe('ENOTDIR')
       })
     })
 
     describe('#outputFile()', () => {
       it('writes data to a file', async () => {
         await handler.outputFile('file', TEST_DATA)
-        assert.deepEqual(await handler.readFile('file'), TEST_DATA)
+        expect(await handler.readFile('file')).toEqual(TEST_DATA)
       })
 
       it('throws on existing files', async () => {
-        await handler.unlink('file')
         await handler.outputFile('file', '')
         const error = await rejectionOf(handler.outputFile('file', ''))
-        assert.equal(error.code, 'EEXIST')
+        expect(error.code).toBe('EEXIST')
       })
 
       it("shouldn't timeout in case of the respect of the parallel execution restriction", async () => {
@@ -190,7 +192,7 @@ handlers.forEach(url => {
     })
 
     describe('#read()', () => {
-      before(() => handler.outputFile('file', TEST_DATA))
+      beforeEach(() => handler.outputFile('file', TEST_DATA))
 
       const start = random(TEST_DATA_LEN)
       const size = random(TEST_DATA_LEN)
@@ -198,8 +200,8 @@ handlers.forEach(url => {
       testWithFileDescriptor('file', 'r', async ({ file }) => {
         const buffer = Buffer.alloc(size)
         const result = await handler.read(file, buffer, start)
-        assert.deepEqual(result.buffer, buffer)
-        assert.deepEqual(result, {
+        expect(result.buffer).toBe(buffer)
+        expect(result).toEqual({
           buffer,
           bytesRead: Math.min(size, TEST_DATA_LEN - start),
         })
@@ -209,13 +211,12 @@ handlers.forEach(url => {
     describe('#readFile', () => {
       it('returns a buffer containing the contents of the file', async () => {
         await handler.outputFile('file', TEST_DATA)
-        assert.deepEqual(await handler.readFile('file'), TEST_DATA)
+        expect(await handler.readFile('file')).toEqual(TEST_DATA)
       })
 
       it('throws on missing file', async () => {
-        await handler.unlink('file')
         const error = await rejectionOf(handler.readFile('file'))
-        assert.equal(error.code, 'ENOENT')
+        expect(error.code).toBe('ENOENT')
       })
     })
 
@@ -224,19 +225,19 @@ handlers.forEach(url => {
         await handler.outputFile('file', TEST_DATA)
         await handler.rename('file', `file2`)
 
-        assert.deepEqual(await handler.list('.'), ['file2'])
-        assert.deepEqual(await handler.readFile(`file2`), TEST_DATA)
+        expect(await handler.list('.')).toEqual(['file2'])
+        expect(await handler.readFile(`file2`)).toEqual(TEST_DATA)
       })
       it(`should rename the file and create dest directory`, async () => {
         await handler.outputFile('file', TEST_DATA)
         await handler.rename('file', `sub/file2`)
 
-        assert.deepEqual(await handler.list('sub'), ['file2'])
-        assert.deepEqual(await handler.readFile(`sub/file2`), TEST_DATA)
+        expect(await handler.list('sub')).toEqual(['file2'])
+        expect(await handler.readFile(`sub/file2`)).toEqual(TEST_DATA)
       })
       it(`should fail with enoent if source file is missing`, async () => {
         const error = await rejectionOf(handler.rename('file', `sub/file2`))
-        assert.equal(error.code, 'ENOENT')
+        expect(error.code).toBe('ENOENT')
       })
     })
 
@@ -244,15 +245,14 @@ handlers.forEach(url => {
       it('should remove an empty directory', async () => {
         await handler.mkdir('dir')
         await handler.rmdir('dir')
-        assert.deepEqual(await handler.list('.'), [])
+        expect(await handler.list('.')).toEqual([])
       })
 
       it(`should throw on non-empty directory`, async () => {
         await handler.outputFile('dir/file', '')
 
         const error = await rejectionOf(handler.rmdir('.'))
-        assert.equal(error.code, 'ENOTEMPTY')
-        await handler.unlink('dir/file')
+        await expect(error.code).toEqual('ENOTEMPTY')
       })
 
       it('does not throw on missing directory', async () => {
@@ -265,7 +265,7 @@ handlers.forEach(url => {
         await handler.outputFile('dir/file', '')
         await handler.rmtree('dir')
 
-        assert.deepEqual(await handler.list('.'), [])
+        expect(await handler.list('.')).toEqual([])
       })
     })
 
@@ -273,9 +273,9 @@ handlers.forEach(url => {
       it('tests the remote appears to be working', async () => {
         const answer = await handler.test()
 
-        assert.equal(answer.success, true)
-        assert.equal(typeof answer.writeRate, 'number')
-        assert.equal(typeof answer.readRate, 'number')
+        expect(answer.success).toBe(true)
+        expect(typeof answer.writeRate).toBe('number')
+        expect(typeof answer.readRate).toBe('number')
       })
     })
 
@@ -284,7 +284,7 @@ handlers.forEach(url => {
         await handler.outputFile('file', TEST_DATA)
         await handler.unlink('file')
 
-        assert.deepEqual(await handler.list('.'), [])
+        await expect(await handler.list('.')).toEqual([])
       })
 
       it('does not throw on missing file', async () => {
@@ -294,7 +294,6 @@ handlers.forEach(url => {
 
     describe('#write()', () => {
       beforeEach(() => handler.outputFile('file', TEST_DATA))
-      afterEach(() => handler.unlink('file'))
 
       const PATCH_DATA_LEN = Math.ceil(TEST_DATA_LEN / 2)
       const PATCH_DATA = unsecureRandomBytes(PATCH_DATA_LEN)
@@ -323,7 +322,7 @@ handlers.forEach(url => {
           describe(title, () => {
             testWithFileDescriptor('file', 'r+', async ({ file }) => {
               await handler.write(file, PATCH_DATA, offset)
-              assert.deepEqual(await handler.readFile('file'), expected)
+              await expect(await handler.readFile('file')).toEqual(expected)
             })
           })
         }
@@ -331,7 +330,6 @@ handlers.forEach(url => {
     })
 
     describe('#truncate()', () => {
-      afterEach(() => handler.unlink('file'))
       forOwn(
         {
           'shrinks file': (() => {
@@ -350,7 +348,7 @@ handlers.forEach(url => {
           it(title, async () => {
             await handler.outputFile('file', TEST_DATA)
             await handler.truncate('file', length)
-            assert.deepEqual(await handler.readFile('file'), expected)
+            await expect(await handler.readFile('file')).toEqual(expected)
           })
         }
       )

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

@@ -19,12 +19,7 @@ async function addSyncStackTrace(fn, ...args) {
   try {
     return await fn.apply(this, args)
   } catch (error) {
-    let { stack } = stackContainer
-
-    // remove first line which does not contain stack information, simply `Error`
-    stack = stack.slice(stack.indexOf('\n') + 1)
-
-    error.stack = [error.stack, 'From:', stack].join('\n')
+    error.syncStack = stackContainer.stack
     throw error
   }
 }
@@ -34,14 +29,11 @@ function dontAddSyncStackTrace(fn, ...args) {
 }
 
 export default class LocalHandler extends RemoteHandlerAbstract {
-  #addSyncStackTrace
-  #retriesOnEagain
-
   constructor(remote, opts = {}) {
     super(remote)
 
-    this.#addSyncStackTrace = opts.syncStackTraces ?? true ? addSyncStackTrace : dontAddSyncStackTrace
-    this.#retriesOnEagain = {
+    this._addSyncStackTrace = opts.syncStackTraces ?? true ? addSyncStackTrace : dontAddSyncStackTrace
+    this._retriesOnEagain = {
       delay: 1e3,
       retries: 9,
       ...opts.retriesOnEagain,
@@ -54,26 +46,26 @@ export default class LocalHandler extends RemoteHandlerAbstract {
     return 'file'
   }
 
-  getRealPath() {
+  _getRealPath() {
     return this._remote.path
   }
 
-  getFilePath(file) {
-    return this.getRealPath() + file
+  _getFilePath(file) {
+    return this._getRealPath() + file
   }
 
   async _closeFile(fd) {
-    return this.#addSyncStackTrace(fs.close, fd)
+    return this._addSyncStackTrace(fs.close, fd)
   }
 
   async _copy(oldPath, newPath) {
-    return this.#addSyncStackTrace(fs.copy, this.getFilePath(oldPath), this.getFilePath(newPath))
+    return this._addSyncStackTrace(fs.copy, this._getFilePath(oldPath), this._getFilePath(newPath))
   }
 
   async _createReadStream(file, options) {
     if (typeof file === 'string') {
-      const stream = fs.createReadStream(this.getFilePath(file), options)
-      await this.#addSyncStackTrace(fromEvent, stream, 'open')
+      const stream = fs.createReadStream(this._getFilePath(file), options)
+      await this._addSyncStackTrace(fromEvent, stream, 'open')
       return stream
     }
     return fs.createReadStream('', {
@@ -85,8 +77,8 @@ export default class LocalHandler extends RemoteHandlerAbstract {
 
   async _createWriteStream(file, options) {
     if (typeof file === 'string') {
-      const stream = fs.createWriteStream(this.getFilePath(file), options)
-      await this.#addSyncStackTrace(fromEvent, stream, 'open')
+      const stream = fs.createWriteStream(this._getFilePath(file), options)
+      await this._addSyncStackTrace(fromEvent, stream, 'open')
       return stream
     }
     return fs.createWriteStream('', {
@@ -101,7 +93,7 @@ export default class LocalHandler extends RemoteHandlerAbstract {
     // filesystem, type, size, used, available, capacity and mountpoint.
     // size, used, available and capacity may be `NaN` so we remove any `NaN`
     // value from the object.
-    const info = await df.file(this.getFilePath('/'))
+    const info = await df.file(this._getFilePath('/'))
     Object.keys(info).forEach(key => {
       if (Number.isNaN(info[key])) {
         delete info[key]
@@ -112,16 +104,16 @@ export default class LocalHandler extends RemoteHandlerAbstract {
   }
 
   async _getSize(file) {
-    const stats = await this.#addSyncStackTrace(fs.stat, this.getFilePath(typeof file === 'string' ? file : file.path))
+    const stats = await this._addSyncStackTrace(fs.stat, this._getFilePath(typeof file === 'string' ? file : file.path))
     return stats.size
   }
 
   async _list(dir) {
-    return this.#addSyncStackTrace(fs.readdir, this.getFilePath(dir))
+    return this._addSyncStackTrace(fs.readdir, this._getFilePath(dir))
   }
 
   async _lock(path) {
-    const acquire = lockfile.lock.bind(undefined, this.getFilePath(path), {
+    const acquire = lockfile.lock.bind(undefined, this._getFilePath(path), {
       async onCompromised(error) {
         warn('lock compromised', { error })
         try {
@@ -133,11 +125,11 @@ export default class LocalHandler extends RemoteHandlerAbstract {
       },
     })
 
-    let release = await this.#addSyncStackTrace(acquire)
+    let release = await this._addSyncStackTrace(acquire)
 
     return async () => {
       try {
-        await this.#addSyncStackTrace(release)
+        await this._addSyncStackTrace(release)
       } catch (error) {
         warn('lock could not be released', { error })
       }
@@ -145,18 +137,18 @@ export default class LocalHandler extends RemoteHandlerAbstract {
   }
 
   _mkdir(dir, { mode }) {
-    return this.#addSyncStackTrace(fs.mkdir, this.getFilePath(dir), { mode })
+    return this._addSyncStackTrace(fs.mkdir, this._getFilePath(dir), { mode })
   }
 
   async _openFile(path, flags) {
-    return this.#addSyncStackTrace(fs.open, this.getFilePath(path), flags)
+    return this._addSyncStackTrace(fs.open, this._getFilePath(path), flags)
   }
 
   async _read(file, buffer, position) {
     const needsClose = typeof file === 'string'
-    file = needsClose ? await this.#addSyncStackTrace(fs.open, this.getFilePath(file), 'r') : file.fd
+    file = needsClose ? await this._addSyncStackTrace(fs.open, this._getFilePath(file), 'r') : file.fd
     try {
-      return await this.#addSyncStackTrace(
+      return await this._addSyncStackTrace(
         fs.read,
         file,
         buffer,
@@ -166,44 +158,44 @@ export default class LocalHandler extends RemoteHandlerAbstract {
       )
     } finally {
       if (needsClose) {
-        await this.#addSyncStackTrace(fs.close, file)
+        await this._addSyncStackTrace(fs.close, file)
       }
     }
   }
 
   async _readFile(file, options) {
-    const filePath = this.getFilePath(file)
-    return await this.#addSyncStackTrace(retry, () => fs.readFile(filePath, options), this.#retriesOnEagain)
+    const filePath = this._getFilePath(file)
+    return await this._addSyncStackTrace(retry, () => fs.readFile(filePath, options), this._retriesOnEagain)
   }
 
   async _rename(oldPath, newPath) {
-    return this.#addSyncStackTrace(fs.rename, this.getFilePath(oldPath), this.getFilePath(newPath))
+    return this._addSyncStackTrace(fs.rename, this._getFilePath(oldPath), this._getFilePath(newPath))
   }
 
   async _rmdir(dir) {
-    return this.#addSyncStackTrace(fs.rmdir, this.getFilePath(dir))
+    return this._addSyncStackTrace(fs.rmdir, this._getFilePath(dir))
   }
 
   async _sync() {
-    const path = this.getRealPath('/')
-    await this.#addSyncStackTrace(fs.ensureDir, path)
-    await this.#addSyncStackTrace(fs.access, path, fs.R_OK | fs.W_OK)
+    const path = this._getRealPath('/')
+    await this._addSyncStackTrace(fs.ensureDir, path)
+    await this._addSyncStackTrace(fs.access, path, fs.R_OK | fs.W_OK)
   }
 
   _truncate(file, len) {
-    return this.#addSyncStackTrace(fs.truncate, this.getFilePath(file), len)
+    return this._addSyncStackTrace(fs.truncate, this._getFilePath(file), len)
   }
 
   async _unlink(file) {
-    const filePath = this.getFilePath(file)
-    return await this.#addSyncStackTrace(retry, () => fs.unlink(filePath), this.#retriesOnEagain)
+    const filePath = this._getFilePath(file)
+    return await this._addSyncStackTrace(retry, () => fs.unlink(filePath), this._retriesOnEagain)
   }
 
   _writeFd(file, buffer, position) {
-    return this.#addSyncStackTrace(fs.write, file.fd, buffer, 0, buffer.length, position)
+    return this._addSyncStackTrace(fs.write, file.fd, buffer, 0, buffer.length, position)
   }
 
   _writeFile(file, data, { flags }) {
-    return this.#addSyncStackTrace(fs.writeFile, this.getFilePath(file), data, { flag: flags })
+    return this._addSyncStackTrace(fs.writeFile, this._getFilePath(file), data, { flag: flags })
   }
 }

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

@@ -9,11 +9,13 @@ import {
   ListObjectsV2Command,
   PutObjectCommand,
   S3Client,
+  UploadPartCommand,
   UploadPartCopyCommand,
 } from '@aws-sdk/client-s3'
 import { Upload } from '@aws-sdk/lib-storage'
 import { NodeHttpHandler } from '@aws-sdk/node-http-handler'
 import { getApplyMd5BodyChecksumPlugin } from '@aws-sdk/middleware-apply-body-checksum'
+import assert from 'assert'
 import { Agent as HttpAgent } from 'http'
 import { Agent as HttpsAgent } from 'https'
 import pRetry from 'promise-toolbox/retry'
@@ -22,6 +24,7 @@ import { decorateWith } from '@vates/decorate-with'
 import { PassThrough, pipeline } from 'stream'
 import { parse } from 'xo-remote-parser'
 import copyStreamToBuffer from './_copyStreamToBuffer.js'
+import createBufferFromStream from './_createBufferFromStream.js'
 import guessAwsRegion from './_guessAwsRegion.js'
 import RemoteHandlerAbstract from './abstract'
 import { basename, join, split } from './path'
@@ -30,14 +33,15 @@ import { asyncEach } from '@vates/async-each'
 // endpoints https://docs.aws.amazon.com/general/latest/gr/s3.html
 
 // limits: https://docs.aws.amazon.com/AmazonS3/latest/dev/qfacts.html
+const MIN_PART_SIZE = 1024 * 1024 * 5 // 5MB
 const MAX_PART_SIZE = 1024 * 1024 * 1024 * 5 // 5GB
+const MAX_PARTS_COUNT = 10000
+const MAX_OBJECT_SIZE = 1024 * 1024 * 1024 * 1024 * 5 // 5TB
+const IDEAL_FRAGMENT_SIZE = Math.ceil(MAX_OBJECT_SIZE / MAX_PARTS_COUNT) // the smallest fragment size that still allows a 5TB upload in 10000 fragments, about 524MB
+
 const { warn } = createLogger('xo:fs:s3')
 
 export default class S3Handler extends RemoteHandlerAbstract {
-  #bucket
-  #dir
-  #s3
-
   constructor(remote, _opts) {
     super(remote)
     const {
@@ -50,7 +54,7 @@ export default class S3Handler extends RemoteHandlerAbstract {
       region = guessAwsRegion(host),
     } = parse(remote.url)
 
-    this.#s3 = new S3Client({
+    this._s3 = new S3Client({
       apiVersion: '2006-03-01',
       endpoint: `${protocol}://${host}`,
       forcePathStyle: true,
@@ -73,27 +77,27 @@ export default class S3Handler extends RemoteHandlerAbstract {
     })
 
     // Workaround for https://github.com/aws/aws-sdk-js-v3/issues/2673
-    this.#s3.middlewareStack.use(getApplyMd5BodyChecksumPlugin(this.#s3.config))
+    this._s3.middlewareStack.use(getApplyMd5BodyChecksumPlugin(this._s3.config))
 
     const parts = split(path)
-    this.#bucket = parts.shift()
-    this.#dir = join(...parts)
+    this._bucket = parts.shift()
+    this._dir = join(...parts)
   }
 
   get type() {
     return 's3'
   }
 
-  #makeCopySource(path) {
-    return join(this.#bucket, this.#dir, path)
+  _makeCopySource(path) {
+    return join(this._bucket, this._dir, path)
   }
 
-  #makeKey(file) {
-    return join(this.#dir, file)
+  _makeKey(file) {
+    return join(this._dir, file)
   }
 
-  #makePrefix(dir) {
-    const prefix = join(this.#dir, dir, '/')
+  _makePrefix(dir) {
+    const prefix = join(this._dir, dir, '/')
 
     // no prefix for root
     if (prefix !== './') {
@@ -101,20 +105,20 @@ export default class S3Handler extends RemoteHandlerAbstract {
     }
   }
 
-  #createParams(file) {
-    return { Bucket: this.#bucket, Key: this.#makeKey(file) }
+  _createParams(file) {
+    return { Bucket: this._bucket, Key: this._makeKey(file) }
   }
 
-  async #multipartCopy(oldPath, newPath) {
+  async _multipartCopy(oldPath, newPath) {
     const size = await this._getSize(oldPath)
-    const CopySource = this.#makeCopySource(oldPath)
-    const multipartParams = await this.#s3.send(new CreateMultipartUploadCommand({ ...this.#createParams(newPath) }))
+    const CopySource = this._makeCopySource(oldPath)
+    const multipartParams = await this._s3.send(new CreateMultipartUploadCommand({ ...this._createParams(newPath) }))
     try {
       const parts = []
       let start = 0
       while (start < size) {
         const partNumber = parts.length + 1
-        const upload = await this.#s3.send(
+        const upload = await this._s3.send(
           new UploadPartCopyCommand({
             ...multipartParams,
             CopySource,
@@ -125,31 +129,31 @@ export default class S3Handler extends RemoteHandlerAbstract {
         parts.push({ ETag: upload.CopyPartResult.ETag, PartNumber: partNumber })
         start += MAX_PART_SIZE
       }
-      await this.#s3.send(
+      await this._s3.send(
         new CompleteMultipartUploadCommand({
           ...multipartParams,
           MultipartUpload: { Parts: parts },
         })
       )
     } catch (e) {
-      await this.#s3.send(new AbortMultipartUploadCommand(multipartParams))
+      await this._s3.send(new AbortMultipartUploadCommand(multipartParams))
       throw e
     }
   }
 
   async _copy(oldPath, newPath) {
-    const CopySource = this.#makeCopySource(oldPath)
+    const CopySource = this._makeCopySource(oldPath)
     try {
-      await this.#s3.send(
+      await this._s3.send(
         new CopyObjectCommand({
-          ...this.#createParams(newPath),
+          ...this._createParams(newPath),
           CopySource,
         })
       )
     } catch (e) {
       // object > 5GB must be copied part by part
       if (e.name === 'EntityTooLarge') {
-        return this.#multipartCopy(oldPath, newPath)
+        return this._multipartCopy(oldPath, newPath)
       }
       // normalize this error code
       if (e.name === 'NoSuchKey') {
@@ -163,20 +167,20 @@ export default class S3Handler extends RemoteHandlerAbstract {
     }
   }
 
-  async #isNotEmptyDir(path) {
-    const result = await this.#s3.send(
+  async _isNotEmptyDir(path) {
+    const result = await this._s3.send(
       new ListObjectsV2Command({
-        Bucket: this.#bucket,
+        Bucket: this._bucket,
         MaxKeys: 1,
-        Prefix: this.#makePrefix(path),
+        Prefix: this._makePrefix(path),
       })
     )
     return result.Contents?.length > 0
   }
 
-  async #isFile(path) {
+  async _isFile(path) {
     try {
-      await this.#s3.send(new HeadObjectCommand(this.#createParams(path)))
+      await this._s3.send(new HeadObjectCommand(this._createParams(path)))
       return true
     } catch (error) {
       if (error.name === 'NotFound') {
@@ -193,9 +197,11 @@ export default class S3Handler extends RemoteHandlerAbstract {
     pipeline(input, Body, () => {})
 
     const upload = new Upload({
-      client: this.#s3,
+      client: this._s3,
+      queueSize: 1,
+      partSize: IDEAL_FRAGMENT_SIZE,
       params: {
-        ...this.#createParams(path),
+        ...this._createParams(path),
         Body,
       },
     })
@@ -206,7 +212,7 @@ export default class S3Handler extends RemoteHandlerAbstract {
       try {
         await validator.call(this, path)
       } catch (error) {
-        await this.__unlink(path)
+        await this.unlink(path)
         throw error
       }
     }
@@ -228,9 +234,9 @@ export default class S3Handler extends RemoteHandlerAbstract {
     },
   })
   async _writeFile(file, data, options) {
-    return this.#s3.send(
+    return this._s3.send(
       new PutObjectCommand({
-        ...this.#createParams(file),
+        ...this._createParams(file),
         Body: data,
       })
     )
@@ -238,7 +244,7 @@ export default class S3Handler extends RemoteHandlerAbstract {
 
   async _createReadStream(path, options) {
     try {
-      return (await this.#s3.send(new GetObjectCommand(this.#createParams(path)))).Body
+      return (await this._s3.send(new GetObjectCommand(this._createParams(path)))).Body
     } catch (e) {
       if (e.name === 'NoSuchKey') {
         const error = new Error(`ENOENT: no such file '${path}'`)
@@ -251,9 +257,9 @@ export default class S3Handler extends RemoteHandlerAbstract {
   }
 
   async _unlink(path) {
-    await this.#s3.send(new DeleteObjectCommand(this.#createParams(path)))
+    await this._s3.send(new DeleteObjectCommand(this._createParams(path)))
 
-    if (await this.#isNotEmptyDir(path)) {
+    if (await this._isNotEmptyDir(path)) {
       const error = new Error(`EISDIR: illegal operation on a directory, unlink '${path}'`)
       error.code = 'EISDIR'
       error.path = path
@@ -264,12 +270,12 @@ export default class S3Handler extends RemoteHandlerAbstract {
   async _list(dir) {
     let NextContinuationToken
     const uniq = new Set()
-    const Prefix = this.#makePrefix(dir)
+    const Prefix = this._makePrefix(dir)
 
     do {
-      const result = await this.#s3.send(
+      const result = await this._s3.send(
         new ListObjectsV2Command({
-          Bucket: this.#bucket,
+          Bucket: this._bucket,
           Prefix,
           Delimiter: '/',
           // will only return path until delimiters
@@ -299,7 +305,7 @@ export default class S3Handler extends RemoteHandlerAbstract {
   }
 
   async _mkdir(path) {
-    if (await this.#isFile(path)) {
+    if (await this._isFile(path)) {
       const error = new Error(`ENOTDIR: file already exists, mkdir '${path}'`)
       error.code = 'ENOTDIR'
       error.path = path
@@ -310,15 +316,15 @@ export default class S3Handler extends RemoteHandlerAbstract {
 
   // s3 doesn't have a rename operation, so copy + delete source
   async _rename(oldPath, newPath) {
-    await this.__copy(oldPath, newPath)
-    await this.#s3.send(new DeleteObjectCommand(this.#createParams(oldPath)))
+    await this.copy(oldPath, newPath)
+    await this._s3.send(new DeleteObjectCommand(this._createParams(oldPath)))
   }
 
   async _getSize(file) {
     if (typeof file !== 'string') {
       file = file.fd
     }
-    const result = await this.#s3.send(new HeadObjectCommand(this.#createParams(file)))
+    const result = await this._s3.send(new HeadObjectCommand(this._createParams(file)))
     return +result.ContentLength
   }
 
@@ -326,15 +332,15 @@ export default class S3Handler extends RemoteHandlerAbstract {
     if (typeof file !== 'string') {
       file = file.fd
     }
-    const params = this.#createParams(file)
+    const params = this._createParams(file)
     params.Range = `bytes=${position}-${position + buffer.length - 1}`
     try {
-      const result = await this.#s3.send(new GetObjectCommand(params))
+      const result = await this._s3.send(new GetObjectCommand(params))
       const bytesRead = await copyStreamToBuffer(result.Body, buffer)
       return { bytesRead, buffer }
     } catch (e) {
       if (e.name === 'NoSuchKey') {
-        if (await this.#isNotEmptyDir(file)) {
+        if (await this._isNotEmptyDir(file)) {
           const error = new Error(`${file} is a directory`)
           error.code = 'EISDIR'
           error.path = file
@@ -346,7 +352,7 @@ export default class S3Handler extends RemoteHandlerAbstract {
   }
 
   async _rmdir(path) {
-    if (await this.#isNotEmptyDir(path)) {
+    if (await this._isNotEmptyDir(path)) {
       const error = new Error(`ENOTEMPTY: directory not empty, rmdir '${path}`)
       error.code = 'ENOTEMPTY'
       error.path = path
@@ -360,11 +366,11 @@ export default class S3Handler extends RemoteHandlerAbstract {
   // @todo : use parallel processing for unlink
   async _rmtree(path) {
     let NextContinuationToken
-    const Prefix = this.#makePrefix(path)
+    const Prefix = this._makePrefix(path)
     do {
-      const result = await this.#s3.send(
+      const result = await this._s3.send(
         new ListObjectsV2Command({
-          Bucket: this.#bucket,
+          Bucket: this._bucket,
           Prefix,
           ContinuationToken: NextContinuationToken,
         })
@@ -376,9 +382,9 @@ export default class S3Handler extends RemoteHandlerAbstract {
         async ({ Key }) => {
           // _unlink will add the prefix, but Key contains everything
           // also we don't need to check if we delete a directory, since the list only return files
-          await this.#s3.send(
+          await this._s3.send(
             new DeleteObjectCommand({
-              Bucket: this.#bucket,
+              Bucket: this._bucket,
               Key,
             })
           )
@@ -390,6 +396,138 @@ export default class S3Handler extends RemoteHandlerAbstract {
     } while (NextContinuationToken !== undefined)
   }
 
+  async _write(file, buffer, position) {
+    if (typeof file !== 'string') {
+      file = file.fd
+    }
+    const uploadParams = this._createParams(file)
+    let fileSize
+    try {
+      fileSize = +(await this._s3.send(new HeadObjectCommand(uploadParams))).ContentLength
+    } catch (e) {
+      if (e.name === 'NotFound') {
+        fileSize = 0
+      } else {
+        throw e
+      }
+    }
+    if (fileSize < MIN_PART_SIZE) {
+      const resultBuffer = Buffer.alloc(Math.max(fileSize, position + buffer.length))
+      if (fileSize !== 0) {
+        const result = await this._s3.send(new GetObjectCommand(uploadParams))
+        await copyStreamToBuffer(result.Body, resultBuffer)
+      } else {
+        Buffer.alloc(0).copy(resultBuffer)
+      }
+      buffer.copy(resultBuffer, position)
+      await this._s3.send(
+        new PutObjectCommand({
+          ...uploadParams,
+          Body: resultBuffer,
+        })
+      )
+      return { buffer, bytesWritten: buffer.length }
+    } else {
+      // using this trick: https://stackoverflow.com/a/38089437/72637
+      // multipart fragments have a minimum size of 5Mo and a max of 5Go unless they are last
+      // splitting the file in 3 parts: [prefix, edit, suffix]
+      // if `prefix` is bigger than 5Mo, it will be sourced from uploadPartCopy()
+      // otherwise otherwise it will be downloaded, concatenated to `edit`
+      // `edit` will always be an upload part
+      // `suffix` will always be sourced from uploadPartCopy()
+      // Then everything will be sliced in 5Gb parts before getting uploaded
+      const multipartParams = await this._s3.send(new CreateMultipartUploadCommand(uploadParams))
+      const copyMultipartParams = {
+        ...multipartParams,
+        CopySource: this._makeCopySource(file),
+      }
+      try {
+        const parts = []
+        const prefixSize = position
+        let suffixOffset = prefixSize + buffer.length
+        let suffixSize = Math.max(0, fileSize - suffixOffset)
+        let hasSuffix = suffixSize > 0
+        let editBuffer = buffer
+        let editBufferOffset = position
+        let partNumber = 1
+        let prefixPosition = 0
+        // use floor() so that last fragment is handled in the if bellow
+        let fragmentsCount = Math.floor(prefixSize / MAX_PART_SIZE)
+        const prefixFragmentSize = MAX_PART_SIZE
+        let prefixLastFragmentSize = prefixSize - prefixFragmentSize * fragmentsCount
+        if (prefixLastFragmentSize >= MIN_PART_SIZE) {
+          // the last fragment of the prefix is smaller than MAX_PART_SIZE, but bigger than the minimum
+          // so we can copy it too
+          fragmentsCount++
+          prefixLastFragmentSize = 0
+        }
+        for (let i = 0; i < fragmentsCount; i++) {
+          const fragmentEnd = Math.min(prefixPosition + prefixFragmentSize, prefixSize)
+          assert.strictEqual(fragmentEnd - prefixPosition <= MAX_PART_SIZE, true)
+          const range = `bytes=${prefixPosition}-${fragmentEnd - 1}`
+          const copyPrefixParams = { ...copyMultipartParams, PartNumber: partNumber++, CopySourceRange: range }
+          const part = await this._s3.send(new UploadPartCopyCommand(copyPrefixParams))
+          parts.push({ ETag: part.CopyPartResult.ETag, PartNumber: copyPrefixParams.PartNumber })
+          prefixPosition += prefixFragmentSize
+        }
+        if (prefixLastFragmentSize) {
+          // grab everything from the prefix that was too small to be copied, download and merge to the edit buffer.
+          const downloadParams = { ...uploadParams, Range: `bytes=${prefixPosition}-${prefixSize - 1}` }
+          let prefixBuffer
+          if (prefixSize > 0) {
+            const result = await this._s3.send(new GetObjectCommand(downloadParams))
+            prefixBuffer = await createBufferFromStream(result.Body)
+          } else {
+            prefixBuffer = Buffer.alloc(0)
+          }
+          editBuffer = Buffer.concat([prefixBuffer, buffer])
+          editBufferOffset -= prefixLastFragmentSize
+        }
+        if (hasSuffix && editBuffer.length < MIN_PART_SIZE) {
+          // the edit fragment is too short and is not the last fragment
+          // let's steal from the suffix fragment to reach the minimum size
+          // the suffix might be too short and itself entirely absorbed in the edit fragment, making it the last one.
+          const complementSize = Math.min(MIN_PART_SIZE - editBuffer.length, suffixSize)
+          const complementOffset = editBufferOffset + editBuffer.length
+          suffixOffset += complementSize
+          suffixSize -= complementSize
+          hasSuffix = suffixSize > 0
+          const prefixRange = `bytes=${complementOffset}-${complementOffset + complementSize - 1}`
+          const downloadParams = { ...uploadParams, Range: prefixRange }
+          const result = await this._s3.send(new GetObjectCommand(downloadParams))
+          const complementBuffer = await createBufferFromStream(result.Body)
+          editBuffer = Buffer.concat([editBuffer, complementBuffer])
+        }
+        const editParams = { ...multipartParams, Body: editBuffer, PartNumber: partNumber++ }
+        const editPart = await this._s3.send(new UploadPartCommand(editParams))
+        parts.push({ ETag: editPart.ETag, PartNumber: editParams.PartNumber })
+        if (hasSuffix) {
+          // use ceil because the last fragment can be arbitrarily small.
+          const suffixFragments = Math.ceil(suffixSize / MAX_PART_SIZE)
+          let suffixFragmentOffset = suffixOffset
+          for (let i = 0; i < suffixFragments; i++) {
+            const fragmentEnd = suffixFragmentOffset + MAX_PART_SIZE
+            assert.strictEqual(Math.min(fileSize, fragmentEnd) - suffixFragmentOffset <= MAX_PART_SIZE, true)
+            const suffixRange = `bytes=${suffixFragmentOffset}-${Math.min(fileSize, fragmentEnd) - 1}`
+            const copySuffixParams = { ...copyMultipartParams, PartNumber: partNumber++, CopySourceRange: suffixRange }
+            const suffixPart = (await this._s3.send(new UploadPartCopyCommand(copySuffixParams))).CopyPartResult
+            parts.push({ ETag: suffixPart.ETag, PartNumber: copySuffixParams.PartNumber })
+            suffixFragmentOffset = fragmentEnd
+          }
+        }
+        await this._s3.send(
+          new CompleteMultipartUploadCommand({
+            ...multipartParams,
+            MultipartUpload: { Parts: parts },
+          })
+        )
+      } catch (e) {
+        await this._s3.send(new AbortMultipartUploadCommand(multipartParams))
+        throw e
+      }
+    }
+  }
+
   async _openFile(path, flags) {
     return path
   }

@xen-orchestra/lite/CHANGELOG.md

@@ -11,10 +11,6 @@
 - Display network throughput chart in pool dashboard (PR [#6610](https://github.com/vatesfr/xen-orchestra/pull/6610))
 - Display RAM usage chart in pool dashboard (PR [#6604](https://github.com/vatesfr/xen-orchestra/pull/6604))
 - Ability to change the state of a VM (PRs [#6571](https://github.com/vatesfr/xen-orchestra/pull/6571) [#6608](https://github.com/vatesfr/xen-orchestra/pull/6608))
-- Display CPU provisioning in pool dashboard (PR [#6601](https://github.com/vatesfr/xen-orchestra/pull/6601))
-- Add a star icon near the pool master (PR [#6712](https://github.com/vatesfr/xen-orchestra/pull/6712))
-- Display an error message if the data cannot be fetched (PR [#6525](https://github.com/vatesfr/xen-orchestra/pull/6525))
-- Add "Under Construction" views (PR [#6673](https://github.com/vatesfr/xen-orchestra/pull/6673))
 
 ## **0.1.0**
 

@xen-orchestra/lite/README.md

@@ -105,7 +105,7 @@ Use the `busy` prop to display a loader icon.
 </template>
 
 <script lang="ts" setup>
-import UiIcon from "@/components/ui/icon/UiIcon.vue";
+import UiIcon from "@/components/ui/UiIcon.vue";
 import { faDisplay } from "@fortawesome/free-solid-svg-icons";
 </script>
 ```

@xen-orchestra/lite/docs/component-stories.md

@@ -1,406 +0,0 @@
-<!-- TOC -->
-
-- [Component Stories](#component-stories)
-  - [How to create a story](#how-to-create-a-story)
-  - [How to write a story](#how-to-write-a-story)
-  _ [Example](#example)
-  _ [Props](#props)
-  _ [Required prop](#required-prop)
-  _ [Prop type](#prop-type)
-  _ [String](#string)
-  _ [Number](#number)
-  _ [Boolean](#boolean)
-  _ [Array](#array)
-  _ [Object](#object)
-  _ [Enum](#enum)
-  _ [Any](#any)
-  _ [Custom type](#custom-type)
-  _ [Prop widget](#prop-widget)
-  _ [Text](#text)
-  _ [Number](#number-1)
-  _ [Object](#object-1)
-  _ [Choice](#choice)
-  _ [Boolean](#boolean-1)
-  _ [Prop default](#prop-default)
-  _ [Prop preset](#prop-preset)
-  _ [Prop help](#prop-help)
-  _ [Events](#events)
-  _ [Event with no arguments](#event-with-no-arguments)
-  _ [Event with arguments](#event-with-arguments)
-  _ [Custom function](#custom-function)
-  _ [Event type](#event-type)
-  _ [Models](#models)
-  _ [Default model](#default-model)
-  _ [Custom model](#custom-model)
-  _ [Configure the underlying prop and event](#configure-the-underlying-prop-and-event)
-  _ [Model type](#model-type)
-  _ [Model help](#model-help)
-  _ [Slots](#slots)
-  _ [Default slot](#default-slot)
-  _ [Named slot](#named-slot)
-  _ [Scoped slot (slot with props)](#scoped-slot--slot-with-props-)
-  _ [Slot help](#slot-help)
-  _ [Settings](#settings)
-  <!-- TOC -->
-
-# Component Stories
-
-The `ComponentStory` component allows you to document your components and their props, events and slots.
-
-It takes a `params` prop which is an array of configuration items.
-
-You can configure props, events, models, slots and settings.
-
-Props, Events and Models will be added to the `properties` slot prop.
-
-Slots are only for documentation purpose.
-
-Settings will be added to the `settings` slot prop.
-
-## How to create a story
-
-1. Create a new story component in the `src/stories` directory (ie. `my-component.story.vue`).
-2. To document your component, create the same file with the `.md` extension (ie. `my-component.story.md`).
-
-## How to write a story
-
-In your `.story.vue` file, import and use the `ComponentStory` component.
-
-```vue
-<template>
-  <ComponentStory
-    v-slot="{ properties, settings }"
-    :params="[
-      prop(...),
-      event(...),
-      model(...),
-      slot(...),
-      setting(...),
-    ]"
-  >
-    <MyComponent v-bind="properties">
-      {{ settings.label }}
-    </MyComponent>
-  </ComponentStory>
-</template>
-
-<script lang="ts" setup>
-import MyComponent from "@/components/MyComponent.vue";
-import ComponentStory from "@/components/component-story/ComponentStory.vue";
-import { prop, event, model, slot, setting } from "@/libs/story/story-param";
-</script>
-```
-
-### Example
-
-Let's take this Vue component:
-
-```vue
-<template>
-  <div>
-    <div>Required string prop: {{ imString }}</div>
-    <div>Required number prop: {{ imNumber }}</div>
-    <div v-if="imOptional">Optional prop: {{ imOptional }}</div>
-    <div>Optional prop with default: {{ imOptionalWithDefault }}</div>
-    <button @click="handleClick">Click me</button>
-    <button @click="handleClickWithArg('some-id')">Click me with an id</button>
-    <div>
-      <slot />
-    </div>
-    <div>
-      <slot name="named-slot" />
-    </div>
-    <div>
-      <slot :moon-distance="moonDistance" name="named-scoped-slot" />
-    </div>
-  </div>
-</template>
-
-<script lang="ts" setup>
-withDefaults(
-  defineProps<{
-    imString: string;
-    imNumber: number;
-    imOptional?: string;
-    imOptionalWithDefault?: string;
-    modelValue?: string;
-    customModel?: number;
-  }>(),
-  { imOptionalWithDefault: "Hi World" }
-);
-
-const emit = defineEmits<{
-  (event: "click"): void;
-  (event: "clickWithArg", id: string): void;
-  (event: "update:modelValue", value: string): void;
-  (event: "update:customModel", value: number): void;
-}>();
-
-const moonDistance = 384400;
-
-const handleClick = () => emit("click");
-const handleClickWithArg = (id: string) => emit("clickWithArg", id);
-</script>
-```
-
-Here is how to document it with a Component Story:
-
-```vue
-<template>
-  <ComponentStory
-    v-slot="{ properties, settings }"
-    :params="[
-      prop('imString')
-        .str()
-        .required()
-        .preset('Example')
-        .widget()
-        .help('This is a required string prop'),
-      prop('imNumber')
-        .num()
-        .required()
-        .preset(42)
-        .widget()
-        .help('This is a required number prop'),
-      prop('imOptional').str().widget().help('This is an optional string prop'),
-      prop('imOptionalWithDefault')
-        .str()
-        .default('Hi World')
-        .widget()
-        .default('My default value'),
-      model().prop((p) => p.str()),
-      model('customModel').prop((p) => p.num()),
-      event('click').help('Emitted when the user clicks the first button'),
-      event('clickWithArg')
-        .args({ id: 'string' })
-        .help('Emitted when the user clicks the second button'),
-      slot().help('This is the default slot'),
-      slot('namedSlot').help('This is a named slot'),
-      slot('namedScopedSlot')
-        .prop('moon-distance', 'number')
-        .help('This is a named slot'),
-      setting('contentExample').widget(text()).preset('Some content'),
-    ]"
-  >
-    <MyComponent v-bind="properties">
-      {{ settings.contentExample }}
-      <template #named-slot>Named slot content</template>
-      <template #named-scoped-slot="{ moonDistance }">
-        Moon distance is {{ moonDistance }} meters.
-      </template>
-    </MyComponent>
-  </ComponentStory>
-</template>
-
-<script lang="ts" setup>
-import ComponentStory from "@/components/component-story/ComponentStory.vue";
-import MyComponent from "@/components/MyComponent.vue";
-import { event, model, prop, setting, slot } from "@/libs/story/story-param";
-import { text } from "@/libs/story/story-widget";
-</script>
-```
-
-### Props
-
-Use the `prop(name: string)` function to document a prop.
-
-It will appear on the **Props** tab.
-
-#### Required prop
-
-If the prop is required, use the `required()` function.
-
-`prop('title').required()`
-
-#### Prop type
-
-You can set the type of the prop with the `str()`, `num()`, `bool()`, `arr()`, `obj()`, `enum()` and `any()` functions.
-
-The type can also be detected automatically if a [preset](#prop-preset) value is defined.
-
-##### String
-
-`prop('title').str()`: `string`
-
-##### Number
-
-`prop('count').num()`: `number`
-
-##### Boolean
-
-`prop('disabled').bool()`: `boolean`
-
-##### Array
-
-`prop('items').arr()`: `any[]`
-
-`prop('items').arr('string')`: `string[]`
-
-##### Object
-
-`prop('user').obj()`: `object`
-
-`prop('user').obj('{ name: string, age: number }')`: `{ name: string; age: number; }`
-
-##### Enum
-
-`prop('color').enum('red', 'green', 'blue')`: `"red" | "green" | "blue"`
-
-##### Any
-
-`prop('color').any()`: `any`
-
-##### Custom type
-
-`prop('user').type('User')`: `User`
-
-#### Prop widget
-
-When the prop type is defined, the widget is automatically detected.
-
-`prop('title').str().widget()`
-
-But you can also define the widget manually.
-
-##### Text
-
-`prop('...').widget(text())`
-
-##### Number
-
-`prop('...').widget(number())`
-
-##### Object
-
-`prop('...').widget(object())`
-
-##### Choice
-
-`prop('...').widget(choice('red', 'green', 'blue'))`
-
-##### Boolean
-
-`prop('title').widget(boolean())`
-
-#### Prop default
-
-This documents the default value of the prop, which is applied when the prop is not defined.
-
-`prop('color').default('blue')`
-
-#### Prop preset
-
-This allows to preset a prop value for this story.
-
-`prop('color').preset('red')`
-
-#### Prop help
-
-This allows to add a help text for this prop.
-
-`prop('color').help('This is the component text color')`
-
-### Events
-
-Use the `event(name: string)` function to document an event.
-
-It will appear in the **Events** tab.
-
-When triggered, this event will be logged to the `Logs` card.
-
-#### Event with no arguments
-
-`event('edit')`: `() => void`
-
-#### Event with arguments
-
-`event('delete').args({ id: 'string' })`: `(id: string) => void`
-
-#### Custom function
-
-If needed, thanks to the `preset` method, you can attach a custom function to your event.
-
-`const debug = (id: string) => console.log(id);`
-
-`event('my-event').args({ id: 'string' }).preset(debug)`
-
-#### Event type
-
-The event type is automatically generated from the arguments.
-
-You can override it with the `type()` method.
-
-#### Event help
-
-This allows to add a help text for this event.
-
-`event('close').help('Called when user clicks the close icon or on the background')`
-
-### Models
-
-Use the `model(name = "model-value")` function to document a model.
-
-Calling `model("foo")` is kind of equivalent to calling `prop("foo")` + `event("update:foo")`.
-
-#### Default model
-
-`model()` with no argument will create a `model-value` prop and a `update:model-value` event.
-
-#### Custom model
-
-`model('foo')` will create a `foo` prop and a `update:foo` event.
-
-#### Configure the underlying prop and event
-
-You can use `.prop((p) => ...)` and `.event((e) => ...)` methods to access the underlying prop and event respectively
-then use any of the [prop](#props) and [event](#events) methods.
-
-`model().event((e) => e.help('Help for update:modelValue event'))`
-
-#### Model type
-
-`.type(type: string)` function is a shortcut for `.prop((p) => p.type(...))`
-
-#### Model help
-
-Using `.help(text: string)` function is a shortcut for `.prop((p) => p.help(...))`
-
-### Slots
-
-Use the `slot(name = "default")` function to document a slot.
-
-#### Default slot
-
-`slot()`
-
-=> `<slot />`
-
-#### Named slot
-
-`slot('header')`
-
-=> `<slot name="header" />`
-
-#### Scoped slot (slot with props)
-
-`slot('footer').prop('color', 'string').prop('count', 'number')`
-
-#### Slot help
-
-`slot('footer').help('This is the footer slot')`
-
-### Settings
-
-Use the `setting(name: string)` to configure your Story with arbitrary settings.
-
-They will not be passed automatically to your component, but you can access them in your template with the `settings` variable.
-
-For example:
-
-```vue
-<template>
-  <ComponentStory v-slot="{ settings }" :params="[setting('label').widget()]">
-    <button>{{ settings.label }}</button>
-  </ComponentStory>
-</template>
-```

@xen-orchestra/lite/env.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="vite/client" />
 /// <reference types="json-rpc-2.0/dist" />
-/// <reference types="vite-plugin-pages/client" />
 
 declare const XO_LITE_VERSION: string;
 declare const XO_LITE_GIT_HEAD: string;

@xen-orchestra/lite/package.json

@@ -18,35 +18,31 @@
     "@novnc/novnc": "^1.3.0",
     "@types/d3-time-format": "^4.0.0",
     "@types/lodash-es": "^4.17.6",
-    "@types/marked": "^4.0.8",
-    "@vueuse/core": "^10.1.2",
-    "@vueuse/math": "^10.1.2",
+    "@vueuse/core": "^9.5.0",
+    "@vueuse/math": "^9.5.0",
     "complex-matcher": "^0.7.0",
     "d3-time-format": "^4.1.0",
     "decorator-synchronized": "^0.6.0",
     "echarts": "^5.3.3",
-    "highlight.js": "^11.6.0",
-    "human-format": "^1.1.0",
-    "iterable-backoff": "^0.1.0",
+    "human-format": "^1.0.0",
     "json-rpc-2.0": "^1.3.0",
     "json5": "^2.2.1",
     "limit-concurrency-decorator": "^0.5.0",
     "lodash-es": "^4.17.21",
     "make-error": "^1.3.6",
-    "marked": "^4.2.12",
-    "pinia": "^2.1.2",
+    "pinia": "^2.0.14",
     "placement.js": "^1.0.0-beta.5",
-    "vue": "^3.3.4",
+    "vue": "^3.2.37",
     "vue-echarts": "^6.2.3",
-    "vue-i18n": "^9.2.2",
-    "vue-router": "^4.2.1"
+    "vue-i18n": "9",
+    "vue-router": "^4.0.16"
   },
   "devDependencies": {
-    "@intlify/unplugin-vue-i18n": "^0.10.0",
+    "@intlify/vite-plugin-vue-i18n": "^6.0.1",
     "@limegrass/eslint-plugin-import-alias": "^1.0.5",
     "@rushstack/eslint-patch": "^1.1.0",
     "@types/node": "^16.11.41",
-    "@vitejs/plugin-vue": "^4.2.3",
+    "@vitejs/plugin-vue": "^3.2.0",
     "@vue/eslint-config-prettier": "^7.0.0",
     "@vue/eslint-config-typescript": "^11.0.0",
     "@vue/tsconfig": "^0.1.3",
@@ -56,9 +52,8 @@
     "postcss-custom-media": "^9.0.1",
     "postcss-nested": "^6.0.0",
     "typescript": "^4.9.3",
-    "vite": "^4.3.8",
-    "vite-plugin-pages": "^0.29.1",
-    "vue-tsc": "^1.6.5"
+    "vite": "^3.2.4",
+    "vue-tsc": "^1.0.9"
   },
   "private": true,
   "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/lite",

@xen-orchestra/lite/src/App.vue

@@ -1,12 +1,34 @@
 <template>
-  <UnreachableHostsModal />
-  <div v-if="!$route.meta.hasStoryNav && !xenApiStore.isConnected">
+  <UiModal
+    v-if="isSslModalOpen"
+    color="error"
+    :icon="faServer"
+    @close="clearUnreachableHostsUrls"
+  >
+    <template #title>{{ $t("unreachable-hosts") }}</template>
+    <template #subtitle>{{ $t("following-hosts-unreachable") }}</template>
+    <p>{{ $t("allow-self-signed-ssl") }}</p>
+    <ul>
+      <li v-for="url in unreachableHostsUrls" :key="url.hostname">
+        <a :href="url.href" target="_blank" rel="noopener">{{ url.href }}</a>
+      </li>
+    </ul>
+    <template #buttons>
+      <UiButton color="success" @click="reload">{{
+        $t("unreachable-hosts-reload-page")
+      }}</UiButton>
+      <UiButton @click="clearUnreachableHostsUrls">{{ $t("cancel") }}</UiButton>
+    </template>
+  </UiModal>
+  <div v-if="!xenApiStore.isConnected">
     <AppLogin />
   </div>
   <div v-else>
     <AppHeader />
     <div style="display: flex">
-      <AppNavigation />
+      <transition name="slide">
+        <AppNavigation />
+      </transition>
       <main class="main">
         <RouterView />
       </main>
@@ -16,23 +38,27 @@
 </template>
 
 <script lang="ts" setup>
-import favicon from "@/assets/favicon.svg";
-import AppHeader from "@/components/AppHeader.vue";
-import AppLogin from "@/components/AppLogin.vue";
 import AppNavigation from "@/components/AppNavigation.vue";
-import AppTooltips from "@/components/AppTooltips.vue";
-import UnreachableHostsModal from "@/components/UnreachableHostsModal.vue";
-import { useChartTheme } from "@/composables/chart-theme.composable";
-import { usePoolStore } from "@/stores/pool.store";
 import { useUiStore } from "@/stores/ui.store";
-import { useXenApiStore } from "@/stores/xen-api.store";
 import { useActiveElement, useMagicKeys, whenever } from "@vueuse/core";
 import { logicAnd } from "@vueuse/math";
-import { computed } from "vue";
+import { difference } from "lodash";
+import { computed, ref, watch, watchEffect } from "vue";
+import favicon from "@/assets/favicon.svg";
+import { faServer } from "@fortawesome/free-solid-svg-icons";
+import AppHeader from "@/components/AppHeader.vue";
+import AppLogin from "@/components/AppLogin.vue";
+import AppTooltips from "@/components/AppTooltips.vue";
+import UiButton from "@/components/ui/UiButton.vue";
+import UiModal from "@/components/ui/UiModal.vue";
+import { useChartTheme } from "@/composables/chart-theme.composable";
+import { useHostStore } from "@/stores/host.store";
+import { useXenApiStore } from "@/stores/xen-api.store";
 
-let link = document.querySelector(
-  "link[rel~='icon']"
-) as HTMLLinkElement | null;
+const unreachableHostsUrls = ref<URL[]>([]);
+const clearUnreachableHostsUrls = () => (unreachableHostsUrls.value = []);
+
+let link: HTMLLinkElement | null = document.querySelector("link[rel~='icon']");
 if (link == null) {
   link = document.createElement("link");
   link.rel = "icon";
@@ -43,7 +69,7 @@ link.href = favicon;
 document.title = "XO Lite";
 
 const xenApiStore = useXenApiStore();
-const { pool } = usePoolStore().subscribe();
+const hostStore = useHostStore();
 useChartTheme();
 const uiStore = useUiStore();
 
@@ -65,25 +91,47 @@ if (import.meta.env.DEV) {
   );
 }
 
-whenever(
-  () => pool.value?.$ref,
-  async (poolRef) => {
-    const xenApi = xenApiStore.getXapi();
-    await xenApi.injectWatchEvent(poolRef);
-    await xenApi.startWatch();
+watchEffect(() => {
+  if (xenApiStore.isConnected) {
+    xenApiStore.init();
+  }
+});
+
+watch(
+  () => hostStore.allRecords,
+  (hosts, previousHosts) => {
+    difference(hosts, previousHosts).forEach((host) => {
+      const url = new URL("http://localhost");
+      url.protocol = window.location.protocol;
+      url.hostname = host.address;
+      fetch(url, { mode: "no-cors" }).catch(() =>
+        unreachableHostsUrls.value.push(url)
+      );
+    });
   }
 );
+
+const isSslModalOpen = computed(() => unreachableHostsUrls.value.length > 0);
+const reload = () => window.location.reload();
 </script>
 
 <style lang="postcss">
 @import "@/assets/base.css";
-</style>
 
-<style lang="postcss" scoped>
+.slide-enter-active,
+.slide-leave-active {
+  transition: transform 0.3s ease;
+}
+
+.slide-enter-from,
+.slide-leave-to {
+  transform: translateX(-37rem);
+}
+
 .main {
   overflow: auto;
   flex: 1;
-  height: calc(100vh - 8rem);
+  height: calc(100vh - 9rem);
   background-color: var(--background-color-secondary);
 }
 </style>

@xen-orchestra/lite/src/assets/base.css

@@ -16,10 +16,8 @@ a {
   color: var(--color-extra-blue-base);
 }
 
-code,
-code * {
-  font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono",
-    "Courier New", monospace;
+code {
+  font-family: monospace;
 }
 
 .card-view {
@@ -27,22 +25,3 @@ code * {
   display: flex;
   gap: 2rem;
 }
-
-.link {
-  text-decoration: underline;
-  color: var(--color-extra-blue-base);
-  cursor: pointer;
-}
-
-.link:hover {
-  color: var(--color-extra-blue-d20);
-}
-
-.link:active,
-.link.router-link-active {
-  color: var(--color-extra-blue-d40);
-}
-
-.link.router-link-active {
-  text-decoration: underline;
-}

@xen-orchestra/lite/src/assets/color-mode-auto.svg

@@ -1,136 +0,0 @@
-<svg width="200" height="200" viewBox="3 2 200 200" fill="none"
-  xmlns="http://www.w3.org/2000/svg">
-  <g filter="url(#filter0_ddd_1994_118844)">
-    <g clip-path="url(#clip0_1994_118844)">
-      <g filter="url(#filter1_ddd_1994_118844)">
-        <g clip-path="url(#clip1_1994_118844)">
-          <rect x="3" y="2" width="200" height="200" rx="8" fill="#F6F6F7"/>
-          <rect width="200" height="29" transform="translate(3 2)" fill="#F6F6F7"/>
-          <rect x="13" y="13" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect width="68" height="171" transform="translate(3 31)" fill="white"/>
-          <rect x="13" y="41" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="41" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="58" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="58" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="75" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="75" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="92" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="92" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="109" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="109" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="126" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="126" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="143" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="143" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="160" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="160" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="177" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="177" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="13" y="194" width="7" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="25" y="194" width="36" height="7" rx="3" fill="#E5E5E7"/>
-          <rect x="76" y="36" width="122" height="44" rx="4" fill="white"/>
-          <rect x="86" y="46" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="46" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-          <rect x="86" y="63" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="63" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-          <rect x="76" y="90" width="122" height="44" rx="4" fill="white"/>
-          <rect x="86" y="100" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="100" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-          <rect x="86" y="117" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="117" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-          <rect x="76" y="144" width="122" height="44" rx="4" fill="white"/>
-          <rect x="86" y="154" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="154" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-          <rect x="86" y="171" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="171" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-          <rect x="76" y="198" width="122" height="44" rx="4" fill="white"/>
-        </g>
-      </g>
-    </g>
-    <g clip-path="url(#clip2_1994_118844)">
-      <g filter="url(#filter2_ddd_1994_118844)">
-        <g clip-path="url(#clip3_1994_118844)">
-          <rect x="3" y="2" width="200" height="200" rx="8" fill="#17182B"/>
-          <rect width="200" height="29" transform="translate(3 2)" fill="#17182B"/>
-          <rect x="76" y="36" width="122" height="44" rx="4" fill="#14141E"/>
-          <rect x="86" y="46" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="46" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-          <rect x="86" y="63" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="63" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-          <rect x="76" y="90" width="122" height="44" rx="4" fill="#14141E"/>
-          <rect x="86" y="100" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="100" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-          <rect x="86" y="117" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="117" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-          <rect x="76" y="144" width="122" height="44" rx="4" fill="#14141E"/>
-          <rect x="86" y="154" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="154" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-          <rect x="86" y="171" width="102" height="7" rx="3" fill="#8F84FF"/>
-          <rect x="86" y="171" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-          <rect x="76" y="198" width="122" height="44" rx="4" fill="#14141E"/>
-        </g>
-      </g>
-    </g>
-  </g>
-  <defs>
-    <filter id="filter0_ddd_1994_118844" x="0" y="0" width="206" height="206" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
-      <feFlood flood-opacity="0" result="BackgroundImageFix"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.08 0"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="2"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.06 0"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="1.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.1 0"/>
-      <feBlend mode="normal" in="SourceGraphic" in2="effect3_dropShadow_1994_118844" result="shape"/>
-    </filter>
-    <filter id="filter1_ddd_1994_118844" x="0" y="0" width="206" height="206" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
-      <feFlood flood-opacity="0" result="BackgroundImageFix"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.08 0"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="2"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.06 0"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="1.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.1 0"/>
-      <feBlend mode="normal" in="SourceGraphic" in2="effect3_dropShadow_1994_118844" result="shape"/>
-    </filter>
-    <filter id="filter2_ddd_1994_118844" x="0" y="0" width="206" height="206" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
-      <feFlood flood-opacity="0" result="BackgroundImageFix"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.16 0"/>
-      <feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_1994_118844"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="2"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.12 0"/>
-      <feBlend mode="normal" in2="effect1_dropShadow_1994_118844" result="effect2_dropShadow_1994_118844"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="1.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.2 0"/>
-      <feBlend mode="normal" in="SourceGraphic" in2="effect3_dropShadow_1994_118844" result="shape"/>
-    </filter>
-    <clipPath id="clip0_1994_118844">
-      <rect width="100" height="200" fill="white" transform="translate(3 2)"/>
-    </clipPath>
-    <clipPath id="clip1_1994_118844">
-      <rect x="3" y="2" width="200" height="200" rx="8" fill="white"/>
-    </clipPath>
-    <clipPath id="clip2_1994_118844">
-      <rect width="100" height="200" fill="white" transform="translate(103 2)"/>
-    </clipPath>
-    <clipPath id="clip3_1994_118844">
-      <rect x="3" y="2" width="200" height="200" rx="8" fill="white"/>
-    </clipPath>
-  </defs>
-</svg>

@xen-orchestra/lite/src/assets/color-mode-dark.svg

@@ -1,70 +0,0 @@
-<svg width="200" height="200" viewBox="3 2 200 200" fill="none"
-  xmlns="http://www.w3.org/2000/svg">
-  <g filter="url(#filter0_ddd_1994_118694)">
-    <g clip-path="url(#clip0_1994_118694)">
-      <rect x="3" y="2" width="200" height="200" rx="8" fill="#17182B"/>
-      <rect width="200" height="29" transform="translate(3 2)" fill="#17182B"/>
-      <rect x="13" y="13" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect width="68" height="171" transform="translate(3 31)" fill="#14141E"/>
-      <rect x="13" y="41" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="41" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="58" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="58" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="75" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="75" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="92" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="92" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="109" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="109" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="126" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="126" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="143" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="143" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="160" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="160" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="177" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="177" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="13" y="194" width="7" height="7" rx="3" fill="#595A6F"/>
-      <rect x="25" y="194" width="36" height="7" rx="3" fill="#595A6F"/>
-      <rect x="76" y="36" width="122" height="44" rx="4" fill="#14141E"/>
-      <rect x="86" y="46" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="46" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-      <rect x="86" y="63" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="63" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-      <rect x="76" y="90" width="122" height="44" rx="4" fill="#14141E"/>
-      <rect x="86" y="100" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="100" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-      <rect x="86" y="117" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="117" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-      <rect x="76" y="144" width="122" height="44" rx="4" fill="#14141E"/>
-      <rect x="86" y="154" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="154" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-      <rect x="86" y="171" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="171" width="102" height="7" rx="3" fill="black" fill-opacity="0.4"/>
-      <rect x="76" y="198" width="122" height="44" rx="4" fill="#14141E"/>
-    </g>
-  </g>
-  <defs>
-    <filter id="filter0_ddd_1994_118694" x="0" y="0" width="206" height="206" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
-      <feFlood flood-opacity="0" result="BackgroundImageFix"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.16 0"/>
-      <feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_1994_118694"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="2"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.12 0"/>
-      <feBlend mode="normal" in2="effect1_dropShadow_1994_118694" result="effect2_dropShadow_1994_118694"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="1.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.2 0"/>
-      <feBlend mode="normal" in="SourceGraphic" in2="effect3_dropShadow_1994_118694" result="shape"/>
-    </filter>
-    <clipPath id="clip0_1994_118694">
-      <rect x="3" y="2" width="200" height="200" rx="8" fill="white"/>
-    </clipPath>
-  </defs>
-</svg>

@xen-orchestra/lite/src/assets/color-mode-light.svg

@@ -1,70 +0,0 @@
-<svg width="200" height="200" viewBox="3 2 200 200" fill="none"
-  xmlns="http://www.w3.org/2000/svg">
-  <g filter="url(#filter0_ddd_1994_118640)">
-    <g clip-path="url(#clip0_1994_118640)">
-      <rect x="3" y="2" width="200" height="200" rx="8" fill="#F6F6F7"/>
-      <rect width="200" height="29" transform="translate(3 2)" fill="#F6F6F7"/>
-      <rect x="13" y="13" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect width="68" height="171" transform="translate(3 31)" fill="white"/>
-      <rect x="13" y="41" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="41" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="58" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="58" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="75" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="75" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="92" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="92" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="109" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="109" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="126" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="126" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="143" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="143" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="160" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="160" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="177" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="177" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="13" y="194" width="7" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="25" y="194" width="36" height="7" rx="3" fill="#E5E5E7"/>
-      <rect x="76" y="36" width="122" height="44" rx="4" fill="white"/>
-      <rect x="86" y="46" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="46" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-      <rect x="86" y="63" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="63" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-      <rect x="76" y="90" width="122" height="44" rx="4" fill="white"/>
-      <rect x="86" y="100" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="100" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-      <rect x="86" y="117" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="117" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-      <rect x="76" y="144" width="122" height="44" rx="4" fill="white"/>
-      <rect x="86" y="154" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="154" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-      <rect x="86" y="171" width="102" height="7" rx="3" fill="#8F84FF"/>
-      <rect x="86" y="171" width="102" height="7" rx="3" fill="white" fill-opacity="0.6"/>
-      <rect x="76" y="198" width="122" height="44" rx="4" fill="white"/>
-    </g>
-  </g>
-  <defs>
-    <filter id="filter0_ddd_1994_118640" x="0" y="0" width="206" height="206" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
-      <feFlood flood-opacity="0" result="BackgroundImageFix"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.08 0"/>
-      <feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_1994_118640"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="2"/>
-      <feGaussianBlur stdDeviation="0.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.06 0"/>
-      <feBlend mode="normal" in2="effect1_dropShadow_1994_118640" result="effect2_dropShadow_1994_118640"/>
-      <feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
-      <feOffset dy="1"/>
-      <feGaussianBlur stdDeviation="1.5"/>
-      <feColorMatrix type="matrix" values="0 0 0 0 0.101961 0 0 0 0 0.105882 0 0 0 0 0.219608 0 0 0 0.1 0"/>
-      <feBlend mode="normal" in="SourceGraphic" in2="effect3_dropShadow_1994_118640" result="shape"/>
-    </filter>
-    <clipPath id="clip0_1994_118640">
-      <rect x="3" y="2" width="200" height="200" rx="8" fill="white"/>
-    </clipPath>
-  </defs>
-</svg>