@xen-orchestra/backups 0.38.3 → 0.40.0

package/_runners/{Metadata.js → 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)

package/_runners/{VmsRemote.js → 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)

package/_runners/{VmsXapi.js → VmsXapi.mjs}

@@ -1,17 +1,15 @@
-'use strict'
-
-const { asyncMapSettled } = require('@xen-orchestra/async-map')
-const Disposable = require('promise-toolbox/Disposable')
-const { limitConcurrency } = require('limit-concurrency-decorator')
-
-const { extractIdsFromSimplePattern } = require('../extractIdsFromSimplePattern.js')
-const { Task } = require('../Task.js')
-const createStreamThrottle = require('./_createStreamThrottle.js')
-const { DEFAULT_SETTINGS, Abstract } = require('./_Abstract.js')
-const { runTask } = require('./_runTask.js')
-const { getAdaptersByRemote } = require('./_getAdaptersByRemote.js')
-const { IncrementalXapi } = require('./_vmRunners/IncrementalXapi.js')
-const { FullXapi } = require('./_vmRunners/FullXapi.js')
+import { asyncMapSettled } from '@xen-orchestra/async-map'
+import Disposable from 'promise-toolbox/Disposable'
+import { limitConcurrency } from 'limit-concurrency-decorator'
+
+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)

package/_runners/{_Abstract.js → _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

package/_runners/{_PoolMetadataBackup.js → _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

package/_runners/{_RemoteTimeoutError.js → _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

package/_runners/{_XoMetadataBackup.js → _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,
             })

package/_runners/{_createStreamThrottle.js → _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
   }

package/_runners/{_forkStreamUnpipe.js → _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
 

package/_runners/{_getAdaptersByRemote.js → _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

package/_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

package/_runners/_vmRunners/{FullRemote.js → 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,
 })

package/_runners/_vmRunners/{FullXapi.js → 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]
   }

package/_runners/_vmRunners/{IncrementalRemote.js → 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,
 })

package/_runners/_vmRunners/{IncrementalXapi.js → IncrementalXapi.mjs}

@@ -1,28 +1,26 @@
-'use strict'
-
-const findLast = require('lodash/findLast.js')
-const keyBy = require('lodash/keyBy.js')
-const mapValues = require('lodash/mapValues.js')
-const vhdStreamValidator = require('vhd-lib/vhdStreamValidator.js')
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { createLogger } = require('@xen-orchestra/log')
-const { pipeline } = require('node:stream')
-
-const { IncrementalRemoteWriter } = require('../_writers/IncrementalRemoteWriter.js')
-const { IncrementalXapiWriter } = require('../_writers/IncrementalXapiWriter.js')
-const { exportIncrementalVm } = require('../../_incrementalVm.js')
-const { Task } = require('../../Task.js')
-const { watchStreamSize } = require('../../_watchStreamSize.js')
-const { AbstractXapi } = require('./_AbstractXapi.js')
-const { forkDeltaExport } = require('./_forkDeltaExport.js')
-const isVhdDifferencingDisk = require('vhd-lib/isVhdDifferencingDisk')
-const { asyncEach } = require('@vates/async-each')
+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'
+
+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]
   }

package/_runners/_vmRunners/{_Abstract.js → _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

package/_runners/_vmRunners/{_AbstractRemote.js → _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,

package/_runners/_vmRunners/{_AbstractXapi.js → _AbstractXapi.mjs}

@@ -1,18 +1,16 @@
-'use strict'
-
-const assert = require('assert')
-const groupBy = require('lodash/groupBy.js')
-const ignoreErrors = require('promise-toolbox/ignoreErrors')
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { decorateMethodsWith } = require('@vates/decorate-with')
-const { defer } = require('golike-defer')
-const { formatDateTime } = require('@xen-orchestra/xapi')
-
-const { getOldEntries } = require('../../_getOldEntries.js')
-const { Task } = require('../../Task.js')
-const { Abstract } = require('./_Abstract.js')
-
-class AbstractXapiVmBackupRunner extends Abstract {
+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'
+
+import { getOldEntries } from '../../_getOldEntries.mjs'
+import { Task } from '../../Task.mjs'
+import { Abstract } from './_Abstract.mjs'
+
+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,
 })

package/_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),
+    },
+  })
+}

package/_runners/_writers/{FullRemoteWriter.js → 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)
 

package/_runners/_writers/{FullXapiWriter.js → 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)