feat(@vates/nbd-client): export a stream from a remote nbd export

Reported by @benjamreis

@vates/fuse-vhd/index.mjs

@@ -1,9 +1,7 @@
-'use strict'
-
-const LRU = require('lru-cache')
-const Fuse = require('fuse-native')
-const { VhdSynthetic } = require('vhd-lib')
-const { Disposable, fromCallback } = require('promise-toolbox')
+import LRU from 'lru-cache'
+import Fuse from 'fuse-native'
+import { VhdSynthetic } from 'vhd-lib'
+import { Disposable, fromCallback } from 'promise-toolbox'
 
 // build a s stat object from https://github.com/fuse-friends/fuse-native/blob/master/test/fixtures/stat.js
 const stat = st => ({
@@ -16,7 +14,7 @@ const stat = st => ({
   gid: st.gid !== undefined ? st.gid : process.getgid(),
 })
 
-exports.mount = Disposable.factory(async function* mount(handler, diskPath, mountDir) {
+export const mount = Disposable.factory(async function* mount(handler, diskPath, mountDir) {
   const vhd = yield VhdSynthetic.fromVhdChain(handler, diskPath)
 
   const cache = new LRU({

@vates/fuse-vhd/package.json

@@ -15,8 +15,9 @@
     "url": "https://vates.fr"
   },
   "engines": {
-    "node": ">=10.0"
+    "node": ">=14"
   },
+  "main": "./index.mjs",
   "dependencies": {
     "fuse-native": "^2.2.6",
     "lru-cache": "^7.14.0",

@vates/nbd-client/constants.js

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

@vates/nbd-client/constants.mjs

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

@vates/nbd-client/index.mjs

@@ -1,8 +1,11 @@
-'use strict'
-const assert = require('node:assert')
-const { Socket } = require('node:net')
-const { connect } = require('node:tls')
-const {
+import assert from 'node:assert'
+import { Socket } from 'node:net'
+import { connect } from 'node:tls'
+import { fromCallback, pRetry, pDelay, pTimeout } from 'promise-toolbox'
+import { readChunkStrict } from '@vates/read-chunk'
+import { createLogger } from '@xen-orchestra/log'
+
+import {
   INIT_PASSWD,
   NBD_CMD_READ,
   NBD_DEFAULT_BLOCK_SIZE,
@@ -17,16 +20,14 @@ const {
   NBD_REQUEST_MAGIC,
   OPTS_MAGIC,
   NBD_CMD_DISC,
-} = require('./constants.js')
-const { fromCallback, pRetry, pDelay, pTimeout } = require('promise-toolbox')
-const { readChunkStrict } = require('@vates/read-chunk')
-const { createLogger } = require('@xen-orchestra/log')
+} from './constants.mjs'
+import { Readable } from 'node:stream'
 
 const { warn } = createLogger('vates:nbd-client')
 
 // documentation is here : https://github.com/NetworkBlockDevice/nbd/blob/master/doc/proto.md
 
-module.exports = class NbdClient {
+export default class NbdClient {
   #serverAddress
   #serverCert
   #serverPort
@@ -232,19 +233,20 @@ module.exports = class NbdClient {
     }
     try {
       this.#waitingForResponse = true
-      const magic = await this.#readInt32()
+      const buffer = await this.#read(8)
+      const magic = buffer.readInt32BE(0)
 
       if (magic !== NBD_REPLY_MAGIC) {
         throw new Error(`magic number for block answer is wrong : ${magic} ${NBD_REPLY_MAGIC}`)
       }
 
-      const error = await this.#readInt32()
+      const error = buffer.readInt32BE(1)
       if (error !== 0) {
         // @todo use error code from constants.mjs
         throw new Error(`GOT ERROR CODE  : ${error}`)
       }
 
-      const blockQueryId = await this.#readInt64()
+      const blockQueryId = buffer.readBigUInt64BE(4)
       const query = this.#commandQueryBacklog.get(blockQueryId)
       if (!query) {
         throw new Error(` no query associated with id ${blockQueryId}`)
@@ -281,7 +283,13 @@ module.exports = class NbdClient {
     buffer.writeInt16BE(NBD_CMD_READ, 6) // we want to read a data block
     buffer.writeBigUInt64BE(queryId, 8)
     // byte offset in the raw disk
-    buffer.writeBigUInt64BE(BigInt(index) * BigInt(size), 16)
+    const offset = BigInt(index) * BigInt(size)
+    const remaining = this.#exportSize - offset
+    if (remaining < BigInt(size)) {
+      size = Number(remaining)
+    }
+
+    buffer.writeBigUInt64BE(offset, 16)
     buffer.writeInt32BE(size, 24)
 
     return new Promise((resolve, reject) => {
@@ -307,14 +315,15 @@ module.exports = class NbdClient {
     })
   }
 
-  async *readBlocks(indexGenerator) {
+  async *readBlocks(indexGenerator = 2 * 1024 * 1024) {
     // default : read all blocks
-    if (indexGenerator === undefined) {
-      const exportSize = this.#exportSize
-      const chunkSize = 2 * 1024 * 1024
+    if (typeof indexGenerator === 'number') {
+      const exportSize = Number(this.#exportSize)
+      const chunkSize = indexGenerator
+
       indexGenerator = function* () {
-        const nbBlocks = Math.ceil(Number(exportSize / BigInt(chunkSize)))
-        for (let index = 0; BigInt(index) < nbBlocks; index++) {
+        const nbBlocks = Math.ceil(exportSize / chunkSize)
+        for (let index = 0; index < nbBlocks; index++) {
           yield { index, size: chunkSize }
         }
       }
@@ -348,4 +357,15 @@ module.exports = class NbdClient {
       yield readAhead.shift()
     }
   }
+
+  stream(chunk_size) {
+    async function* iterator() {
+      for await (const chunk of this.readBlocks(chunk_size)) {
+        yield chunk
+      }
+    }
+    // create a readable stream instead of returning the iterator
+    // since iterators don't like unshift and partial reading
+    return Readable.from(iterator())
+  }
 }

@vates/nbd-client/package.json

@@ -13,17 +13,18 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "engines": {
     "node": ">=14.0"
   },
+  "main": "./index.mjs",
   "dependencies": {
     "@vates/async-each": "^1.0.0",
     "@vates/read-chunk": "^1.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
     "@xen-orchestra/log": "^0.6.0",
     "promise-toolbox": "^0.21.0",
-    "xen-api": "^1.3.1"
+    "xen-api": "^1.3.3"
   },
   "devDependencies": {
     "tap": "^16.3.0",
@@ -31,6 +32,6 @@
   },
   "scripts": {
     "postversion": "npm publish --access public",
-    "test-integration": "tap --lines 97 --functions 95 --branches 74 --statements 97 tests/*.integ.js"
+    "test-integration": "tap --lines 97 --functions 95 --branches 74 --statements 97 tests/*.integ.mjs"
   }
 }

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

@@ -1,13 +1,12 @@
-'use strict'
-const NbdClient = require('../index.js')
-const { spawn, exec } = require('node:child_process')
-const fs = require('node:fs/promises')
-const { test } = require('tap')
-const tmp = require('tmp')
-const { pFromCallback } = require('promise-toolbox')
-const { Socket } = require('node:net')
-const { NBD_DEFAULT_PORT } = require('../constants.js')
-const assert = require('node:assert')
+import NbdClient from '../index.mjs'
+import { spawn, exec } from 'node:child_process'
+import fs from 'node:fs/promises'
+import { test } from 'tap'
+import tmp from 'tmp'
+import { pFromCallback } from 'promise-toolbox'
+import { Socket } from 'node:net'
+import { NBD_DEFAULT_PORT } from '../constants.mjs'
+import assert from 'node:assert'
 
 const FILE_SIZE = 10 * 1024 * 1024
 

@vates/node-vsphere-soap/.npmignore

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

@vates/node-vsphere-soap/LICENSE

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

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

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

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

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

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

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

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

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

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

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

@vates/read-chunk/index.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const assert = require('assert')
+const isUtf8 = require('isutf8')
 
 /**
  * Read a chunk of data from a stream.
@@ -81,6 +82,13 @@ 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})`)
+
+    // Buffer.isUtf8 is too recent for now
+    // @todo : replace external package by Buffer.isUtf8 when the supported version of node reach 18
+
+    if (chunk.length < 1024 && isUtf8(chunk)) {
+      error.text = chunk.toString('utf8')
+    }
     Object.defineProperties(error, {
       chunk: {
         value: chunk,

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

@@ -102,12 +102,37 @@ describe('readChunkStrict', function () {
     assert.strictEqual(error.chunk, undefined)
   })
 
-  it('throws if stream ends with not enough data', async () => {
+  it('throws if stream ends with not enough data, utf8', 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.text, 'foobar')
     assert.deepEqual(error.chunk, Buffer.from('foobar'))
   })
+
+  it('throws if stream ends with not enough data, non utf8 ', async () => {
+    const source = [Buffer.alloc(10, 128), Buffer.alloc(10, 128)]
+    const error = await rejectionOf(readChunkStrict(makeStream(source), 30))
+    assert(error instanceof Error)
+    assert.strictEqual(error.message, 'stream has ended with not enough data (actual: 20, expected: 30)')
+    assert.strictEqual(error.text, undefined)
+    assert.deepEqual(error.chunk, Buffer.concat(source))
+  })
+
+  it('throws if stream ends with not enough data,  utf8 , long data', async () => {
+    const source = Buffer.from('a'.repeat(1500))
+    const error = await rejectionOf(readChunkStrict(makeStream([source]), 2000))
+    assert(error instanceof Error)
+    assert.strictEqual(error.message, `stream has ended with not enough data (actual: 1500, expected: 2000)`)
+    assert.strictEqual(error.text, undefined)
+    assert.deepEqual(error.chunk, source)
+  })
+
+  it('succeed', async () => {
+    const source = Buffer.from('a'.repeat(20))
+    const chunk = await readChunkStrict(makeStream([source]), 10)
+    assert.deepEqual(source.subarray(10), chunk)
+  })
 })
 
 describe('skip', function () {
@@ -134,6 +159,16 @@ describe('skip', function () {
   it('returns less size if stream ends', async () => {
     assert.deepEqual(await skip(makeStream('foo bar'), 10), 7)
   })
+
+  it('put back if it read too much', async () => {
+    let source = makeStream(['foo', 'bar'])
+    await skip(source, 1) // read part of data chunk
+    const chunk = (await readChunkStrict(source, 2)).toString('utf-8')
+    assert.strictEqual(chunk, 'oo')
+
+    source = makeStream(['foo', 'bar'])
+    assert.strictEqual(await skip(source, 3), 3) // read aligned with data chunk
+  })
 })
 
 describe('skipStrict', function () {
@@ -144,4 +179,9 @@ describe('skipStrict', function () {
     assert.strictEqual(error.message, 'stream has ended with not enough data (actual: 7, expected: 10)')
     assert.deepEqual(error.bytesSkipped, 7)
   })
+  it('succeed', async () => {
+    const source = makeStream(['foo', 'bar', 'baz'])
+    const res = await skipStrict(source, 4)
+    assert.strictEqual(res, undefined)
+  })
 })

@vates/read-chunk/package.json

@@ -33,5 +33,8 @@
   },
   "devDependencies": {
     "test": "^3.2.1"
+  },
+  "dependencies": {
+    "isutf8": "^4.0.0"
   }
 }

@vates/task/package.json

@@ -13,7 +13,7 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "engines": {
     "node": ">=14"
   },

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

@@ -1,5 +1,5 @@
 import { asyncMap } from '@xen-orchestra/async-map'
-import { RemoteAdapter } from '@xen-orchestra/backups/RemoteAdapter.js'
+import { RemoteAdapter } from '@xen-orchestra/backups/RemoteAdapter.mjs'
 import { getSyncedHandler } from '@xen-orchestra/fs'
 import getopts from 'getopts'
 import { basename, dirname } from 'path'

@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.38.2",
-    "@xen-orchestra/fs": "^4.0.0",
+    "@xen-orchestra/backups": "^0.39.0",
+    "@xen-orchestra/fs": "^4.0.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.8",
+  "version": "1.0.9",
   "license": "AGPL-3.0-or-later",
   "author": {
     "name": "Vates SAS",

@xen-orchestra/backups/Backup.mjs

@@ -1,10 +1,8 @@
-'use strict'
+import { Metadata } from './_runners/Metadata.mjs'
+import { VmsRemote } from './_runners/VmsRemote.mjs'
+import { VmsXapi } from './_runners/VmsXapi.mjs'
 
-const { Metadata } = require('./_runners/Metadata.js')
-const { VmsRemote } = require('./_runners/VmsRemote.js')
-const { VmsXapi } = require('./_runners/VmsXapi.js')
-
-exports.createRunner = function createRunner(opts) {
+export function createRunner(opts) {
   const { type } = opts.job
   switch (type) {
     case 'backup':

@xen-orchestra/backups/DurablePartition.mjs

@@ -1,8 +1,6 @@
-'use strict'
+import { asyncMap } from '@xen-orchestra/async-map'
 
-const { asyncMap } = require('@xen-orchestra/async-map')
-
-exports.DurablePartition = class DurablePartition {
+export class DurablePartition {
   // private resource API is used exceptionally to be able to separate resource creation and release
   #partitionDisposers = {}
 

@xen-orchestra/backups/HealthCheckVmBackup.mjs

@@ -1,8 +1,6 @@
-'use strict'
+import { Task } from './Task.mjs'
 
-const { Task } = require('./Task')
-
-exports.HealthCheckVmBackup = class HealthCheckVmBackup {
+export class HealthCheckVmBackup {
   #restoredVm
   #timeout
   #xapi

@xen-orchestra/backups/ImportVmBackup.mjs

@@ -1,13 +1,11 @@
-'use strict'
+import assert from 'node:assert'
 
-const assert = require('assert')
+import { formatFilenameDate } from './_filenameDate.mjs'
+import { importIncrementalVm } from './_incrementalVm.mjs'
+import { Task } from './Task.mjs'
+import { watchStreamSize } from './_watchStreamSize.mjs'
 
-const { formatFilenameDate } = require('./_filenameDate.js')
-const { importIncrementalVm } = require('./_incrementalVm.js')
-const { Task } = require('./Task.js')
-const { watchStreamSize } = require('./_watchStreamSize.js')
-
-exports.ImportVmBackup = class ImportVmBackup {
+export class ImportVmBackup {
   constructor({ adapter, metadata, srUuid, xapi, settings: { newMacAddresses, mapVdisSrs = {} } = {} }) {
     this._adapter = adapter
     this._importIncrementalVmSettings = { newMacAddresses, mapVdisSrs }

@xen-orchestra/backups/RemoteAdapter.mjs

@@ -1,43 +1,38 @@
-'use strict'
+import { asyncEach } from '@vates/async-each'
+import { asyncMap, asyncMapSettled } from '@xen-orchestra/async-map'
+import { compose } from '@vates/compose'
+import { createLogger } from '@xen-orchestra/log'
+import { createVhdDirectoryFromStream, openVhd, VhdAbstract, VhdDirectory, VhdSynthetic } from 'vhd-lib'
+import { decorateMethodsWith } from '@vates/decorate-with'
+import { deduped } from '@vates/disposable/deduped.js'
+import { dirname, join, normalize, resolve } from 'node:path'
+import { execFile } from 'child_process'
+import { mount } from '@vates/fuse-vhd'
+import { readdir, lstat } from 'node:fs/promises'
+import { synchronized } from 'decorator-synchronized'
+import { v4 as uuidv4 } from 'uuid'
+import { ZipFile } from 'yazl'
+import Disposable from 'promise-toolbox/Disposable'
+import fromCallback from 'promise-toolbox/fromCallback'
+import fromEvent from 'promise-toolbox/fromEvent'
+import groupBy from 'lodash/groupBy.js'
+import pDefer from 'promise-toolbox/defer'
+import pickBy from 'lodash/pickBy.js'
+import zlib from 'zlib'
 
-const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
-const { synchronized } = require('decorator-synchronized')
-const Disposable = require('promise-toolbox/Disposable')
-const fromCallback = require('promise-toolbox/fromCallback')
-const fromEvent = require('promise-toolbox/fromEvent')
-const pDefer = require('promise-toolbox/defer')
-const groupBy = require('lodash/groupBy.js')
-const pickBy = require('lodash/pickBy.js')
-const { dirname, join, normalize, resolve } = require('path')
-const { createLogger } = require('@xen-orchestra/log')
-const { createVhdDirectoryFromStream, openVhd, VhdAbstract, VhdDirectory, VhdSynthetic } = require('vhd-lib')
-const { deduped } = require('@vates/disposable/deduped.js')
-const { decorateMethodsWith } = require('@vates/decorate-with')
-const { compose } = require('@vates/compose')
-const { execFile } = require('child_process')
-const { readdir, lstat } = require('fs-extra')
-const { v4: uuidv4 } = require('uuid')
-const { ZipFile } = require('yazl')
-const zlib = require('zlib')
+import { BACKUP_DIR } from './_getVmBackupDir.mjs'
+import { cleanVm } from './_cleanVm.mjs'
+import { formatFilenameDate } from './_filenameDate.mjs'
+import { getTmpDir } from './_getTmpDir.mjs'
+import { isMetadataFile } from './_backupType.mjs'
+import { isValidXva } from './_isValidXva.mjs'
+import { listPartitions, LVM_PARTITION_TYPE } from './_listPartitions.mjs'
+import { lvs, pvs } from './_lvm.mjs'
+import { watchStreamSize } from './_watchStreamSize.mjs'
 
-const { BACKUP_DIR } = require('./_getVmBackupDir.js')
-const { cleanVm } = require('./_cleanVm.js')
-const { formatFilenameDate } = require('./_filenameDate.js')
-const { getTmpDir } = require('./_getTmpDir.js')
-const { isMetadataFile } = require('./_backupType.js')
-const { isValidXva } = require('./_isValidXva.js')
-const { listPartitions, LVM_PARTITION_TYPE } = require('./_listPartitions.js')
-const { lvs, pvs } = require('./_lvm.js')
-const { watchStreamSize } = require('./_watchStreamSize')
-// @todo : this import is marked extraneous , sould be fixed when lib is published
-const { mount } = require('@vates/fuse-vhd')
-const { asyncEach } = require('@vates/async-each')
+export const DIR_XO_CONFIG_BACKUPS = 'xo-config-backups'
 
-const DIR_XO_CONFIG_BACKUPS = 'xo-config-backups'
-exports.DIR_XO_CONFIG_BACKUPS = DIR_XO_CONFIG_BACKUPS
-
-const DIR_XO_POOL_METADATA_BACKUPS = 'xo-pool-metadata-backups'
-exports.DIR_XO_POOL_METADATA_BACKUPS = DIR_XO_POOL_METADATA_BACKUPS
+export const DIR_XO_POOL_METADATA_BACKUPS = 'xo-pool-metadata-backups'
 
 const { debug, warn } = createLogger('xo:backups:RemoteAdapter')
 
@@ -76,7 +71,7 @@ const debounceResourceFactory = factory =>
     return this._debounceResource(factory.apply(this, arguments))
   }
 
-class RemoteAdapter {
+export class RemoteAdapter {
   constructor(
     handler,
     { debounceResource = res => res, dirMode, vhdDirectoryCompression, useGetDiskLegacy = false } = {}
@@ -835,5 +830,3 @@ decorateMethodsWith(RemoteAdapter, {
 
   getPartition: Disposable.factory,
 })
-
-exports.RemoteAdapter = RemoteAdapter

@xen-orchestra/backups/RestoreMetadataBackup.mjs

@@ -1,9 +1,9 @@
-'use strict'
+import { join, resolve } from 'node:path/posix'
 
-const { DIR_XO_POOL_METADATA_BACKUPS } = require('./RemoteAdapter.js')
-const { PATH_DB_DUMP } = require('./_runners/_PoolMetadataBackup.js')
+import { DIR_XO_POOL_METADATA_BACKUPS } from './RemoteAdapter.mjs'
+import { PATH_DB_DUMP } from './_runners/_PoolMetadataBackup.mjs'
 
-exports.RestoreMetadataBackup = class RestoreMetadataBackup {
+export class RestoreMetadataBackup {
   constructor({ backupId, handler, xapi }) {
     this._backupId = backupId
     this._handler = handler
@@ -20,7 +20,8 @@ exports.RestoreMetadataBackup = class RestoreMetadataBackup {
         task: xapi.task_create('Import pool metadata'),
       })
     } else {
-      return String(await handler.readFile(`${backupId}/data.json`))
+      const metadata = JSON.parse(await handler.readFile(join(backupId, 'metadata.json')))
+      return String(await handler.readFile(resolve(backupId, metadata.data ?? 'data.json')))
     }
   }
 }

@xen-orchestra/backups/Task.mjs

@@ -1,7 +1,5 @@
-'use strict'
-
-const CancelToken = require('promise-toolbox/CancelToken')
-const Zone = require('node-zone')
+import CancelToken from 'promise-toolbox/CancelToken'
+import Zone from 'node-zone'
 
 const logAfterEnd = log => {
   const error = new Error('task has already ended')
@@ -30,7 +28,7 @@ const serializeError = error =>
 
 const $$task = Symbol('@xen-orchestra/backups/Task')
 
-class Task {
+export class Task {
   static get cancelToken() {
     const task = Zone.current.data[$$task]
     return task !== undefined ? task.#cancelToken : CancelToken.none
@@ -151,7 +149,6 @@ class Task {
     })
   }
 }
-exports.Task = Task
 
 for (const method of ['info', 'warning']) {
   Task[method] = (...args) => Zone.current.data[$$task]?.[method](...args)

@xen-orchestra/backups/_backupType.js

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

@xen-orchestra/backups/_backupType.mjs

@@ -0,0 +1,4 @@
+export const isMetadataFile = filename => filename.endsWith('.json')
+export const isVhdFile = filename => filename.endsWith('.vhd')
+export const isXvaFile = filename => filename.endsWith('.xva')
+export const isXvaSumFile = filename => filename.endsWith('.xva.checksum')

@xen-orchestra/backups/_backupWorker.mjs

@@ -1,25 +1,25 @@
-'use strict'
+import { createLogger } from '@xen-orchestra/log'
+import { catchGlobalErrors } from '@xen-orchestra/log/configure'
 
-const logger = require('@xen-orchestra/log').createLogger('xo:backups:worker')
+import Disposable from 'promise-toolbox/Disposable'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
+import { compose } from '@vates/compose'
+import { createCachedLookup } from '@vates/cached-dns.lookup'
+import { createDebounceResource } from '@vates/disposable/debounceResource.js'
+import { createRunner } from './Backup.mjs'
+import { decorateMethodsWith } from '@vates/decorate-with'
+import { deduped } from '@vates/disposable/deduped.js'
+import { getHandler } from '@xen-orchestra/fs'
+import { parseDuration } from '@vates/parse-duration'
+import { Xapi } from '@xen-orchestra/xapi'
 
-require('@xen-orchestra/log/configure').catchGlobalErrors(logger)
+import { RemoteAdapter } from './RemoteAdapter.mjs'
+import { Task } from './Task.mjs'
 
-require('@vates/cached-dns.lookup').createCachedLookup().patchGlobal()
-
-const Disposable = require('promise-toolbox/Disposable')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
-const { compose } = require('@vates/compose')
-const { createDebounceResource } = require('@vates/disposable/debounceResource.js')
-const { decorateMethodsWith } = require('@vates/decorate-with')
-const { deduped } = require('@vates/disposable/deduped.js')
-const { getHandler } = require('@xen-orchestra/fs')
-const { createRunner } = require('./Backup.js')
-const { parseDuration } = require('@vates/parse-duration')
-const { Xapi } = require('@xen-orchestra/xapi')
-
-const { RemoteAdapter } = require('./RemoteAdapter.js')
-const { Task } = require('./Task.js')
+createCachedLookup().patchGlobal()
 
+const logger = createLogger('xo:backups:worker')
+catchGlobalErrors(logger)
 const { debug } = logger
 
 class BackupWorker {

@xen-orchestra/backups/_cancelableMap.mjs

@@ -1,13 +1,11 @@
-'use strict'
-
-const cancelable = require('promise-toolbox/cancelable')
-const CancelToken = require('promise-toolbox/CancelToken')
+import cancelable from 'promise-toolbox/cancelable'
+import CancelToken from 'promise-toolbox/CancelToken'
 
 // Similar to `Promise.all` + `map` but pass a cancel token to the callback
 //
 // If any of the executions fails, the cancel token will be triggered and the
 // first reason will be rejected.
-exports.cancelableMap = cancelable(async function cancelableMap($cancelToken, iterable, callback) {
+export const cancelableMap = cancelable(async function cancelableMap($cancelToken, iterable, callback) {
   const { cancel, token } = CancelToken.source([$cancelToken])
   try {
     return await Promise.all(

@xen-orchestra/backups/_cleanVm.integ.mjs

@@ -1,19 +1,19 @@
-'use strict'
+import test from 'test'
+import { strict as assert } from 'node:assert'
 
-const { beforeEach, afterEach, test, describe } = require('test')
-const assert = require('assert').strict
+import tmp from 'tmp'
+import fs from 'fs-extra'
+import * as uuid from 'uuid'
+import { getHandler } from '@xen-orchestra/fs'
+import { pFromCallback } from 'promise-toolbox'
+import { RemoteAdapter } from './RemoteAdapter.mjs'
+import { VHDFOOTER, VHDHEADER } from './tests.fixtures.mjs'
+import { VhdFile, Constants, VhdDirectory, VhdAbstract } from 'vhd-lib'
+import { checkAliases } from './_cleanVm.mjs'
+import { dirname, basename } from 'node:path'
+import { rimraf } from 'rimraf'
 
-const tmp = require('tmp')
-const fs = require('fs-extra')
-const uuid = require('uuid')
-const { getHandler } = require('@xen-orchestra/fs')
-const { pFromCallback } = require('promise-toolbox')
-const { RemoteAdapter } = require('./RemoteAdapter')
-const { VHDFOOTER, VHDHEADER } = require('./tests.fixtures.js')
-const { VhdFile, Constants, VhdDirectory, VhdAbstract } = require('vhd-lib')
-const { checkAliases } = require('./_cleanVm')
-const { dirname, basename } = require('path')
-const { rimraf } = require('rimraf')
+const { beforeEach, afterEach, describe } = test
 
 let tempDir, adapter, handler, jobId, vdiId, basePath, relativePath
 const rootPath = 'xo-vm-backups/VMUUID/'

@xen-orchestra/backups/_cleanVm.mjs

@@ -1,19 +1,18 @@
-'use strict'
+import * as UUID from 'uuid'
+import sum from 'lodash/sum.js'
+import { asyncMap } from '@xen-orchestra/async-map'
+import { Constants, openVhd, VhdAbstract, VhdFile } from 'vhd-lib'
+import { isVhdAlias, resolveVhdAlias } from 'vhd-lib/aliases.js'
+import { dirname, resolve } from 'node:path'
+import { isMetadataFile, isVhdFile, isXvaFile, isXvaSumFile } from './_backupType.mjs'
+import { limitConcurrency } from 'limit-concurrency-decorator'
+import { mergeVhdChain } from 'vhd-lib/merge.js'
+
+import { Task } from './Task.mjs'
+import { Disposable } from 'promise-toolbox'
+import handlerPath from '@xen-orchestra/fs/path'
 
-const sum = require('lodash/sum')
-const UUID = require('uuid')
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { Constants, openVhd, VhdAbstract, VhdFile } = require('vhd-lib')
-const { isVhdAlias, resolveVhdAlias } = require('vhd-lib/aliases')
-const { dirname, resolve } = require('path')
 const { DISK_TYPES } = Constants
-const { isMetadataFile, isVhdFile, isXvaFile, isXvaSumFile } = require('./_backupType.js')
-const { limitConcurrency } = require('limit-concurrency-decorator')
-const { mergeVhdChain } = require('vhd-lib/merge')
-
-const { Task } = require('./Task.js')
-const { Disposable } = require('promise-toolbox')
-const handlerPath = require('@xen-orchestra/fs/path')
 
 // checking the size of a vhd directory is costly
 // 1 Http Query per 1000 blocks
@@ -117,7 +116,7 @@ const listVhds = async (handler, vmDir, logWarn) => {
   return { vhds, interruptedVhds, aliases }
 }
 
-async function checkAliases(
+export async function checkAliases(
   aliasPaths,
   targetDataRepository,
   { handler, logInfo = noop, logWarn = console.warn, remove = false }
@@ -176,11 +175,9 @@ async function checkAliases(
   })
 }
 
-exports.checkAliases = checkAliases
-
 const defaultMergeLimiter = limitConcurrency(1)
 
-exports.cleanVm = async function cleanVm(
+export async function cleanVm(
   vmDir,
   {
     fixMetadata,

@xen-orchestra/backups/_filenameDate.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const { utcFormat, utcParse } = require('d3-time-format')
-
-// Format a date in ISO 8601 in a safe way to be used in filenames
-// (even on Windows).
-exports.formatFilenameDate = utcFormat('%Y%m%dT%H%M%SZ')
-exports.parseFilenameDate = utcParse('%Y%m%dT%H%M%SZ')

@xen-orchestra/backups/_filenameDate.mjs

@@ -0,0 +1,6 @@
+import { utcFormat, utcParse } from 'd3-time-format'
+
+// Format a date in ISO 8601 in a safe way to be used in filenames
+// (even on Windows).
+export const formatFilenameDate = utcFormat('%Y%m%dT%H%M%SZ')
+export const parseFilenameDate = utcParse('%Y%m%dT%H%M%SZ')

@xen-orchestra/backups/_getOldEntries.mjs

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

@xen-orchestra/backups/_getTmpDir.mjs

@@ -1,13 +1,11 @@
-'use strict'
-
-const Disposable = require('promise-toolbox/Disposable')
-const { join } = require('path')
-const { mkdir, rmdir } = require('fs-extra')
-const { tmpdir } = require('os')
+import Disposable from 'promise-toolbox/Disposable'
+import { join } from 'node:path'
+import { mkdir, rmdir } from 'node:fs/promises'
+import { tmpdir } from 'os'
 
 const MAX_ATTEMPTS = 3
 
-exports.getTmpDir = async function getTmpDir() {
+export async function getTmpDir() {
   for (let i = 0; true; ++i) {
     const path = join(tmpdir(), Math.random().toString(36).slice(2))
     try {

@xen-orchestra/backups/_getVmBackupDir.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const BACKUP_DIR = 'xo-vm-backups'
-exports.BACKUP_DIR = BACKUP_DIR
-
-exports.getVmBackupDir = function getVmBackupDir(uuid) {
-  return `${BACKUP_DIR}/${uuid}`
-}

@xen-orchestra/backups/_getVmBackupDir.mjs

@@ -0,0 +1,5 @@
+export const BACKUP_DIR = 'xo-vm-backups'
+
+export function getVmBackupDir(uuid) {
+  return `${BACKUP_DIR}/${uuid}`
+}

@xen-orchestra/backups/_incrementalVm.mjs

@@ -1,24 +1,20 @@
-'use strict'
+import find from 'lodash/find.js'
+import groupBy from 'lodash/groupBy.js'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
+import omit from 'lodash/omit.js'
+import { asyncMap } from '@xen-orchestra/async-map'
+import { CancelToken } from 'promise-toolbox'
+import { compareVersions } from 'compare-versions'
+import { createVhdStreamWithLength } from 'vhd-lib'
+import { defer } from 'golike-defer'
 
-const find = require('lodash/find.js')
-const groupBy = require('lodash/groupBy.js')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
-const omit = require('lodash/omit.js')
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { CancelToken } = require('promise-toolbox')
-const { compareVersions } = require('compare-versions')
-const { createVhdStreamWithLength } = require('vhd-lib')
-const { defer } = require('golike-defer')
+import { cancelableMap } from './_cancelableMap.mjs'
+import { Task } from './Task.mjs'
+import pick from 'lodash/pick.js'
 
-const { cancelableMap } = require('./_cancelableMap.js')
-const { Task } = require('./Task.js')
-const pick = require('lodash/pick.js')
+export const TAG_BASE_DELTA = 'xo:base_delta'
 
-const TAG_BASE_DELTA = 'xo:base_delta'
-exports.TAG_BASE_DELTA = TAG_BASE_DELTA
-
-const TAG_COPY_SRC = 'xo:copy_of'
-exports.TAG_COPY_SRC = TAG_COPY_SRC
+export const TAG_COPY_SRC = 'xo:copy_of'
 
 const ensureArray = value => (value === undefined ? [] : Array.isArray(value) ? value : [value])
 const resolveUuid = async (xapi, cache, uuid, type) => {
@@ -33,7 +29,7 @@ const resolveUuid = async (xapi, cache, uuid, type) => {
   return ref
 }
 
-exports.exportIncrementalVm = async function exportIncrementalVm(
+export async function exportIncrementalVm(
   vm,
   baseVm,
   {
@@ -143,7 +139,7 @@ exports.exportIncrementalVm = async function exportIncrementalVm(
   )
 }
 
-exports.importIncrementalVm = defer(async function importIncrementalVm(
+export const importIncrementalVm = defer(async function importIncrementalVm(
   $defer,
   incrementalVm,
   sr,

@xen-orchestra/backups/_isValidXva.mjs

@@ -1,6 +1,4 @@
-'use strict'
-
-const assert = require('assert')
+import assert from 'node:assert'
 
 const COMPRESSED_MAGIC_NUMBERS = [
   // https://tools.ietf.org/html/rfc1952.html#page-5
@@ -47,7 +45,7 @@ const isValidTar = async (handler, size, fd) => {
 }
 
 // TODO: find an heuristic for compressed files
-async function isValidXva(path) {
+export async function isValidXva(path) {
   const handler = this._handler
 
   // size is longer when encrypted  + reading part of an encrypted file is not implemented
@@ -74,6 +72,5 @@ async function isValidXva(path) {
     return true
   }
 }
-exports.isValidXva = isValidXva
 
 const noop = Function.prototype

@xen-orchestra/backups/_listPartitions.mjs

@@ -1,9 +1,7 @@
-'use strict'
-
-const fromCallback = require('promise-toolbox/fromCallback')
-const { createLogger } = require('@xen-orchestra/log')
-const { createParser } = require('parse-pairs')
-const { execFile } = require('child_process')
+import fromCallback from 'promise-toolbox/fromCallback'
+import { createLogger } from '@xen-orchestra/log'
+import { createParser } from 'parse-pairs'
+import { execFile } from 'child_process'
 
 const { debug } = createLogger('xo:backups:listPartitions')
 
@@ -24,8 +22,7 @@ const IGNORED_PARTITION_TYPES = {
   0x82: true, // swap
 }
 
-const LVM_PARTITION_TYPE = 0x8e
-exports.LVM_PARTITION_TYPE = LVM_PARTITION_TYPE
+export const LVM_PARTITION_TYPE = 0x8e
 
 const parsePartxLine = createParser({
   keyTransform: key => (key === 'UUID' ? 'id' : key.toLowerCase()),
@@ -33,7 +30,7 @@ const parsePartxLine = createParser({
 })
 
 // returns an empty array in case of a non-partitioned disk
-exports.listPartitions = async function listPartitions(devicePath) {
+export async function listPartitions(devicePath) {
   const parts = await fromCallback(execFile, 'partx', [
     '--bytes',
     '--output=NR,START,SIZE,NAME,UUID,TYPE',

@xen-orchestra/backups/_lvm.mjs

@@ -1,8 +1,6 @@
-'use strict'
-
-const fromCallback = require('promise-toolbox/fromCallback')
-const { createParser } = require('parse-pairs')
-const { execFile } = require('child_process')
+import fromCallback from 'promise-toolbox/fromCallback'
+import { createParser } from 'parse-pairs'
+import { execFile } from 'child_process'
 
 // ===================================================================
 
@@ -29,5 +27,5 @@ const makeFunction =
       .map(Array.isArray(fields) ? parse : line => parse(line)[fields])
   }
 
-exports.lvs = makeFunction('lvs')
-exports.pvs = makeFunction('pvs')
+export const lvs = makeFunction('lvs')
+export const pvs = makeFunction('pvs')

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

@@ -1,22 +1,20 @@
-'use strict'
+import { asyncMap } from '@xen-orchestra/async-map'
+import Disposable from 'promise-toolbox/Disposable'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
 
-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')
+import { extractIdsFromSimplePattern } from '../extractIdsFromSimplePattern.mjs'
+import { PoolMetadataBackup } from './_PoolMetadataBackup.mjs'
+import { XoMetadataBackup } from './_XoMetadataBackup.mjs'
+import { DEFAULT_SETTINGS, Abstract } from './_Abstract.mjs'
+import { runTask } from './_runTask.mjs'
+import { getAdaptersByRemote } from './_getAdaptersByRemote.mjs'
 
 const DEFAULT_METADATA_SETTINGS = {
   retentionPoolMetadata: 0,
   retentionXoMetadata: 0,
 }
 
-exports.Metadata = class MetadataBackupRunner extends Abstract {
+export const Metadata = class MetadataBackupRunner extends Abstract {
   _computeBaseSettings(config, job) {
     const baseSettings = { ...DEFAULT_SETTINGS }
     Object.assign(baseSettings, DEFAULT_METADATA_SETTINGS, config.defaultSettings, config.metadata?.defaultSettings)

@xen-orchestra/backups/_runners/VmsRemote.mjs

@@ -1,17 +1,15 @@
-'use strict'
+import { asyncMapSettled } from '@xen-orchestra/async-map'
+import Disposable from 'promise-toolbox/Disposable'
+import { limitConcurrency } from 'limit-concurrency-decorator'
 
-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 { FullRemote } = require('./_vmRunners/FullRemote.js')
-const { IncrementalRemote } = require('./_vmRunners/IncrementalRemote.js')
+import { extractIdsFromSimplePattern } from '../extractIdsFromSimplePattern.mjs'
+import { Task } from '../Task.mjs'
+import createStreamThrottle from './_createStreamThrottle.mjs'
+import { DEFAULT_SETTINGS, Abstract } from './_Abstract.mjs'
+import { runTask } from './_runTask.mjs'
+import { getAdaptersByRemote } from './_getAdaptersByRemote.mjs'
+import { FullRemote } from './_vmRunners/FullRemote.mjs'
+import { IncrementalRemote } from './_vmRunners/IncrementalRemote.mjs'
 
 const DEFAULT_REMOTE_VM_SETTINGS = {
   concurrency: 2,
@@ -27,7 +25,7 @@ const DEFAULT_REMOTE_VM_SETTINGS = {
   vmTimeout: 0,
 }
 
-exports.VmsRemote = class RemoteVmsBackupRunner extends Abstract {
+export const VmsRemote = class RemoteVmsBackupRunner extends Abstract {
   _computeBaseSettings(config, job) {
     const baseSettings = { ...DEFAULT_SETTINGS }
     Object.assign(baseSettings, DEFAULT_REMOTE_VM_SETTINGS, config.defaultSettings, config.vm?.defaultSettings)

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

@@ -1,17 +1,15 @@
-'use strict'
+import { asyncMapSettled } from '@xen-orchestra/async-map'
+import Disposable from 'promise-toolbox/Disposable'
+import { limitConcurrency } from 'limit-concurrency-decorator'
 
-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')
+import { extractIdsFromSimplePattern } from '../extractIdsFromSimplePattern.mjs'
+import { Task } from '../Task.mjs'
+import createStreamThrottle from './_createStreamThrottle.mjs'
+import { DEFAULT_SETTINGS, Abstract } from './_Abstract.mjs'
+import { runTask } from './_runTask.mjs'
+import { getAdaptersByRemote } from './_getAdaptersByRemote.mjs'
+import { IncrementalXapi } from './_vmRunners/IncrementalXapi.mjs'
+import { FullXapi } from './_vmRunners/FullXapi.mjs'
 
 const DEFAULT_XAPI_VM_SETTINGS = {
   bypassVdiChainsCheck: false,
@@ -19,6 +17,7 @@ const DEFAULT_XAPI_VM_SETTINGS = {
   concurrency: 2,
   copyRetention: 0,
   deleteFirst: false,
+  diskPerVmConcurrency: 0, // not limited by default
   exportRetention: 0,
   fullInterval: 0,
   healthCheckSr: undefined,
@@ -35,7 +34,7 @@ const DEFAULT_XAPI_VM_SETTINGS = {
   vmTimeout: 0,
 }
 
-exports.VmsXapi = class VmsXapiBackupRunner extends Abstract {
+export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
   _computeBaseSettings(config, job) {
     const baseSettings = { ...DEFAULT_SETTINGS }
     Object.assign(baseSettings, DEFAULT_XAPI_VM_SETTINGS, config.defaultSettings, config.vm?.defaultSettings)

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

@@ -1,17 +1,15 @@
-'use strict'
+import Disposable from 'promise-toolbox/Disposable'
+import pTimeout from 'promise-toolbox/timeout'
+import { compileTemplate } from '@xen-orchestra/template'
+import { runTask } from './_runTask.mjs'
+import { RemoteTimeoutError } from './_RemoteTimeoutError.mjs'
 
-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 = {
+export const DEFAULT_SETTINGS = {
   getRemoteTimeout: 300e3,
   reportWhen: 'failure',
 }
 
-exports.Abstract = class AbstractRunner {
+export const Abstract = class AbstractRunner {
   constructor({ config, getAdapter, getConnectedRecord, job, schedule }) {
     this._config = config
     this._getRecord = getConnectedRecord

@xen-orchestra/backups/_runners/_PoolMetadataBackup.mjs

@@ -1,16 +1,13 @@
-'use strict'
+import { asyncMap } from '@xen-orchestra/async-map'
 
-const { asyncMap } = require('@xen-orchestra/async-map')
+import { DIR_XO_POOL_METADATA_BACKUPS } from '../RemoteAdapter.mjs'
+import { forkStreamUnpipe } from './_forkStreamUnpipe.mjs'
+import { formatFilenameDate } from '../_filenameDate.mjs'
+import { Task } from '../Task.mjs'
 
-const { DIR_XO_POOL_METADATA_BACKUPS } = require('../RemoteAdapter.js')
-const { forkStreamUnpipe } = require('./_forkStreamUnpipe.js')
-const { formatFilenameDate } = require('../_filenameDate.js')
-const { Task } = require('../Task.js')
+export const PATH_DB_DUMP = '/pool/xmldbdump'
 
-const PATH_DB_DUMP = '/pool/xmldbdump'
-exports.PATH_DB_DUMP = PATH_DB_DUMP
-
-exports.PoolMetadataBackup = class PoolMetadataBackup {
+export class PoolMetadataBackup {
   constructor({ config, job, pool, remoteAdapters, schedule, settings }) {
     this._config = config
     this._job = job

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

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

@xen-orchestra/backups/_runners/_XoMetadataBackup.mjs

@@ -1,12 +1,11 @@
-'use strict'
+import { asyncMap } from '@xen-orchestra/async-map'
+import { join } from '@xen-orchestra/fs/path'
 
-const { asyncMap } = require('@xen-orchestra/async-map')
+import { DIR_XO_CONFIG_BACKUPS } from '../RemoteAdapter.mjs'
+import { formatFilenameDate } from '../_filenameDate.mjs'
+import { Task } from '../Task.mjs'
 
-const { DIR_XO_CONFIG_BACKUPS } = require('../RemoteAdapter.js')
-const { formatFilenameDate } = require('../_filenameDate.js')
-const { Task } = require('../Task.js')
-
-exports.XoMetadataBackup = class XoMetadataBackup {
+export class XoMetadataBackup {
   constructor({ config, job, remoteAdapters, schedule, settings }) {
     this._config = config
     this._job = job
@@ -23,10 +22,11 @@ exports.XoMetadataBackup = class XoMetadataBackup {
     const dir = `${scheduleDir}/${formatFilenameDate(timestamp)}`
 
     const data = job.xoMetadata
-    const fileName = `${dir}/data.json`
+    const dataBaseName = './data.json'
 
     const metadata = JSON.stringify(
       {
+        data: dataBaseName,
         jobId: job.id,
         jobName: job.name,
         scheduleId: schedule.id,
@@ -36,6 +36,8 @@ exports.XoMetadataBackup = class XoMetadataBackup {
       null,
       2
     )
+
+    const dataFileName = join(dir, dataBaseName)
     const metaDataFileName = `${dir}/metadata.json`
 
     await asyncMap(
@@ -52,7 +54,7 @@ exports.XoMetadataBackup = class XoMetadataBackup {
           async () => {
             const handler = adapter.handler
             const dirMode = this._config.dirMode
-            await handler.outputFile(fileName, data, { dirMode })
+            await handler.outputFile(dataFileName, data, { dirMode })
             await handler.outputFile(metaDataFileName, metadata, {
               dirMode,
             })

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

@@ -1,12 +1,10 @@
-'use strict'
-
-const { pipeline } = require('node:stream')
-const { ThrottleGroup } = require('@kldzj/stream-throttle')
-const identity = require('lodash/identity.js')
+import { pipeline } from 'node:stream'
+import { ThrottleGroup } from '@kldzj/stream-throttle'
+import identity from 'lodash/identity.js'
 
 const noop = Function.prototype
 
-module.exports = function createStreamThrottle(rate) {
+export default function createStreamThrottle(rate) {
   if (rate === 0) {
     return identity
   }

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

@@ -1,14 +1,13 @@
-'use strict'
+import { createLogger } from '@xen-orchestra/log'
+import { finished, PassThrough } from 'node:stream'
 
-const { finished, PassThrough } = require('node:stream')
-
-const { debug } = require('@xen-orchestra/log').createLogger('xo:backups:forkStreamUnpipe')
+const { debug } = 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) {
+export function forkStreamUnpipe(source) {
   const { forks = 0 } = source
   source.forks = forks + 1
 

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

@@ -1,9 +1,7 @@
-'use strict'
-const getAdaptersByRemote = adapters => {
+export function 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/_runTask.mjs

@@ -0,0 +1,5 @@
+import { Task } from '../Task.mjs'
+
+const noop = Function.prototype
+
+export const runTask = (...args) => Task.run(...args).catch(noop) // errors are handled by logs

@xen-orchestra/backups/_runners/_vmRunners/FullRemote.mjs

@@ -1,14 +1,12 @@
-'use strict'
+import { decorateMethodsWith } from '@vates/decorate-with'
+import { defer } from 'golike-defer'
+import { AbstractRemote } from './_AbstractRemote.mjs'
+import { FullRemoteWriter } from '../_writers/FullRemoteWriter.mjs'
+import { forkStreamUnpipe } from '../_forkStreamUnpipe.mjs'
+import { watchStreamSize } from '../../_watchStreamSize.mjs'
+import { Task } from '../../Task.mjs'
 
-const { decorateMethodsWith } = require('@vates/decorate-with')
-const { defer } = require('golike-defer')
-const { AbstractRemote } = require('./_AbstractRemote')
-const { FullRemoteWriter } = require('../_writers/FullRemoteWriter')
-const { forkStreamUnpipe } = require('../_forkStreamUnpipe')
-const { watchStreamSize } = require('../../_watchStreamSize')
-const { Task } = require('../../Task')
-
-class FullRemoteVmBackupRunner extends AbstractRemote {
+export const FullRemote = class FullRemoteVmBackupRunner extends AbstractRemote {
   _getRemoteWriter() {
     return FullRemoteWriter
   }
@@ -47,7 +45,6 @@ class FullRemoteVmBackupRunner extends AbstractRemote {
   }
 }
 
-exports.FullRemote = FullRemoteVmBackupRunner
-decorateMethodsWith(FullRemoteVmBackupRunner, {
+decorateMethodsWith(FullRemote, {
   _run: defer,
 })

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

@@ -1,16 +1,14 @@
-'use strict'
+import { createLogger } from '@xen-orchestra/log'
 
-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')
+import { forkStreamUnpipe } from '../_forkStreamUnpipe.mjs'
+import { FullRemoteWriter } from '../_writers/FullRemoteWriter.mjs'
+import { FullXapiWriter } from '../_writers/FullXapiWriter.mjs'
+import { watchStreamSize } from '../../_watchStreamSize.mjs'
+import { AbstractXapi } from './_AbstractXapi.mjs'
 
 const { debug } = createLogger('xo:backups:FullXapiVmBackup')
 
-exports.FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
+export const FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
   _getWriters() {
     return [FullRemoteWriter, FullXapiWriter]
   }

@xen-orchestra/backups/_runners/_vmRunners/IncrementalRemote.mjs

@@ -1,15 +1,14 @@
-'use strict'
-const assert = require('node:assert')
+import { asyncEach } from '@vates/async-each'
+import { decorateMethodsWith } from '@vates/decorate-with'
+import { defer } from 'golike-defer'
+import assert from 'node:assert'
+import isVhdDifferencingDisk from 'vhd-lib/isVhdDifferencingDisk.js'
+import mapValues from 'lodash/mapValues.js'
 
-const { decorateMethodsWith } = require('@vates/decorate-with')
-const { defer } = require('golike-defer')
-const { mapValues } = require('lodash')
-const { Task } = require('../../Task')
-const { AbstractRemote } = require('./_AbstractRemote')
-const { IncrementalRemoteWriter } = require('../_writers/IncrementalRemoteWriter')
-const { forkDeltaExport } = require('./_forkDeltaExport')
-const isVhdDifferencingDisk = require('vhd-lib/isVhdDifferencingDisk')
-const { asyncEach } = require('@vates/async-each')
+import { AbstractRemote } from './_AbstractRemote.mjs'
+import { forkDeltaExport } from './_forkDeltaExport.mjs'
+import { IncrementalRemoteWriter } from '../_writers/IncrementalRemoteWriter.mjs'
+import { Task } from '../../Task.mjs'
 
 class IncrementalRemoteVmBackupRunner extends AbstractRemote {
   _getRemoteWriter() {
@@ -61,7 +60,7 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
   }
 }
 
-exports.IncrementalRemote = IncrementalRemoteVmBackupRunner
+export const IncrementalRemote = IncrementalRemoteVmBackupRunner
 decorateMethodsWith(IncrementalRemoteVmBackupRunner, {
   _run: defer,
 })

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

@@ -1,28 +1,26 @@
-'use strict'
+import { asyncEach } from '@vates/async-each'
+import { asyncMap } from '@xen-orchestra/async-map'
+import { createLogger } from '@xen-orchestra/log'
+import { pipeline } from 'node:stream'
+import findLast from 'lodash/findLast.js'
+import isVhdDifferencingDisk from 'vhd-lib/isVhdDifferencingDisk.js'
+import keyBy from 'lodash/keyBy.js'
+import mapValues from 'lodash/mapValues.js'
+import vhdStreamValidator from 'vhd-lib/vhdStreamValidator.js'
 
-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 isVhdDifferencingDisk = require('vhd-lib/isVhdDifferencingDisk')
-const { asyncEach } = require('@vates/async-each')
+import { AbstractXapi } from './_AbstractXapi.mjs'
+import { exportIncrementalVm } from '../../_incrementalVm.mjs'
+import { forkDeltaExport } from './_forkDeltaExport.mjs'
+import { IncrementalRemoteWriter } from '../_writers/IncrementalRemoteWriter.mjs'
+import { IncrementalXapiWriter } from '../_writers/IncrementalXapiWriter.mjs'
+import { Task } from '../../Task.mjs'
+import { watchStreamSize } from '../../_watchStreamSize.mjs'
 
 const { debug } = createLogger('xo:backups:IncrementalXapiVmBackup')
 
 const noop = Function.prototype
 
-exports.IncrementalXapi = class IncrementalXapiVmBackupRunner extends AbstractXapi {
+export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends AbstractXapi {
   _getWriters() {
     return [IncrementalRemoteWriter, IncrementalXapiWriter]
   }

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

@@ -1,8 +1,6 @@
-'use strict'
-
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { createLogger } = require('@xen-orchestra/log')
-const { Task } = require('../../Task.js')
+import { asyncMap } from '@xen-orchestra/async-map'
+import { createLogger } from '@xen-orchestra/log'
+import { Task } from '../../Task.mjs'
 
 const { debug, warn } = createLogger('xo:backups:AbstractVmRunner')
 
@@ -19,7 +17,7 @@ const asyncEach = async (iterable, fn, thisArg = iterable) => {
   }
 }
 
-exports.Abstract = class AbstractVmBackupRunner {
+export const 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

@xen-orchestra/backups/_runners/_vmRunners/_AbstractRemote.mjs

@@ -1,11 +1,11 @@
-'use strict'
-const { Abstract } = require('./_Abstract')
+import { asyncEach } from '@vates/async-each'
+import { Disposable } from 'promise-toolbox'
 
-const { getVmBackupDir } = require('../../_getVmBackupDir')
-const { asyncEach } = require('@vates/async-each')
-const { Disposable } = require('promise-toolbox')
+import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
 
-exports.AbstractRemote = class AbstractRemoteVmBackupRunner extends Abstract {
+import { Abstract } from './_Abstract.mjs'
+
+export const AbstractRemote = class AbstractRemoteVmBackupRunner extends Abstract {
   constructor({
     config,
     job,

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

@@ -1,18 +1,16 @@
-'use strict'
+import assert from 'node:assert'
+import groupBy from 'lodash/groupBy.js'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
+import { asyncMap } from '@xen-orchestra/async-map'
+import { decorateMethodsWith } from '@vates/decorate-with'
+import { defer } from 'golike-defer'
+import { formatDateTime } from '@xen-orchestra/xapi'
 
-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')
+import { getOldEntries } from '../../_getOldEntries.mjs'
+import { Task } from '../../Task.mjs'
+import { Abstract } from './_Abstract.mjs'
 
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { Task } = require('../../Task.js')
-const { Abstract } = require('./_Abstract.js')
-
-class AbstractXapiVmBackupRunner extends Abstract {
+export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
   constructor({
     config,
     getSnapshotNameLabel,
@@ -271,8 +269,7 @@ class AbstractXapiVmBackupRunner extends Abstract {
     await this._healthCheck()
   }
 }
-exports.AbstractXapi = AbstractXapiVmBackupRunner
 
-decorateMethodsWith(AbstractXapiVmBackupRunner, {
+decorateMethodsWith(AbstractXapi, {
   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/_vmRunners/_forkDeltaExport.mjs

@@ -0,0 +1,11 @@
+import mapValues from 'lodash/mapValues.js'
+
+import { forkStreamUnpipe } from '../_forkStreamUnpipe.mjs'
+
+export function forkDeltaExport(deltaExport) {
+  return Object.create(deltaExport, {
+    streams: {
+      value: mapValues(deltaExport.streams, forkStreamUnpipe),
+    },
+  })
+}

@xen-orchestra/backups/_runners/_writers/FullRemoteWriter.mjs

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

@xen-orchestra/backups/_runners/_writers/FullXapiWriter.mjs

@@ -1,18 +1,16 @@
-'use strict'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
+import { asyncMap, asyncMapSettled } from '@xen-orchestra/async-map'
+import { formatDateTime } from '@xen-orchestra/xapi'
 
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
-const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
-const { formatDateTime } = require('@xen-orchestra/xapi')
+import { formatFilenameDate } from '../../_filenameDate.mjs'
+import { getOldEntries } from '../../_getOldEntries.mjs'
+import { Task } from '../../Task.mjs'
 
-const { formatFilenameDate } = require('../../_filenameDate.js')
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { Task } = require('../../Task.js')
+import { AbstractFullWriter } from './_AbstractFullWriter.mjs'
+import { MixinXapiWriter } from './_MixinXapiWriter.mjs'
+import { listReplicatedVms } from './_listReplicatedVms.mjs'
 
-const { AbstractFullWriter } = require('./_AbstractFullWriter.js')
-const { MixinXapiWriter } = require('./_MixinXapiWriter.js')
-const { listReplicatedVms } = require('./_listReplicatedVms.js')
-
-exports.FullXapiWriter = class FullXapiWriter extends MixinXapiWriter(AbstractFullWriter) {
+export class FullXapiWriter extends MixinXapiWriter(AbstractFullWriter) {
   constructor(props) {
     super(props)
 
@@ -36,7 +34,7 @@ exports.FullXapiWriter = class FullXapiWriter extends MixinXapiWriter(AbstractFu
     const sr = this._sr
     const settings = this._settings
     const job = this._job
-    const scheduleId = this.scheduleId
+    const scheduleId = this._scheduleId
 
     const { uuid: srUuid, $xapi: xapi } = sr
 

@xen-orchestra/backups/_runners/_writers/IncrementalRemoteWriter.mjs

@@ -1,29 +1,27 @@
-'use strict'
+import assert from 'node:assert'
+import mapValues from 'lodash/mapValues.js'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
+import { asyncEach } from '@vates/async-each'
+import { asyncMap } from '@xen-orchestra/async-map'
+import { chainVhd, checkVhdChain, openVhd, VhdAbstract } from 'vhd-lib'
+import { createLogger } from '@xen-orchestra/log'
+import { decorateClass } from '@vates/decorate-with'
+import { defer } from 'golike-defer'
+import { dirname } from 'node:path'
 
-const assert = require('assert')
-const map = require('lodash/map.js')
-const mapValues = require('lodash/mapValues.js')
-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')
+import { formatFilenameDate } from '../../_filenameDate.mjs'
+import { getOldEntries } from '../../_getOldEntries.mjs'
+import { Task } from '../../Task.mjs'
 
-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 { checkVhd } = require('./_checkVhd.js')
-const { packUuid } = require('./_packUuid.js')
-const { Disposable } = require('promise-toolbox')
+import { MixinRemoteWriter } from './_MixinRemoteWriter.mjs'
+import { AbstractIncrementalWriter } from './_AbstractIncrementalWriter.mjs'
+import { checkVhd } from './_checkVhd.mjs'
+import { packUuid } from './_packUuid.mjs'
+import { Disposable } from 'promise-toolbox'
 
 const { warn } = createLogger('xo:backups:DeltaBackupWriter')
 
-class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWriter) {
+export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWriter) {
   async checkBaseVdis(baseUuidToSrcVdi) {
     const { handler } = this._adapter
     const adapter = this._adapter
@@ -138,7 +136,7 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
     const adapter = this._adapter
     const job = this._job
     const scheduleId = this._scheduleId
-
+    const settings = this._settings
     const jobId = job.id
     const handler = adapter.handler
 
@@ -176,8 +174,9 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
     }
     const { size } = await Task.run({ name: 'transfer' }, async () => {
       let transferSize = 0
-      await Promise.all(
-        map(deltaExport.vdis, async (vdi, id) => {
+      await asyncEach(
+        Object.entries(deltaExport.vdis),
+        async ([id, vdi]) => {
           const path = `${this._vmBackupDir}/${vhds[id]}`
 
           const isDelta = differentialVhds[`${id}.vhd`]
@@ -223,8 +222,12 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
             await vhd.readBlockAllocationTable() // required by writeFooter()
             await vhd.writeFooter()
           })
-        })
+        },
+        {
+          concurrency: settings.diskPerVmConcurrency,
+        }
       )
+
       return { size: transferSize }
     })
     metadataContent.size = size
@@ -233,6 +236,6 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
     // TODO: run cleanup?
   }
 }
-exports.IncrementalRemoteWriter = decorateClass(IncrementalRemoteWriter, {
+decorateClass(IncrementalRemoteWriter, {
   _transfer: defer,
 })

@xen-orchestra/backups/_runners/_writers/IncrementalXapiWriter.mjs

@@ -1,19 +1,17 @@
-'use strict'
+import { asyncMap, asyncMapSettled } from '@xen-orchestra/async-map'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
+import { formatDateTime } from '@xen-orchestra/xapi'
 
-const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
-const { formatDateTime } = require('@xen-orchestra/xapi')
+import { formatFilenameDate } from '../../_filenameDate.mjs'
+import { getOldEntries } from '../../_getOldEntries.mjs'
+import { importIncrementalVm, TAG_COPY_SRC } from '../../_incrementalVm.mjs'
+import { Task } from '../../Task.mjs'
 
-const { formatFilenameDate } = require('../../_filenameDate.js')
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { importIncrementalVm, TAG_COPY_SRC } = require('../../_incrementalVm.js')
-const { Task } = require('../../Task.js')
+import { AbstractIncrementalWriter } from './_AbstractIncrementalWriter.mjs'
+import { MixinXapiWriter } from './_MixinXapiWriter.mjs'
+import { listReplicatedVms } from './_listReplicatedVms.mjs'
 
-const { AbstractIncrementalWriter } = require('./_AbstractIncrementalWriter.js')
-const { MixinXapiWriter } = require('./_MixinXapiWriter.js')
-const { listReplicatedVms } = require('./_listReplicatedVms.js')
-
-exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
+export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
   async checkBaseVdis(baseUuidToSrcVdi, baseVm) {
     const sr = this._sr
     const replicatedVm = listReplicatedVms(sr.$xapi, this._job.id, sr.uuid, this._vmUuid).find(

@xen-orchestra/backups/_runners/_writers/_AbstractFullWriter.mjs

@@ -1,8 +1,6 @@
-'use strict'
+import { AbstractWriter } from './_AbstractWriter.mjs'
 
-const { AbstractWriter } = require('./_AbstractWriter.js')
-
-exports.AbstractFullWriter = class AbstractFullWriter extends AbstractWriter {
+export class AbstractFullWriter extends AbstractWriter {
   async run({ timestamp, sizeContainer, stream, vm, vmSnapshot }) {
     try {
       return await this._run({ timestamp, sizeContainer, stream, vm, vmSnapshot })

@xen-orchestra/backups/_runners/_writers/_AbstractIncrementalWriter.mjs

@@ -1,8 +1,6 @@
-'use strict'
+import { AbstractWriter } from './_AbstractWriter.mjs'
 
-const { AbstractWriter } = require('./_AbstractWriter.js')
-
-exports.AbstractIncrementalWriter = class AbstractIncrementalWriter extends AbstractWriter {
+export class AbstractIncrementalWriter extends AbstractWriter {
   checkBaseVdis(baseUuidToSrcVdi, baseVm) {
     throw new Error('Not implemented')
   }

@xen-orchestra/backups/_runners/_writers/_AbstractWriter.mjs

@@ -1,9 +1,7 @@
-'use strict'
+import { formatFilenameDate } from '../../_filenameDate.mjs'
+import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
 
-const { formatFilenameDate } = require('../../_filenameDate')
-const { getVmBackupDir } = require('../../_getVmBackupDir')
-
-exports.AbstractWriter = class AbstractWriter {
+export class AbstractWriter {
   constructor({ config, healthCheckSr, job, vmUuid, scheduleId, settings }) {
     this._config = config
     this._healthCheckSr = healthCheckSr

@xen-orchestra/backups/_runners/_writers/_MixinRemoteWriter.mjs

@@ -1,19 +1,17 @@
-'use strict'
+import { createLogger } from '@xen-orchestra/log'
+import { join } from 'node:path'
+import assert from 'node:assert'
 
-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')
+import { formatFilenameDate } from '../../_filenameDate.mjs'
+import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
+import { HealthCheckVmBackup } from '../../HealthCheckVmBackup.mjs'
+import { ImportVmBackup } from '../../ImportVmBackup.mjs'
+import { Task } from '../../Task.mjs'
+import * as MergeWorker from '../../merge-worker/index.mjs'
 
 const { info, warn } = createLogger('xo:backups:MixinBackupWriter')
 
-exports.MixinRemoteWriter = (BaseClass = Object) =>
+export const MixinRemoteWriter = (BaseClass = Object) =>
   class MixinRemoteWriter extends BaseClass {
     #lock
 

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

@@ -1,46 +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() {
-      const sr = this._healthCheckSr
-      assert.notStrictEqual(sr, undefined, 'SR should be defined before making a health check')
-      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/_runners/_writers/_MixinXapiWriter.mjs

@@ -0,0 +1,72 @@
+import { extractOpaqueRef } from '@xen-orchestra/xapi'
+import assert from 'node:assert/strict'
+
+import { HealthCheckVmBackup } from '../../HealthCheckVmBackup.mjs'
+import { Task } from '../../Task.mjs'
+
+export const MixinXapiWriter = (BaseClass = Object) =>
+  class MixinXapiWriter extends BaseClass {
+    constructor({ sr, ...rest }) {
+      super(rest)
+
+      this._sr = sr
+    }
+
+    // check if the base Vm has all its disk on health check sr
+    async #isAlreadyOnHealthCheckSr(baseVm) {
+      const xapi = baseVm.$xapi
+      const vdiRefs = await xapi.VM_getDisks(baseVm.$ref)
+      for (const vdiRef of vdiRefs) {
+        const vdi = xapi.getObject(vdiRef)
+        if (vdi.$SR.uuid !== this._heathCheckSr.uuid) {
+          return false
+        }
+      }
+      return true
+    }
+
+    healthCheck() {
+      const sr = this._healthCheckSr
+      assert.notStrictEqual(sr, undefined, 'SR should be defined before making a health check')
+      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 healthCheckVmRef
+          try {
+            const baseVm = xapi.getObject(this._targetVmRef) ?? (await xapi.waitObject(this._targetVmRef))
+
+            if (await this.#isAlreadyOnHealthCheckSr(baseVm)) {
+              healthCheckVmRef = await Task.run(
+                { name: 'cloning-vm' },
+                async () =>
+                  await xapi
+                    .callAsync('VM.clone', this._targetVmRef, `Health Check - ${baseVm.name_label}`)
+                    .then(extractOpaqueRef)
+              )
+            } else {
+              healthCheckVmRef = await Task.run(
+                { name: 'copying-vm' },
+                async () =>
+                  await xapi
+                    .callAsync('VM.copy', this._targetVmRef, `Health Check - ${baseVm.name_label}`, sr.$ref)
+                    .then(extractOpaqueRef)
+              )
+            }
+            const healthCheckVm = xapi.getObject(healthCheckVmRef) ?? (await xapi.waitObject(healthCheckVmRef))
+
+            await new HealthCheckVmBackup({
+              restoredVm: healthCheckVm,
+              xapi,
+            }).run()
+          } finally {
+            healthCheckVmRef && (await xapi.VM_destroy(healthCheckVmRef))
+          }
+        }
+      )
+    }
+  }

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

@@ -1,8 +0,0 @@
-'use strict'
-
-const openVhd = require('vhd-lib').openVhd
-const Disposable = require('promise-toolbox/Disposable')
-
-exports.checkVhd = async function checkVhd(handler, path) {
-  await Disposable.use(openVhd(handler, path), () => {})
-}

@xen-orchestra/backups/_runners/_writers/_checkVhd.mjs

@@ -0,0 +1,6 @@
+import { openVhd } from 'vhd-lib'
+import Disposable from 'promise-toolbox/Disposable'
+
+export async function checkVhd(handler, path) {
+  await Disposable.use(openVhd(handler, path), () => {})
+}

@xen-orchestra/backups/_runners/_writers/_listReplicatedVms.mjs

@@ -1,5 +1,3 @@
-'use strict'
-
 const getReplicatedVmDatetime = vm => {
   const { 'xo:backup:datetime': datetime = vm.name_label.slice(-17, -1) } = vm.other_config
   return datetime
@@ -7,7 +5,7 @@ const getReplicatedVmDatetime = vm => {
 
 const compareReplicatedVmDatetime = (a, b) => (getReplicatedVmDatetime(a) < getReplicatedVmDatetime(b) ? -1 : 1)
 
-exports.listReplicatedVms = function listReplicatedVms(xapi, scheduleOrJobId, srUuid, vmUuid) {
+export function listReplicatedVms(xapi, scheduleOrJobId, srUuid, vmUuid) {
   const { all } = xapi.objects
   const vms = {}
   for (const key in all) {

@xen-orchestra/backups/_runners/_writers/_packUuid.mjs

@@ -1,7 +1,5 @@
-'use strict'
-
 const PARSE_UUID_RE = /-/g
 
-exports.packUuid = function packUuid(uuid) {
+export function packUuid(uuid) {
   return Buffer.from(uuid.replace(PARSE_UUID_RE, ''), 'hex')
 }

@xen-orchestra/backups/_watchStreamSize.mjs

@@ -1,6 +1,4 @@
-'use strict'
-
-exports.watchStreamSize = function watchStreamSize(stream, container = { size: 0 }) {
+export function watchStreamSize(stream, container = { size: 0 }) {
   stream.on('data', data => {
     container.size += data.length
   })

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

@@ -171,13 +171,16 @@ job:
   # For replication jobs, indicates which SRs to use
   srs: IdPattern
 
-  # Here for historical reasons
-  type: 'backup'
+  type: 'backup' | 'mirrorBackup'
 
-  # Indicates which VMs to backup/replicate
+  # Indicates which VMs to backup/replicate for a xapi to remote backup job
   vms: IdPattern
 
+  # Indicates which remote to read from for a mirror backup job
+  sourceRemote: IdPattern
+
 # Indicates which XAPI to use to connect to a specific VM or SR
+# for remote to remote backup job,this is only needed if there is healtcheck
 recordToXapi:
   [ObjectId]: XapiId
 

@xen-orchestra/backups/extractIdsFromSimplePattern.mjs

@@ -1,6 +1,4 @@
-'use strict'
-
-exports.extractIdsFromSimplePattern = function extractIdsFromSimplePattern(pattern) {
+export function extractIdsFromSimplePattern(pattern) {
   if (pattern === undefined) {
     return []
   }

@xen-orchestra/backups/formatVmBackups.mjs

@@ -1,7 +1,5 @@
-'use strict'
-
-const mapValues = require('lodash/mapValues.js')
-const { dirname } = require('path')
+import mapValues from 'lodash/mapValues.js'
+import { dirname } from 'node:path'
 
 function formatVmBackup(backup) {
   return {
@@ -31,6 +29,6 @@ function formatVmBackup(backup) {
 }
 
 // format all backups as returned by RemoteAdapter#listAllVmBackups()
-exports.formatVmBackups = function formatVmBackups(backupsByVM) {
+export function formatVmBackups(backupsByVM) {
   return mapValues(backupsByVM, backups => backups.map(formatVmBackup))
 }

@xen-orchestra/backups/merge-worker/cli.mjs

@@ -2,19 +2,17 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable n/shebang */
 
-'use strict'
+import { catchGlobalErrors } from '@xen-orchestra/log/configure'
+import { createLogger } from '@xen-orchestra/log'
+import { getSyncedHandler } from '@xen-orchestra/fs'
+import { join } from 'node:path'
+import Disposable from 'promise-toolbox/Disposable'
+import min from 'lodash/min.js'
 
-const { catchGlobalErrors } = require('@xen-orchestra/log/configure')
-const { createLogger } = require('@xen-orchestra/log')
-const { getSyncedHandler } = require('@xen-orchestra/fs')
-const { join } = require('path')
-const Disposable = require('promise-toolbox/Disposable')
-const min = require('lodash/min')
+import { getVmBackupDir } from '../_getVmBackupDir.mjs'
+import { RemoteAdapter } from '../RemoteAdapter.mjs'
 
-const { getVmBackupDir } = require('../_getVmBackupDir.js')
-const { RemoteAdapter } = require('../RemoteAdapter.js')
-
-const { CLEAN_VM_QUEUE } = require('./index.js')
+import { CLEAN_VM_QUEUE } from './index.mjs'
 
 // -------------------------------------------------------------------
 

@xen-orchestra/backups/merge-worker/index.mjs

@@ -1,13 +1,12 @@
-'use strict'
+import { join } from 'node:path'
+import { spawn } from 'child_process'
+import { check } from 'proper-lockfile'
 
-const { join, resolve } = require('path')
-const { spawn } = require('child_process')
-const { check } = require('proper-lockfile')
+export const CLEAN_VM_QUEUE = '/xo-vm-backups/.queue/clean-vm/'
 
-const CLEAN_VM_QUEUE = (exports.CLEAN_VM_QUEUE = '/xo-vm-backups/.queue/clean-vm/')
+const CLI_PATH = new URL('cli.mjs', import.meta.url).pathname
 
-const CLI_PATH = resolve(__dirname, 'cli.js')
-exports.run = async function runMergeWorker(remotePath) {
+export const run = async function runMergeWorker(remotePath) {
   try {
     // TODO: find a way to pass the acquire the lock and then pass it down the worker
     if (await check(join(remotePath, CLEAN_VM_QUEUE))) {

@xen-orchestra/backups/package.json

@@ -8,13 +8,13 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.38.2",
+  "version": "0.39.0",
   "engines": {
-    "node": ">=14.6"
+    "node": ">=14.18"
   },
   "scripts": {
     "postversion": "npm publish --access public",
-    "test-integration": "node--test *.integ.js"
+    "test-integration": "node--test *.integ.mjs"
   },
   "dependencies": {
     "@kldzj/stream-throttle": "^1.1.1",
@@ -24,16 +24,15 @@
     "@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": "^1.2.1",
     "@vates/parse-duration": "^0.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/fs": "^4.0.0",
+    "@xen-orchestra/fs": "^4.0.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",
-    "fs-extra": "^11.1.0",
     "golike-defer": "^0.5.1",
     "limit-concurrency-decorator": "^0.5.0",
     "lodash": "^4.17.20",
@@ -43,9 +42,11 @@
     "proper-lockfile": "^4.1.2",
     "uuid": "^9.0.0",
     "vhd-lib": "^4.5.0",
+    "xen-api": "^1.3.3",
     "yazl": "^2.5.1"
   },
   "devDependencies": {
+    "fs-extra": "^11.1.0",
     "rimraf": "^5.0.1",
     "sinon": "^15.0.1",
     "test": "^3.2.1",

@xen-orchestra/backups/parseMetadataBackupId.mjs

@@ -1,8 +1,6 @@
-'use strict'
+import { DIR_XO_CONFIG_BACKUPS, DIR_XO_POOL_METADATA_BACKUPS } from './RemoteAdapter.mjs'
 
-const { DIR_XO_CONFIG_BACKUPS, DIR_XO_POOL_METADATA_BACKUPS } = require('./RemoteAdapter.js')
-
-exports.parseMetadataBackupId = function parseMetadataBackupId(backupId) {
+export function parseMetadataBackupId(backupId) {
   const [dir, ...rest] = backupId.split('/')
   if (dir === DIR_XO_CONFIG_BACKUPS) {
     const [scheduleId, timestamp] = rest

@xen-orchestra/backups/runBackupWorker.mjs

@@ -1,14 +1,11 @@
-'use strict'
-
-const path = require('path')
-const { createLogger } = require('@xen-orchestra/log')
-const { fork } = require('child_process')
+import { createLogger } from '@xen-orchestra/log'
+import { fork } from 'child_process'
 
 const { warn } = createLogger('xo:backups:backupWorker')
 
-const PATH = path.resolve(__dirname, '_backupWorker.js')
+const PATH = new URL('_backupWorker.mjs', import.meta.url).pathname
 
-exports.runBackupWorker = function runBackupWorker(params, onLog) {
+export function runBackupWorker(params, onLog) {
   return new Promise((resolve, reject) => {
     const worker = fork(PATH)
 

@xen-orchestra/backups/tests.fixtures.mjs

@@ -1,7 +1,5 @@
-'use strict'
-
 // a valid footer of a 2
-exports.VHDFOOTER = {
+export const VHDFOOTER = {
   cookie: 'conectix',
   features: 2,
   fileFormatVersion: 65536,
@@ -20,7 +18,7 @@ exports.VHDFOOTER = {
   hidden: '',
   reserved: '',
 }
-exports.VHDHEADER = {
+export const VHDHEADER = {
   cookie: 'cxsparse',
   dataOffset: undefined,
   tableOffset: 2048,

@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.3.3"
   },
   "scripts": {
     "postversion": "npm publish"

@xen-orchestra/fs/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@xen-orchestra/fs",
-  "version": "4.0.0",
+  "version": "4.0.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",
@@ -30,7 +30,6 @@
     "@vates/coalesce-calls": "^0.1.0",
     "@vates/decorate-with": "^2.0.0",
     "@vates/read-chunk": "^1.1.1",
-    "@xen-orchestra/async-map": "^0.1.2",
     "@xen-orchestra/log": "^0.6.0",
     "bind-property-descriptor": "^2.0.0",
     "decorator-synchronized": "^0.6.0",

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

@@ -1,6 +1,6 @@
-import asyncMapSettled from '@xen-orchestra/async-map/legacy'
 import assert from 'assert'
 import getStream from 'get-stream'
+import { asyncEach } from '@vates/async-each'
 import { coalesceCalls } from '@vates/coalesce-calls'
 import { createLogger } from '@xen-orchestra/log'
 import { fromCallback, fromEvent, ignoreErrors, timeout } from 'promise-toolbox'
@@ -623,7 +623,7 @@ export default class RemoteHandlerAbstract {
     }
 
     const files = await this._list(dir)
-    await asyncMapSettled(files, file =>
+    await asyncEach(files, file =>
       this._unlink(`${dir}/${file}`).catch(error => {
         // Unlink dir behavior is not consistent across platforms
         // https://github.com/nodejs/node-v0.x-archive/issues/5791

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

@@ -209,7 +209,7 @@ describe('encryption', () => {
     // encrypt with a non default algorithm
     const encryptor = _getEncryptor('aes-256-cbc', '73c1838d7d8a6088ca2317fb5f29cd91')
 
-    await fs.writeFile(`${dir}/encryption.json`, `{"algorithm": "aes-256-gmc"}`)
+    await fs.writeFile(`${dir}/encryption.json`, `{"algorithm": "aes-256-gcm"}`)
     await fs.writeFile(`${dir}/metadata.json`, encryptor.encryptData(`{"random": "NOTSORANDOM"}`))
 
     // remote is now non empty : can't modify key anymore

@xen-orchestra/lite/CHANGELOG.md

@@ -1,6 +1,11 @@
 # ChangeLog
 
-## **0.2.0**
+## **next**
+
+- Ability to export selected VMs as CSV file (PR [#6915](https://github.com/vatesfr/xen-orchestra/pull/6915))
+- [Pool/VMs] Ability to export selected VMs as JSON file (PR [#6911](https://github.com/vatesfr/xen-orchestra/pull/6911))
+
+## **0.1.1** (2023-07-03)
 
 - Invalidate sessionId token after logout (PR [#6480](https://github.com/vatesfr/xen-orchestra/pull/6480))
 - Settings page (PR [#6418](https://github.com/vatesfr/xen-orchestra/pull/6418))
@@ -17,6 +22,7 @@
 - Add "Under Construction" views (PR [#6673](https://github.com/vatesfr/xen-orchestra/pull/6673))
 - Ability to change the state of selected VMs from the pool's list of VMs (PR [#6782](https://github.com/vatesfr/xen-orchestra/pull/6782))
 - Ability to copy selected VMs from the pool's list of VMs (PR [#6847](https://github.com/vatesfr/xen-orchestra/pull/6847))
+- Ability to delete selected VMs from the pool's list of VMs (PR [#6673](https://github.com/vatesfr/xen-orchestra/pull/6860))
 
 ## **0.1.0**
 

@xen-orchestra/lite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xen-orchestra/lite",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "scripts": {
     "dev": "GIT_HEAD=$(git rev-parse HEAD) vite",
     "build": "run-p type-check build-only",
@@ -17,6 +17,7 @@
     "@fortawesome/vue-fontawesome": "^3.0.1",
     "@novnc/novnc": "^1.3.0",
     "@types/d3-time-format": "^4.0.0",
+    "@types/file-saver": "^2.0.5",
     "@types/lodash-es": "^4.17.6",
     "@types/marked": "^4.0.8",
     "@vueuse/core": "^10.1.2",
@@ -25,6 +26,7 @@
     "d3-time-format": "^4.1.0",
     "decorator-synchronized": "^0.6.0",
     "echarts": "^5.3.3",
+    "file-saver": "^2.0.5",
     "highlight.js": "^11.6.0",
     "human-format": "^1.1.0",
     "iterable-backoff": "^0.1.0",
@@ -57,7 +59,6 @@
     "postcss-nested": "^6.0.0",
     "typescript": "^4.9.3",
     "vite": "^4.3.8",
-    "vite-plugin-pages": "^0.29.1",
     "vue-tsc": "^1.6.5"
   },
   "private": true,

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

@@ -29,6 +29,7 @@ import { useXenApiStore } from "@/stores/xen-api.store";
 import { useActiveElement, useMagicKeys, whenever } from "@vueuse/core";
 import { logicAnd } from "@vueuse/math";
 import { computed } from "vue";
+import { useI18n } from "vue-i18n";
 
 let link = document.querySelector(
   "link[rel~='icon']"
@@ -48,10 +49,11 @@ useChartTheme();
 const uiStore = useUiStore();
 
 if (import.meta.env.DEV) {
+  const { locale } = useI18n();
   const activeElement = useActiveElement();
-  const { D } = useMagicKeys();
+  const { D, L } = useMagicKeys();
 
-  const canToggleDarkMode = computed(() => {
+  const canToggle = computed(() => {
     if (activeElement.value == null) {
       return true;
     }
@@ -60,9 +62,14 @@ if (import.meta.env.DEV) {
   });
 
   whenever(
-    logicAnd(D, canToggleDarkMode),
+    logicAnd(D, canToggle),
     () => (uiStore.colorMode = uiStore.colorMode === "dark" ? "light" : "dark")
   );
+
+  whenever(
+    logicAnd(L, canToggle),
+    () => (locale.value = locale.value === "en" ? "fr" : "en")
+  );
 }
 
 whenever(

@xen-orchestra/lite/src/components/AppLogin.vue

@@ -13,13 +13,10 @@
           v-model="password"
           :placeholder="$t('password')"
           :readonly="isConnecting"
+          required
         />
       </FormInputWrapper>
-      <UiButton
-        type="submit"
-        :busy="isConnecting"
-        :disabled="password.trim().length < 1"
-      >
+      <UiButton type="submit" :busy="isConnecting">
         {{ $t("login") }}
       </UiButton>
     </form>

@xen-orchestra/lite/src/components/AppMarkdown.vue

@@ -5,7 +5,6 @@
 <script lang="ts" setup>
 import markdown from "@/libs/markdown";
 import { useEventListener } from "@vueuse/core";
-import "highlight.js/styles/github-dark.css";
 import { computed, type Ref, ref } from "vue";
 
 const rootElement = ref() as Ref<HTMLElement>;

@xen-orchestra/lite/src/components/CodeHighlight.vue

@@ -3,14 +3,13 @@
 </template>
 
 <script lang="ts" setup>
-import HLJS from "highlight.js";
+import { type AcceptedLanguage, highlight } from "@/libs/highlight";
 import { computed } from "vue";
-import "highlight.js/styles/github-dark.css";
 
 const props = withDefaults(
   defineProps<{
     code?: any;
-    lang?: string;
+    lang?: AcceptedLanguage;
   }>(),
   { lang: "typescript" }
 );
@@ -27,7 +26,7 @@ const codeAsText = computed(() => {
 });
 
 const codeAsHtml = computed(
-  () => HLJS.highlight(codeAsText.value, { language: props.lang }).value
+  () => highlight(codeAsText.value, { language: props.lang }).value
 );
 </script>
 

@xen-orchestra/lite/src/components/ObjectNotFoundWrapper.vue

@@ -6,23 +6,26 @@
   <slot v-else />
 </template>
 
-<script lang="ts" setup>
+<script
+  generic="T extends XenApiRecord<string>, I extends T['uuid']"
+  lang="ts"
+  setup
+>
 import UiSpinner from "@/components/ui/UiSpinner.vue";
+import type { XenApiRecord } from "@/libs/xen-api";
 import ObjectNotFoundView from "@/views/ObjectNotFoundView.vue";
 import { computed } from "vue";
 import { useRouter } from "vue-router";
 
 const props = defineProps<{
   isReady: boolean;
-  uuidChecker: (uuid: string) => boolean;
-  id?: string;
+  uuidChecker: (uuid: I) => boolean;
+  id?: I;
 }>();
 
 const { currentRoute } = useRouter();
 
-const id = computed(
-  () => props.id ?? (currentRoute.value.params.uuid as string)
-);
+const id = computed(() => props.id ?? (currentRoute.value.params.uuid as I));
 
 const isRecordNotFound = computed(
   () => props.isReady && !props.uuidChecker(id.value)

@xen-orchestra/lite/src/components/RouterTab.vue

@@ -11,7 +11,8 @@
 </template>
 
 <script lang="ts" setup>
-import { type ComputedRef, computed, inject } from "vue";
+import { IK_TAB_BAR_DISABLED } from "@/types/injection-keys";
+import { computed, inject } from "vue";
 import type { RouteLocationRaw } from "vue-router";
 import UiTab from "@/components/ui/UiTab.vue";
 
@@ -20,8 +21,8 @@ defineProps<{
   disabled?: boolean;
 }>();
 
-const isTabBarDisabled = inject<ComputedRef<boolean>>(
-  "isTabBarDisabled",
+const isTabBarDisabled = inject(
+  IK_TAB_BAR_DISABLED,
   computed(() => false)
 );
 </script>