@xen-orchestra/backups 0.37.0 → 0.38.1

package/Backup.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { Metadata } = require('./_runners/Metadata.js')
+const { VmsRemote } = require('./_runners/VmsRemote.js')
 const { VmsXapi } = require('./_runners/VmsXapi.js')
 
 exports.createRunner = function createRunner(opts) {
@@ -8,6 +9,8 @@ exports.createRunner = function createRunner(opts) {
   switch (type) {
     case 'backup':
       return new VmsXapi(opts)
+    case 'mirrorBackup':
+      return new VmsRemote(opts)
     case 'metadataBackup':
       return new Metadata(opts)
     default:

package/_runners/VmsRemote.js

@@ -0,0 +1,98 @@
+'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 { FullRemote } = require('./_vmRunners/FullRemote.js')
+const { IncrementalRemote } = require('./_vmRunners/IncrementalRemote.js')
+
+const DEFAULT_REMOTE_VM_SETTINGS = {
+  concurrency: 2,
+  copyRetention: 0,
+  deleteFirst: false,
+  exportRetention: 0,
+  healthCheckSr: undefined,
+  healthCheckVmsWithTags: [],
+  maxExportRate: 0,
+  maxMergedDeltasPerRun: Infinity,
+  timeout: 0,
+  validateVhdStreams: false,
+  vmTimeout: 0,
+}
+
+exports.VmsRemote = class RemoteVmsBackupRunner extends Abstract {
+  _computeBaseSettings(config, job) {
+    const baseSettings = { ...DEFAULT_SETTINGS }
+    Object.assign(baseSettings, DEFAULT_REMOTE_VM_SETTINGS, config.defaultSettings, config.vm?.defaultSettings)
+    Object.assign(baseSettings, job.settings[''])
+    return baseSettings
+  }
+
+  async run() {
+    const job = this._job
+    const schedule = this._schedule
+    const settings = this._settings
+
+    const throttleStream = createStreamThrottle(settings.maxExportRate)
+
+    const config = this._config
+    await Disposable.use(
+      () => this._getAdapter(job.sourceRemote),
+      () => (settings.healthCheckSr !== undefined ? this._getRecord('SR', settings.healthCheckSr) : undefined),
+      Disposable.all(
+        extractIdsFromSimplePattern(job.remotes).map(id => id !== job.sourceRemote && this._getAdapter(id))
+      ),
+      async ({ adapter: sourceRemoteAdapter }, healthCheckSr, remoteAdapters) => {
+        // remove adapters that failed (already handled)
+        remoteAdapters = remoteAdapters.filter(_ => !!_)
+        if (remoteAdapters.length === 0) {
+          return
+        }
+
+        const vmsUuids = await sourceRemoteAdapter.listAllVms()
+
+        Task.info('vms', { vms: vmsUuids })
+
+        remoteAdapters = getAdaptersByRemote(remoteAdapters)
+        const allSettings = this._job.settings
+        const baseSettings = this._baseSettings
+
+        const handleVm = vmUuid => {
+          const taskStart = { name: 'backup VM', data: { type: 'VM', id: vmUuid } }
+
+          const opts = {
+            baseSettings,
+            config,
+            job,
+            healthCheckSr,
+            remoteAdapters,
+            schedule,
+            settings: { ...settings, ...allSettings[vmUuid] },
+            sourceRemoteAdapter,
+            throttleStream,
+            vmUuid,
+          }
+          let vmBackup
+          if (job.mode === 'delta') {
+            vmBackup = new IncrementalRemote(opts)
+          } else if (job.mode === 'full') {
+            vmBackup = new FullRemote(opts)
+          } else {
+            throw new Error(`Job mode ${job.mode} not implemented for mirror backup`)
+          }
+
+          return runTask(taskStart, () => vmBackup.run())
+        }
+        const { concurrency } = settings
+        await asyncMapSettled(vmsUuids, !concurrency ? handleVm : limitConcurrency(concurrency)(handleVm))
+      }
+    )
+  }
+}

package/_runners/_vmRunners/FullRemote.js

@@ -0,0 +1,53 @@
+'use strict'
+
+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 {
+  _getRemoteWriter() {
+    return FullRemoteWriter
+  }
+  async _run($defer) {
+    const transferList = await this._computeTransferList(({ mode }) => mode === 'full')
+
+    await this._callWriters(async writer => {
+      await writer.beforeBackup()
+      $defer(async () => {
+        await writer.afterBackup()
+      })
+    }, 'writer.beforeBackup()')
+    if (transferList.length > 0) {
+      for (const metadata of transferList) {
+        const stream = await this._sourceRemoteAdapter.readFullVmBackup(metadata)
+        const sizeContainer = watchStreamSize(stream)
+
+        // @todo shouldn't transfer backup if it will be deleted by retention policy (higher retention on source than destination)
+        await this._callWriters(
+          writer =>
+            writer.run({
+              stream: forkStreamUnpipe(stream),
+              timestamp: metadata.timestamp,
+              vm: metadata.vm,
+              vmSnapshot: metadata.vmSnapshot,
+              sizeContainer,
+            }),
+          'writer.run()'
+        )
+        // for healthcheck
+        this._tags = metadata.vm.tags
+      }
+    } else {
+      Task.info('No new data to upload for this VM')
+    }
+  }
+}
+
+exports.FullRemote = FullRemoteVmBackupRunner
+decorateMethodsWith(FullRemoteVmBackupRunner, {
+  _run: defer,
+})

package/_runners/_vmRunners/FullXapi.js

@@ -16,7 +16,7 @@ exports.FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
   }
 
   _mustDoSnapshot() {
-    const { vm } = this
+    const vm = this._vm
 
     const settings = this._settings
     return (
@@ -29,8 +29,10 @@ exports.FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
 
   async _copy() {
     const { compression } = this.job
+    const vm = this._vm
+    const exportedVm = this._exportedVm
     const stream = this._throttleStream(
-      await this._xapi.VM_export(this.exportedVm.$ref, {
+      await this._xapi.VM_export(exportedVm.$ref, {
         compress: Boolean(compression) && (compression === 'native' ? 'gzip' : 'zstd'),
         useSnapshot: false,
       })
@@ -45,6 +47,8 @@ exports.FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
           sizeContainer,
           stream: forkStreamUnpipe(stream),
           timestamp,
+          vm,
+          vmSnapshot: exportedVm,
         }),
       'writer.run()'
     )

package/_runners/_vmRunners/IncrementalRemote.js

@@ -0,0 +1,67 @@
+'use strict'
+const assert = require('node:assert')
+
+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')
+
+class IncrementalRemoteVmBackupRunner extends AbstractRemote {
+  _getRemoteWriter() {
+    return IncrementalRemoteWriter
+  }
+  async _run($defer) {
+    const transferList = await this._computeTransferList(({ mode }) => mode === 'delta')
+    await this._callWriters(async writer => {
+      await writer.beforeBackup()
+      $defer(async () => {
+        await writer.afterBackup()
+      })
+    }, 'writer.beforeBackup()')
+
+    if (transferList.length > 0) {
+      for (const metadata of transferList) {
+        assert.strictEqual(metadata.mode, 'delta')
+
+        await this._callWriters(writer => writer.prepare({ isBase: metadata.isBase }), 'writer.prepare()')
+        const incrementalExport = await this._sourceRemoteAdapter.readIncrementalVmBackup(metadata, undefined, {
+          useChain: false,
+        })
+
+        const differentialVhds = {}
+
+        await asyncEach(Object.entries(incrementalExport.streams), async ([key, stream]) => {
+          differentialVhds[key] = await isVhdDifferencingDisk(stream)
+        })
+
+        incrementalExport.streams = mapValues(incrementalExport.streams, this._throttleStream)
+        await this._callWriters(
+          writer =>
+            writer.transfer({
+              deltaExport: forkDeltaExport(incrementalExport),
+              differentialVhds,
+              timestamp: metadata.timestamp,
+              vm: metadata.vm,
+              vmSnapshot: metadata.vmSnapshot,
+            }),
+          'writer.transfer()'
+        )
+        await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
+        // for healthcheck
+        this._tags = metadata.vm.tags
+      }
+    } else {
+      Task.info('No new data to upload for this VM')
+    }
+  }
+}
+
+exports.IncrementalRemote = IncrementalRemoteVmBackupRunner
+decorateMethodsWith(IncrementalRemoteVmBackupRunner, {
+  _run: defer,
+})

package/_runners/_vmRunners/IncrementalXapi.js

@@ -15,6 +15,8 @@ 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')
 
 const { debug } = createLogger('xo:backups:IncrementalXapiVmBackup')
 
@@ -30,8 +32,9 @@ exports.IncrementalXapi = class IncrementalXapiVmBackupRunner extends AbstractXa
   }
 
   async _copy() {
-    const { exportedVm } = this
     const baseVm = this._baseVm
+    const vm = this._vm
+    const exportedVm = this._exportedVm
     const fullVdisRequired = this._fullVdisRequired
 
     const isFull = fullVdisRequired === undefined || fullVdisRequired.size !== 0
@@ -46,12 +49,18 @@ exports.IncrementalXapi = class IncrementalXapiVmBackupRunner extends AbstractXa
     if (Object.values(deltaExport.streams).some(({ _nbd }) => _nbd)) {
       Task.info('Transfer data using NBD')
     }
+
+    const differentialVhds = {}
+    // since isVhdDifferencingDisk is reading and unshifting data in stream
+    // it should be done BEFORE any other stream transform
+    await asyncEach(Object.entries(deltaExport.streams), async ([key, stream]) => {
+      differentialVhds[key] = await isVhdDifferencingDisk(stream)
+    })
     const sizeContainers = mapValues(deltaExport.streams, stream => watchStreamSize(stream))
 
     if (this._settings.validateVhdStreams) {
       deltaExport.streams = mapValues(deltaExport.streams, stream => pipeline(stream, vhdStreamValidator, noop))
     }
-
     deltaExport.streams = mapValues(deltaExport.streams, this._throttleStream)
 
     const timestamp = Date.now()
@@ -60,8 +69,11 @@ exports.IncrementalXapi = class IncrementalXapiVmBackupRunner extends AbstractXa
       writer =>
         writer.transfer({
           deltaExport: forkDeltaExport(deltaExport),
+          differentialVhds,
           sizeContainers,
           timestamp,
+          vm,
+          vmSnapshot: exportedVm,
         }),
       'writer.transfer()'
     )
@@ -108,7 +120,7 @@ exports.IncrementalXapi = class IncrementalXapiVmBackupRunner extends AbstractXa
       return
     }
 
-    const srcVdis = keyBy(await xapi.getRecords('VDI', await this.vm.$getDisks()), '$ref')
+    const srcVdis = keyBy(await xapi.getRecords('VDI', await this._vm.$getDisks()), '$ref')
 
     // resolve full record
     baseVm = await xapi.getRecord('VM', baseVm.$ref)

package/_runners/_vmRunners/_Abstract.js

@@ -75,13 +75,21 @@ exports.Abstract = class AbstractVmBackupRunner {
     }
 
     // check if current VM has tags
-    const { tags } = this.vm
+    const tags = this._tags
     const intersect = settings.healthCheckVmsWithTags.some(t => tags.includes(t))
 
     if (settings.healthCheckVmsWithTags.length !== 0 && !intersect) {
-      return
+      // create a task to have an info in the logs and reports
+      return Task.run(
+        {
+          name: 'health check',
+        },
+        () => {
+          Task.info(`This VM doesn't match the health check's tags for this schedule`)
+        }
+      )
     }
 
-    await this._callWriters(writer => writer.healthCheck(this._healthCheckSr), 'writer.healthCheck()')
+    await this._callWriters(writer => writer.healthCheck(), 'writer.healthCheck()')
   }
 }

package/_runners/_vmRunners/_AbstractRemote.js

@@ -0,0 +1,97 @@
+'use strict'
+const { Abstract } = require('./_Abstract')
+
+const { getVmBackupDir } = require('../../_getVmBackupDir')
+const { asyncEach } = require('@vates/async-each')
+const { Disposable } = require('promise-toolbox')
+
+exports.AbstractRemote = class AbstractRemoteVmBackupRunner extends Abstract {
+  constructor({
+    config,
+    job,
+    healthCheckSr,
+    remoteAdapters,
+    schedule,
+    settings,
+    sourceRemoteAdapter,
+    throttleStream,
+    vmUuid,
+  }) {
+    super()
+    this.config = config
+    this.job = job
+    this.remoteAdapters = remoteAdapters
+    this.scheduleId = schedule.id
+    this.timestamp = undefined
+
+    this._healthCheckSr = healthCheckSr
+    this._sourceRemoteAdapter = sourceRemoteAdapter
+    this._throttleStream = throttleStream
+    this._vmUuid = vmUuid
+
+    const allSettings = job.settings
+    const writers = new Set()
+    this._writers = writers
+
+    const RemoteWriter = this._getRemoteWriter()
+    Object.entries(remoteAdapters).forEach(([remoteId, adapter]) => {
+      const targetSettings = {
+        ...settings,
+        ...allSettings[remoteId],
+      }
+      writers.add(
+        new RemoteWriter({
+          adapter,
+          config,
+          healthCheckSr,
+          job,
+          scheduleId: schedule.id,
+          vmUuid,
+          remoteId,
+          settings: targetSettings,
+        })
+      )
+    })
+  }
+
+  async _computeTransferList(predicate) {
+    const vmBackups = await this._sourceRemoteAdapter.listVmBackups(this._vmUuid, predicate)
+    const localMetada = new Map()
+    Object.values(vmBackups).forEach(metadata => {
+      const timestamp = metadata.timestamp
+      localMetada.set(timestamp, metadata)
+    })
+    const nbRemotes = Object.keys(this.remoteAdapters).length
+    const remoteMetadatas = {}
+    await asyncEach(Object.values(this.remoteAdapters), async remoteAdapter => {
+      const remoteMetadata = await remoteAdapter.listVmBackups(this._vmUuid, predicate)
+      remoteMetadata.forEach(metadata => {
+        const timestamp = metadata.timestamp
+        remoteMetadatas[timestamp] = (remoteMetadatas[timestamp] ?? 0) + 1
+      })
+    })
+
+    let chain = []
+    const timestamps = [...localMetada.keys()]
+    timestamps.sort()
+    for (const timestamp of timestamps) {
+      if (remoteMetadatas[timestamp] !== nbRemotes) {
+        // this backup is not present in all the remote
+        // should be retransfered if not found later
+        chain.push(localMetada.get(timestamp))
+      } else {
+        // backup is present in local and remote : the chain has already been transferred
+        chain = []
+      }
+    }
+    return chain
+  }
+
+  async run() {
+    const handler = this._sourceRemoteAdapter._handler
+    await Disposable.use(await handler.lock(getVmBackupDir(this._vmUuid)), async () => {
+      await this._run()
+      await this._healthCheck()
+    })
+  }
+}

package/_runners/_vmRunners/_AbstractXapi.js

@@ -40,11 +40,11 @@ class AbstractXapiVmBackupRunner extends Abstract {
     this.timestamp = undefined
 
     // VM currently backed up
-    this.vm = vm
-    const { tags } = this.vm
+    const tags = (this._tags = vm.tags)
 
     // VM (snapshot) that is really exported
-    this.exportedVm = undefined
+    this._exportedVm = undefined
+    this._vm = vm
 
     this._fullVdisRequired = undefined
     this._getSnapshotNameLabel = getSnapshotNameLabel
@@ -66,7 +66,6 @@ class AbstractXapiVmBackupRunner extends Abstract {
       settings.offlineSnapshot = true
     }
     this._settings = settings
-
     // Create writers
     {
       const writers = new Set()
@@ -75,13 +74,24 @@ class AbstractXapiVmBackupRunner extends Abstract {
       const [BackupWriter, ReplicationWriter] = this._getWriters()
 
       const allSettings = job.settings
-      Object.keys(remoteAdapters).forEach(remoteId => {
+      Object.entries(remoteAdapters).forEach(([remoteId, adapter]) => {
         const targetSettings = {
           ...settings,
           ...allSettings[remoteId],
         }
         if (targetSettings.exportRetention !== 0) {
-          writers.add(new BackupWriter({ backup: this, remoteId, settings: targetSettings }))
+          writers.add(
+            new BackupWriter({
+              adapter,
+              config,
+              healthCheckSr,
+              job,
+              scheduleId: schedule.id,
+              vmUuid: vm.uuid,
+              remoteId,
+              settings: targetSettings,
+            })
+          )
         }
       })
       srs.forEach(sr => {
@@ -90,7 +100,17 @@ class AbstractXapiVmBackupRunner extends Abstract {
           ...allSettings[sr.uuid],
         }
         if (targetSettings.copyRetention !== 0) {
-          writers.add(new ReplicationWriter({ backup: this, sr, settings: targetSettings }))
+          writers.add(
+            new ReplicationWriter({
+              config,
+              healthCheckSr,
+              job,
+              scheduleId: schedule.id,
+              vmUuid: vm.uuid,
+              sr,
+              settings: targetSettings,
+            })
+          )
         }
       })
     }
@@ -99,7 +119,7 @@ class AbstractXapiVmBackupRunner extends Abstract {
   // ensure the VM itself does not have any backup metadata which would be
   // copied on manual snapshots and interfere with the backup jobs
   async _cleanMetadata() {
-    const { vm } = this
+    const vm = this._vm
     if ('xo:backup:job' in vm.other_config) {
       await vm.update_other_config({
         'xo:backup:datetime': null,
@@ -113,7 +133,7 @@ class AbstractXapiVmBackupRunner extends Abstract {
   }
 
   async _snapshot() {
-    const { vm } = this
+    const vm = this._vm
     const xapi = this._xapi
 
     const settings = this._settings
@@ -138,19 +158,19 @@ class AbstractXapiVmBackupRunner extends Abstract {
           'xo:backup:vm': vm.uuid,
         })
 
-        this.exportedVm = await xapi.getRecord('VM', snapshotRef)
+        this._exportedVm = await xapi.getRecord('VM', snapshotRef)
 
-        return this.exportedVm.uuid
+        return this._exportedVm.uuid
       })
     } else {
-      this.exportedVm = vm
+      this._exportedVm = vm
       this.timestamp = Date.now()
     }
   }
 
   async _fetchJobSnapshots() {
     const jobId = this._jobId
-    const vmRef = this.vm.$ref
+    const vmRef = this._vm.$ref
     const xapi = this._xapi
 
     const snapshotsRef = await xapi.getField('VM', vmRef, 'snapshots')
@@ -177,7 +197,7 @@ class AbstractXapiVmBackupRunner extends Abstract {
       const settings = {
         ...baseSettings,
         ...allSettings[scheduleId],
-        ...allSettings[this.vm.uuid],
+        ...allSettings[this._vm.uuid],
       }
       return asyncMap(getOldEntries(settings.snapshotRetention, snapshots), ({ $ref }) => {
         if ($ref !== baseVmRef) {
@@ -224,7 +244,7 @@ class AbstractXapiVmBackupRunner extends Abstract {
     await this._cleanMetadata()
     await this._removeUnusedSnapshots()
 
-    const { vm } = this
+    const vm = this._vm
     const isRunning = vm.power_state === 'Running'
     const startAfter = isRunning && (settings.offlineBackup ? 'backup' : settings.offlineSnapshot && 'snapshot')
     if (startAfter) {

package/_runners/_writers/FullRemoteWriter.js

@@ -26,15 +26,17 @@ exports.FullRemoteWriter = class FullRemoteWriter extends MixinRemoteWriter(Abst
     )
   }
 
-  async _run({ timestamp, sizeContainer, stream }) {
-    const backup = this._backup
+  async _run({ timestamp, sizeContainer, stream, vm, vmSnapshot }) {
     const settings = this._settings
-
-    const { job, scheduleId, vm } = backup
+    const job = this._job
+    const scheduleId = this._scheduleId
 
     const adapter = this._adapter
-
-    // TODO: clean VM backup directory
+    let metadata = await this._isAlreadyTransferred(timestamp)
+    if (metadata !== undefined) {
+      // @todo : should skip backup while being vigilant to not stuck the forked stream
+      Task.info('This backup has already been transfered')
+    }
 
     const oldBackups = getOldEntries(
       settings.exportRetention - 1,
@@ -47,14 +49,14 @@ exports.FullRemoteWriter = class FullRemoteWriter extends MixinRemoteWriter(Abst
     const dataBasename = basename + '.xva'
     const dataFilename = this._vmBackupDir + '/' + dataBasename
 
-    const metadata = {
+    metadata = {
       jobId: job.id,
       mode: job.mode,
       scheduleId,
       timestamp,
       version: '2.0.0',
       vm,
-      vmSnapshot: this._backup.exportedVm,
+      vmSnapshot,
       xva: './' + dataBasename,
     }
 

package/_runners/_writers/FullXapiWriter.js

@@ -32,10 +32,11 @@ exports.FullXapiWriter = class FullXapiWriter extends MixinXapiWriter(AbstractFu
     )
   }
 
-  async _run({ timestamp, sizeContainer, stream }) {
+  async _run({ timestamp, sizeContainer, stream, vm }) {
     const sr = this._sr
     const settings = this._settings
-    const { job, scheduleId, vm } = this._backup
+    const job = this._job
+    const scheduleId = this.scheduleId
 
     const { uuid: srUuid, $xapi: xapi } = sr
 

package/_runners/_writers/IncrementalRemoteWriter.js

@@ -26,10 +26,9 @@ const { warn } = createLogger('xo:backups:DeltaBackupWriter')
 class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWriter) {
   async checkBaseVdis(baseUuidToSrcVdi) {
     const { handler } = this._adapter
-    const backup = this._backup
     const adapter = this._adapter
 
-    const vdisDir = `${this._vmBackupDir}/vdis/${backup.job.id}`
+    const vdisDir = `${this._vmBackupDir}/vdis/${this._job.id}`
 
     await asyncMap(baseUuidToSrcVdi, async ([baseUuid, srcVdi]) => {
       let found = false
@@ -91,11 +90,12 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
   async _prepare() {
     const adapter = this._adapter
     const settings = this._settings
-    const { scheduleId, vm } = this._backup
+    const scheduleId = this._scheduleId
+    const vmUuid = this._vmUuid
 
     const oldEntries = getOldEntries(
       settings.exportRetention - 1,
-      await adapter.listVmBackups(vm.uuid, _ => _.mode === 'delta' && _.scheduleId === scheduleId)
+      await adapter.listVmBackups(vmUuid, _ => _.mode === 'delta' && _.scheduleId === scheduleId)
     )
     this._oldEntries = oldEntries
 
@@ -134,16 +134,19 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
     }
   }
 
-  async _transfer($defer, { timestamp, deltaExport }) {
+  async _transfer($defer, { differentialVhds, timestamp, deltaExport, vm, vmSnapshot }) {
     const adapter = this._adapter
-    const backup = this._backup
-
-    const { job, scheduleId, vm } = backup
+    const job = this._job
+    const scheduleId = this._scheduleId
 
     const jobId = job.id
     const handler = adapter.handler
 
-    // TODO: clean VM backup directory
+    let metadataContent = await this._isAlreadyTransferred(timestamp)
+    if (metadataContent !== undefined) {
+      // @todo : should skip backup while being vigilant to not stuck the forked stream
+      Task.info('This backup has already been transfered')
+    }
 
     const basename = formatFilenameDate(timestamp)
     const vhds = mapValues(
@@ -158,7 +161,7 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
         }/${adapter.getVhdFileName(basename)}`
     )
 
-    const metadataContent = {
+    metadataContent = {
       jobId,
       mode: job.mode,
       scheduleId,
@@ -169,16 +172,15 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
       vifs: deltaExport.vifs,
       vhds,
       vm,
-      vmSnapshot: this._backup.exportedVm,
+      vmSnapshot,
     }
-
     const { size } = await Task.run({ name: 'transfer' }, async () => {
       let transferSize = 0
       await Promise.all(
         map(deltaExport.vdis, async (vdi, id) => {
           const path = `${this._vmBackupDir}/${vhds[id]}`
 
-          const isDelta = vdi.other_config['xo:base_delta'] !== undefined
+          const isDelta = differentialVhds[`${id}.vhd`]
           let parentPath
           if (isDelta) {
             const vdiDir = dirname(path)
@@ -191,7 +193,11 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
               .sort()
               .pop()
 
-            assert.notStrictEqual(parentPath, undefined, `missing parent of ${id}`)
+            assert.notStrictEqual(
+              parentPath,
+              undefined,
+              `missing parent of ${id} in ${dirname(path)}, looking for ${vdi.other_config['xo:base_delta']}`
+            )
 
             parentPath = parentPath.slice(1) // remove leading slash
 
@@ -204,7 +210,7 @@ class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWrite
             // merges and chainings
             checksum: false,
             validator: tmpPath => checkVhd(handler, tmpPath),
-            writeBlockConcurrency: this._backup.config.writeBlockConcurrency,
+            writeBlockConcurrency: this._config.writeBlockConcurrency,
           })
 
           if (isDelta) {

package/_runners/_writers/IncrementalXapiWriter.js

@@ -16,7 +16,7 @@ const { listReplicatedVms } = require('./_listReplicatedVms.js')
 exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
   async checkBaseVdis(baseUuidToSrcVdi, baseVm) {
     const sr = this._sr
-    const replicatedVm = listReplicatedVms(sr.$xapi, this._backup.job.id, sr.uuid, this._backup.vm.uuid).find(
+    const replicatedVm = listReplicatedVms(sr.$xapi, this._job.id, sr.uuid, this._vmUuid).find(
       vm => vm.other_config[TAG_COPY_SRC] === baseVm.uuid
     )
     if (replicatedVm === undefined) {
@@ -49,9 +49,10 @@ exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWri
         type: 'SR',
       },
     })
+    const hasHealthCheckSr = this._healthCheckSr !== undefined
     this.transfer = task.wrapFn(this.transfer)
-    this.cleanup = task.wrapFn(this.cleanup)
-    this.healthCheck = task.wrapFn(this.healthCheck, true)
+    this.cleanup = task.wrapFn(this.cleanup, !hasHealthCheckSr)
+    this.healthCheck = task.wrapFn(this.healthCheck, hasHealthCheckSr)
 
     return task.run(() => this._prepare())
   }
@@ -59,12 +60,13 @@ exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWri
   async _prepare() {
     const settings = this._settings
     const { uuid: srUuid, $xapi: xapi } = this._sr
-    const { scheduleId, vm } = this._backup
+    const vmUuid = this._vmUuid
+    const scheduleId = this._scheduleId
 
     // delete previous interrupted copies
-    ignoreErrors.call(asyncMapSettled(listReplicatedVms(xapi, scheduleId, undefined, vm.uuid), vm => vm.$destroy))
+    ignoreErrors.call(asyncMapSettled(listReplicatedVms(xapi, scheduleId, undefined, vmUuid), vm => vm.$destroy))
 
-    this._oldEntries = getOldEntries(settings.copyRetention - 1, listReplicatedVms(xapi, scheduleId, srUuid, vm.uuid))
+    this._oldEntries = getOldEntries(settings.copyRetention - 1, listReplicatedVms(xapi, scheduleId, srUuid, vmUuid))
 
     if (settings.deleteFirst) {
       await this._deleteOldEntries()
@@ -81,10 +83,11 @@ exports.IncrementalXapiWriter = class IncrementalXapiWriter extends MixinXapiWri
     return asyncMapSettled(this._oldEntries, vm => vm.$destroy())
   }
 
-  async _transfer({ timestamp, deltaExport, sizeContainers }) {
+  async _transfer({ timestamp, deltaExport, sizeContainers, vm }) {
     const { _warmMigration } = this._settings
     const sr = this._sr
-    const { job, scheduleId, vm } = this._backup
+    const job = this._job
+    const scheduleId = this._scheduleId
 
     const { uuid: srUuid, $xapi: xapi } = sr
 

package/_runners/_writers/_AbstractFullWriter.js

@@ -3,9 +3,9 @@
 const { AbstractWriter } = require('./_AbstractWriter.js')
 
 exports.AbstractFullWriter = class AbstractFullWriter extends AbstractWriter {
-  async run({ timestamp, sizeContainer, stream }) {
+  async run({ timestamp, sizeContainer, stream, vm, vmSnapshot }) {
     try {
-      return await this._run({ timestamp, sizeContainer, stream })
+      return await this._run({ timestamp, sizeContainer, stream, vm, vmSnapshot })
     } finally {
       // ensure stream is properly closed
       stream.destroy()

package/_runners/_writers/_AbstractIncrementalWriter.js

@@ -15,9 +15,9 @@ exports.AbstractIncrementalWriter = class AbstractIncrementalWriter extends Abst
     throw new Error('Not implemented')
   }
 
-  async transfer({ timestamp, deltaExport, sizeContainers }) {
+  async transfer({ deltaExport, ...other }) {
     try {
-      return await this._transfer({ timestamp, deltaExport, sizeContainers })
+      return await this._transfer({ deltaExport, ...other })
     } finally {
       // ensure all streams are properly closed
       for (const stream of Object.values(deltaExport.streams)) {

package/_runners/_writers/_AbstractWriter.js

@@ -1,9 +1,16 @@
 'use strict'
 
+const { formatFilenameDate } = require('../../_filenameDate')
+const { getVmBackupDir } = require('../../_getVmBackupDir')
+
 exports.AbstractWriter = class AbstractWriter {
-  constructor({ backup, settings }) {
-    this._backup = backup
+  constructor({ config, healthCheckSr, job, vmUuid, scheduleId, settings }) {
+    this._config = config
+    this._healthCheckSr = healthCheckSr
+    this._job = job
+    this._scheduleId = scheduleId
     this._settings = settings
+    this._vmUuid = vmUuid
   }
 
   beforeBackup() {}
@@ -11,4 +18,14 @@ exports.AbstractWriter = class AbstractWriter {
   afterBackup() {}
 
   healthCheck(sr) {}
+
+  _isAlreadyTransferred(timestamp) {
+    const vmUuid = this._vmUuid
+    const adapter = this._adapter
+    const backupDir = getVmBackupDir(vmUuid)
+    try {
+      const actualMetadata = JSON.parse(adapter._handler.readFile(`${backupDir}/${formatFilenameDate(timestamp)}.json`))
+      return actualMetadata
+    } catch (error) {}
+  }
 }

package/_runners/_writers/_MixinRemoteWriter.js

@@ -17,13 +17,13 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
   class MixinRemoteWriter extends BaseClass {
     #lock
 
-    constructor({ remoteId, ...rest }) {
+    constructor({ remoteId, adapter, ...rest }) {
       super(rest)
 
-      this._adapter = rest.backup.remoteAdapters[remoteId]
+      this._adapter = adapter
       this._remoteId = remoteId
 
-      this._vmBackupDir = getVmBackupDir(this._backup.vm.uuid)
+      this._vmBackupDir = getVmBackupDir(rest.vmUuid)
     }
 
     async _cleanVm(options) {
@@ -38,7 +38,7 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
               Task.warning(message, data)
             },
             lock: false,
-            mergeBlockConcurrency: this._backup.config.mergeBlockConcurrency,
+            mergeBlockConcurrency: this._config.mergeBlockConcurrency,
           })
         })
       } catch (error) {
@@ -55,7 +55,7 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
     }
 
     async afterBackup() {
-      const { disableMergeWorker } = this._backup.config
+      const { disableMergeWorker } = this._config
       // merge worker only compatible with local remotes
       const { handler } = this._adapter
       const willMergeInWorker = !disableMergeWorker && typeof handler.getRealPath === 'function'
@@ -76,7 +76,9 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
       }
     }
 
-    healthCheck(sr) {
+    healthCheck() {
+      const sr = this._healthCheckSr
+      assert.notStrictEqual(sr, undefined, 'SR should be defined before making a health check')
       assert.notStrictEqual(
         this._metadataFileName,
         undefined,
@@ -109,4 +111,16 @@ exports.MixinRemoteWriter = (BaseClass = Object) =>
         }
       )
     }
+
+    _isAlreadyTransferred(timestamp) {
+      const vmUuid = this._vmUuid
+      const adapter = this._adapter
+      const backupDir = getVmBackupDir(vmUuid)
+      try {
+        const actualMetadata = JSON.parse(
+          adapter._handler.readFile(`${backupDir}/${formatFilenameDate(timestamp)}.json`)
+        )
+        return actualMetadata
+      } catch (error) {}
+    }
   }

package/_runners/_writers/_MixinXapiWriter.js

@@ -14,7 +14,9 @@ exports.MixinXapiWriter = (BaseClass = Object) =>
       this._sr = sr
     }
 
-    healthCheck(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(

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.37.0",
+  "version": "0.38.1",
   "engines": {
     "node": ">=14.6"
   },
@@ -42,7 +42,7 @@
     "promise-toolbox": "^0.21.0",
     "proper-lockfile": "^4.1.2",
     "uuid": "^9.0.0",
-    "vhd-lib": "^4.4.1",
+    "vhd-lib": "^4.5.0",
     "yazl": "^2.5.1"
   },
   "devDependencies": {