@xen-orchestra/backups 0.72.1 → 0.73.0

package/ImportVmBackup.mjs

@@ -10,7 +10,7 @@ import { dirname, join } from 'node:path'
 import pickBy from 'lodash/pickBy.js'
 import { defer } from 'golike-defer'
 import { NegativeDisk } from '@xen-orchestra/disk-transform'
-import { openDiskChain } from './disks/openDiskChain.mjs'
+import { openDiskChain } from '@xen-orchestra/backup-archive/disks'
 import { resetVmOtherConfig } from './_otherConfig.mjs'
 
 const { debug, info, warn } = createLogger('xo:backups:importVmBackup')

package/RemoteAdapter.mjs

@@ -22,7 +22,7 @@ import * as tar from 'tar'
 import zlib from 'zlib'
 
 import { BACKUP_DIR } from './_getVmBackupDir.mjs'
-import { cleanVm } from './_cleanVm.mjs'
+import { VmBackupDirectory } from '@xen-orchestra/backup-archive'
 import { formatFilenameDate } from './_filenameDate.mjs'
 import { getTmpDir } from './_getTmpDir.mjs'
 import { isMetadataFile } from './_backupType.mjs'
@@ -31,8 +31,7 @@ import { listPartitions, LVM_PARTITION_TYPE_MBR, LVM_PARTITION_TYPE_GPT } from '
 import { lvs, pvs } from './_lvm.mjs'
 import { watchStreamSize } from './_watchStreamSize.mjs'
 
-import { RemoteVhdDisk } from './disks/RemoteVhdDisk.mjs'
-import { openDiskChain } from './disks/openDiskChain.mjs'
+import { RemoteVhdDisk, openDiskChain } from '@xen-orchestra/backup-archive/disks'
 import { toVhdStream, writeToVhdDirectory } from 'vhd-lib/disk-consumer/index.mjs'
 import { ReadAhead } from '@xen-orchestra/disk-transform'
 
@@ -879,11 +878,14 @@ export class RemoteAdapter {
 }
 
 Object.assign(RemoteAdapter.prototype, {
-  cleanVm(vmDir, { lock = true } = {}) {
+  cleanVm(vmBackupPath, opts = {}) {
+    const { lock = true, ...cleanOpts } = opts
     if (lock) {
-      return Disposable.use(this._handler.lock(vmDir), () => cleanVm.apply(this, arguments))
+      return Disposable.use(this._handler.lock(vmBackupPath), () => {
+        return VmBackupDirectory.cleanVm(this._handler, vmBackupPath, cleanOpts)
+      })
     } else {
-      return cleanVm.apply(this, arguments)
+      return VmBackupDirectory.cleanVm(this._handler, vmBackupPath, cleanOpts)
     }
   },
   isValidXva,

package/_otherConfig.mjs

@@ -85,6 +85,7 @@ export async function getVmDeltaChainLength(xapi, vmRef) {
 export function resetVmOtherConfig(xapi, vmRef) {
   return applyToVmAndVdis(xapi, vmRef, (type, ref) => {
     return xapi.setFieldEntries(type, ref, 'other_config', {
+      [CONTENT_KEY]: null,
       [COPY_OF]: null,
       [DATETIME]: null,
       [DELTA_CHAIN_LENGTH]: null,
@@ -92,6 +93,7 @@ export function resetVmOtherConfig(xapi, vmRef) {
       [JOB_ID]: null,
       [SCHEDULE_ID]: null,
       [VM_UUID]: null,
+
       // REPLICATED_TO_SR_UUID is not reset since we can replicate a replication
     })
   })

package/_runners/_vmRunners/IncrementalXapi.mjs

@@ -8,6 +8,7 @@ import { exportIncrementalVm } from '../../_incrementalVm.mjs'
 import { IncrementalRemoteWriter } from '../_writers/IncrementalRemoteWriter.mjs'
 import { IncrementalXapiWriter } from '../_writers/IncrementalXapiWriter.mjs'
 import {
+  CONTENT_KEY,
   DATETIME,
   DELTA_CHAIN_LENGTH,
   EXPORTED_SUCCESSFULLY,
@@ -101,63 +102,136 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
     await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
   }
 
+  /**
+   * Groups snapshot VDIs by their DATETIME other_config value and sorts them most-recent-first.
+   *
+   * @param {import('@vates/types').XenApiVdi[]} snapshotVdis
+   * @returns {{ datetime: string, vdis: import('@vates/types').XenApiVdi[] }[]}
+   */
+  _groupSnapshotVdisByDatetime(snapshotVdis) {
+    const byDatetime = new Map()
+    for (const vdi of snapshotVdis) {
+      const datetime = vdi.other_config[DATETIME]
+      if (!byDatetime.has(datetime)) {
+        byDatetime.set(datetime, [])
+      }
+      byDatetime.get(datetime).push(vdi)
+    }
+    // sort them by decreasing datetime
+    return [...byDatetime.entries()]
+      .sort(([a], [b]) => b.localeCompare(a))
+      .map(([datetime, vdis]) => ({ datetime, vdis }))
+  }
+
+  /**
+   * For each snapshot VDI in `snapshotVdis`, maps it to its live source VDI,
+   * attaches its CONTENT_KEY when present, calls checkBaseVdis on all writers,
+   * and returns both the full mapping and the subset confirmed present by writers.
+   *
+   * @param {import('@vates/types').XenApiVdi[]} snapshotVdis - Snapshot VDI records to use as base candidates
+   * @param {Record<string, object>} srcVdisByRef - Live VM VDI records keyed by $ref
+   * @param {{ useContentKey?: boolean }} [options]
+   * @returns {Promise<{ presentBaseVdis: Map<string, string>, baseUuidToSrcVdiUuid: Map<string, string>}>}
+   */
+  async _checkBaseVdis(snapshotVdis, srcVdisByRef, { useContentKey = false } = {}) {
+    const baseUuidToSrcVdiUuid = new Map()
+    const baseUuidToContentKey = new Map()
+    for (const snapshotVdi of snapshotVdis) {
+      const baseUuid = snapshotVdi.uuid
+      const srcVdi = srcVdisByRef[snapshotVdi.snapshot_of]
+      if (srcVdi !== undefined) {
+        baseUuidToSrcVdiUuid.set(baseUuid, srcVdi.uuid)
+        if (useContentKey) {
+          const contentKey = snapshotVdi.other_config[CONTENT_KEY]
+          if (contentKey !== undefined) {
+            baseUuidToContentKey.set(baseUuid, contentKey)
+          }
+        }
+      } else {
+        debug('ignore snapshot VDI because no longer present on VM', { vdi: baseUuid })
+      }
+    }
+
+    const presentBaseVdis = new Map(baseUuidToSrcVdiUuid)
+    await this._callWriters(
+      writer => presentBaseVdis.size !== 0 && writer.checkBaseVdis(presentBaseVdis, baseUuidToContentKey),
+      'writer.checkBaseVdis()',
+      false
+    )
+    return { presentBaseVdis, baseUuidToSrcVdiUuid }
+  }
+
   async _selectBaseVm() {
     const xapi = this._xapi
 
-    // filter _jobSnapshotVdis to have only the last successfully exported vdi
-    // compute delta chain length
-    // fill baseUuidToSrcVdi with this data
-
     const exportedVdis = this._jobSnapshotVdis.filter(
       _ => EXPORTED_SUCCESSFULLY in _.other_config && DATETIME in _.other_config
     )
-    let lastSuccessfullBackup
-    let lastExportedVdis = []
-    for (const exportedVdi of exportedVdis) {
-      if (lastSuccessfullBackup === undefined || lastSuccessfullBackup < exportedVdi.other_config[DATETIME]) {
-        lastExportedVdis = []
-        lastSuccessfullBackup = exportedVdi.other_config[DATETIME]
-      }
-      if (lastSuccessfullBackup === exportedVdi.other_config[DATETIME]) {
-        lastExportedVdis.push(exportedVdi)
-      }
-    }
+    const grouped = this._groupSnapshotVdisByDatetime(exportedVdis)
 
     this._baseVdis = {}
-    if (lastExportedVdis.length === 0) {
-      debug('no base VDIS found', {
+    if (grouped.length === 0) {
+      debug('no base VDIs found', {
         jobLength: this._jobSnapshotVdis.length,
-        lastSuccessfullBackup,
         exportedLength: exportedVdis.length,
       })
-      return
     }
-    const deltaChainLength = Math.max(
-      ...lastExportedVdis.map(({ other_config }) => Number(other_config[DELTA_CHAIN_LENGTH] ?? 0))
-    )
-
     const srcVdis = keyBy(await xapi.getRecords('VDI', await this._vm.$getDisks()), '$ref')
+    let lastExportedVdis = []
+    let presentBaseVdis = new Map()
+    let baseUuidToSrcVdiUuid = new Map()
+    let deltaChainLength
 
-    const baseUuidToSrcVdiUuid = new Map()
-    for (const lastExportedVdi of lastExportedVdis) {
-      const baseUuid = lastExportedVdi.uuid
-      const snapshotOf = lastExportedVdi.snapshot_of
-      const srcVdi = srcVdis[snapshotOf]
-      if (srcVdi !== undefined) {
-        baseUuidToSrcVdiUuid.set(baseUuid, srcVdi.uuid)
-      } else {
-        debug('ignore snapshot VDI because no longer present on VM', {
-          vdi: baseUuid,
-        })
-      }
+    if (grouped.length > 0) {
+      lastExportedVdis = grouped[0].vdis
+      // only compute it on the _jobSnapshotVdis , not on the reused snapshot from CONTENT_KEYS
+      deltaChainLength = Math.max(
+        ...lastExportedVdis.map(({ other_config }) => Number(other_config[DELTA_CHAIN_LENGTH] ?? 0))
+      )
+      ;({ presentBaseVdis, baseUuidToSrcVdiUuid } = await this._checkBaseVdis(lastExportedVdis, srcVdis))
     }
 
-    const presentBaseVdis = new Map(baseUuidToSrcVdiUuid)
-    await this._callWriters(
-      writer => presentBaseVdis.size !== 0 && writer.checkBaseVdis(presentBaseVdis),
-      'writer.checkBaseVdis()',
-      false
-    )
+    // if we don't find any candidates
+    // if there is only one writer of type IncrementalXapiWriter
+    // allow the reuse of any matching snapshot of this VM even from another job
+    if (
+      presentBaseVdis.size === 0 &&
+      this._writers.size === 1 &&
+      [...this._writers][0] instanceof IncrementalXapiWriter
+    ) {
+      debug('fallback to content key')
+      const candidates = {}
+      for (const srcVdi of Object.values(srcVdis)) {
+        const snapshots = srcVdi.$snapshots
+        debug(`${srcVdi.uuid} got ${snapshots.length} snapshots`)
+        for (const snapshot of snapshots) {
+          if (DATETIME in snapshot.other_config) {
+            candidates[snapshot.uuid] = snapshot
+          }
+        }
+      }
+
+      debug('got candidates ', Object.keys(candidates).length)
+      this._filterValidSnapshotVdis(candidates)
+      debug('got filtered  ', Object.keys(candidates).length)
+      for (const group of this._groupSnapshotVdisByDatetime(Object.values(candidates))) {
+        debug('check by datetime   ', [...group.vdis].length)
+        debug(group.vdis)
+        const result = await this._checkBaseVdis(group.vdis, srcVdis, { useContentKey: true })
+        debug('result ', result)
+        if (result.presentBaseVdis.size > 0) {
+          lastExportedVdis = group.vdis
+
+          presentBaseVdis = result.presentBaseVdis
+          baseUuidToSrcVdiUuid = result.baseUuidToSrcVdiUuid
+
+          break
+        }
+        debug('try next group if any')
+      }
+    } else {
+      debug(' no fallback ')
+    }
 
     if (presentBaseVdis.size === 0) {
       debug('no base VM found')

package/_runners/_vmRunners/_AbstractXapi.mjs

@@ -236,28 +236,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
   //   ensure they are attached to only one vm snapshot
   //   ensure any VM-snapshot harvested by this has all its disk harvested (no mix of vdi snapshot from this job and not)
 
-  async _fetchJobSnapshots() {
-    const jobId = this._jobId
-    const xapi = this._xapi
-
-    const vdiCandidates = {}
-    const vdiUuids = this._vm.$VBDs.map(({ VDI }) => VDI)
-    Object.values(xapi.objects.indexes.type.VDI)
-      .filter(_ => !!_) // filter nullish
-      .filter(({ other_config, snapshot_of }) => {
-        return (
-          vdiUuids.includes(snapshot_of) &&
-          other_config[JOB_ID] === jobId &&
-          other_config[VM_UUID] === this._vm.uuid &&
-          other_config[COPY_OF] === undefined
-        )
-      })
-      .forEach(vdi => {
-        vdiCandidates[vdi.uuid] = vdi
-      })
-
-    // check that user snapshots are clean
-
+  _filterValidSnapshotVdis(vdiCandidates) {
     for (const vdi of Object.values(vdiCandidates)) {
       // cbt metadata are always considered linked to a backup job
       // if they have the right other_config
@@ -279,7 +258,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
       const userVms = vbds.map(({ $VM }) => $VM)
       if (vbds.length > 1) {
         warn(
-          `vdi ${vdi.name_label} (${vdi.uuid}) is linked to multipe vms :  ${userVms.map(({ name_label, uuid }) => `${name_label} ${uuid}`).join(', ')}. 
+          `vdi ${vdi.name_label} (${vdi.uuid}) is linked to multipe vms :  ${userVms.map(({ name_label, uuid }) => `${name_label} ${uuid}`).join(', ')}.
               This disk snapshot will be excluded from the backup cleaning`,
           { vdi, userVms }
         )
@@ -294,7 +273,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
       // => we exclude these from the backup processing
       if (vm.$snapshot_of === undefined) {
         warn(
-          `vdi ${vdi.name_label} (${vdi.uuid}) is a snapshot linked to a non snapshot vm ${vm.name_label} ${vm.uuid}. 
+          `vdi ${vdi.name_label} (${vdi.uuid}) is a snapshot linked to a non snapshot vm ${vm.name_label} ${vm.uuid}.
           This disk snapshot will be excluded from the backup cleaning`,
           { vdi, vm }
         )
@@ -311,7 +290,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
         vm.other_config[VM_UUID] !== vdi.other_config[VM_UUID]
       ) {
         warn(
-          `vdi ${vdi.name_label} (${vdi.uuid}) is a snapshot linked to a snapshot vm ${vm.name_label} ${vm.uuid} out of this backup job scope. 
+          `vdi ${vdi.name_label} (${vdi.uuid}) is a snapshot linked to a snapshot vm ${vm.name_label} ${vm.uuid} out of this backup job scope.
           This disk snapshot will be excluded from the backup cleaning`,
           { vdi, vm }
         )
@@ -328,7 +307,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
         .forEach(({ $VDI: outOfSnapshotsVdi, ...other }) => {
           warn(
             `vdi ${vdi.name_label} ${vdi.uuid} is recognized as a snapshot of the backup job,
-           linked to vm ${vm.name_label} ${vm.uuid} but vdi ${outOfSnapshotsVdi.name_label} ${outOfSnapshotsVdi.uuid} 
+           linked to vm ${vm.name_label} ${vm.uuid} but vdi ${outOfSnapshotsVdi.name_label} ${outOfSnapshotsVdi.uuid}
            is not linked to the job. This disk snapshot will be excluded from the backup cleaning`,
             { vdi, vm, vbds, outOfSnapshotsVdi }
           )
@@ -336,19 +315,44 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
           delete vdiCandidates[vdi.uuid]
         })
     }
+  }
+
+  async _fetchJobSnapshots() {
+    const jobId = this._jobId
+    const xapi = this._xapi
+
+    const vdiCandidates = {}
+    const vdiUuids = this._vm.$VBDs.map(({ VDI }) => VDI)
+    Object.values(xapi.objects.indexes.type.VDI)
+      .filter(_ => !!_) // filter nullish
+      .filter(({ other_config, snapshot_of }) => {
+        return (
+          vdiUuids.includes(snapshot_of) &&
+          other_config[JOB_ID] === jobId &&
+          other_config[VM_UUID] === this._vm.uuid &&
+          other_config[COPY_OF] === undefined
+        )
+      })
+      .forEach(vdi => {
+        vdiCandidates[vdi.uuid] = vdi
+      })
+
+    this._filterValidSnapshotVdis(vdiCandidates)
 
     this._jobSnapshotVdis = Object.values(vdiCandidates)
 
     // For VMs with no disks, retention must be tracked directly on VM snapshots
     // since there are no VDIs to anchor the discovery.
     if (vdiUuids.length === 0) {
-      this._disklessJobSnapshotVms = this._vm.$snapshots.filter(Boolean).filter(
-        ({ other_config, $snapshot_of }) =>
-          $snapshot_of !== undefined &&
-          other_config[JOB_ID] === jobId &&
-          other_config[VM_UUID] === this._vm.uuid &&
-          other_config[COPY_OF] === undefined
-      )
+      this._disklessJobSnapshotVms = this._vm.$snapshots
+        .filter(Boolean)
+        .filter(
+          ({ other_config, $snapshot_of }) =>
+            $snapshot_of !== undefined &&
+            other_config[JOB_ID] === jobId &&
+            other_config[VM_UUID] === this._vm.uuid &&
+            other_config[COPY_OF] === undefined
+        )
     } else {
       this._disklessJobSnapshotVms = []
     }
@@ -447,7 +451,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
     if (disklessVmSnapshots.length > 0) {
       const snapshotsPerSchedule = groupBy(disklessVmSnapshots, _ => _.other_config[SCHEDULE_ID])
       await asyncEach(Object.entries(snapshotsPerSchedule), async ([scheduleId, snapshots]) => {
-        // we only have one snapshot per date time since it's at the VM level 
+        // we only have one snapshot per date time since it's at the VM level
         const snapshotPerDatetime = Object.fromEntries(snapshots.map(s => [s.other_config[DATETIME], s.$ref]))
         const datetimes = Object.keys(snapshotPerDatetime).sort()
         const settings = {

package/_runners/_writers/IncrementalXapiWriter.mjs

@@ -19,11 +19,14 @@ import {
   REPLICATED_TO_SR_UUID,
   DATETIME,
   VM_UUID,
+  CONTENT_KEY,
+  resetVmOtherConfig,
 } from '../../_otherConfig.mjs'
 import { formatFilenameDate } from '../../_filenameDate.mjs'
 import { XapiDiskSource } from '@xen-orchestra/xapi'
 import { asyncEach } from '@vates/async-each'
 import { createLogger } from '@xen-orchestra/log'
+import { VM_POWER_STATE } from '@vates/types'
 
 const { debug } = createLogger('xo:backups:IncrementalXapiWriter')
 
@@ -32,7 +35,20 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
   // Built by checkBaseVdis, consumed by #decorateVmMetadata to set baseVdi.
   #baseVdisBySourceUuid = new Map()
 
-  async checkBaseVdis(baseUuidToSrcVdi) {
+  /**
+   * Finds VDIs on the target SR that can serve as base for the next delta transfer.
+   *
+   * For each entry in `baseUuidToSrcVdi`, searches the target SR for a matching snapshot
+   * using CONTENT_KEY when available, then falls back to COPY_OF matching for older snapshots.
+   * Entries with no matching base found on the target SR are removed from `baseUuidToSrcVdi`.
+   *
+   * Side-effects: populates `#baseVdisBySourceUuid`; may set `_targetVmRef`.
+   *
+   * @param {Map<string, string>} baseUuidToSrcVdi - Source snapshot UUID → source active VDI UUID. Mutated in place.
+   * @param {Map<string, string>} contentKeys - Source snapshot UUID → CONTENT_KEY value (empty for pre-CONTENT_KEY snapshots).
+   * @returns {Promise<void>}
+   */
+  async checkBaseVdis(baseUuidToSrcVdi, contentKeys) {
     const sr = this._sr
     this.#baseVdisBySourceUuid = new Map()
 
@@ -45,18 +61,45 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     // look for the same snapshot
     // ensure there are no data between the snapshot and the active disk
 
-    const snapshotCandidates = sr.$VDIs.filter(vdi => {
-      return (
-        vdi?.managed &&
-        vdi?.is_a_snapshot &&
-        vdi.other_config[JOB_ID] === this._job.id &&
-        vdi.other_config[VM_UUID] === this._vmUuid &&
-        baseUuidToSrcVdi.has(vdi?.other_config[COPY_OF])
-      )
-    })
-    debug('checkBaseVdis, got snapshot candidates,', snapshotCandidates.length)
+    const snapshotCandidates = new Map()
+
+    for (const [baseUuid, srcVdiuid] of baseUuidToSrcVdi) {
+      let target
+
+      const contentKey = contentKeys.get(baseUuid)
+
+      if (contentKey !== undefined) {
+        debug('got one content key, look for a candidate')
+        target = sr.$VDIs.find(
+          vdi =>
+            vdi?.managed &&
+            vdi?.is_a_snapshot &&
+            vdi.other_config[CONTENT_KEY] === contentKey && // &&
+            // ensure we don't replicate on ourself or any of the vdi in the source  chain
+            vdi.$snapshot_of.uuid !== srcVdiuid
+        )
+      }
+
+      // fall back for older snapshots
+      if (target === undefined) {
+        debug('content key not here or not found , look by jobid ')
+        target = sr.$VDIs.find(
+          vdi =>
+            vdi?.managed &&
+            vdi?.is_a_snapshot &&
+            vdi.other_config[JOB_ID] === this._job.id &&
+            vdi.other_config[VM_UUID] === this._vmUuid &&
+            vdi?.other_config[COPY_OF] === baseUuid
+        )
+      }
+      if (target !== undefined) {
+        snapshotCandidates.set(baseUuid, target)
+      }
+    }
 
-    if (snapshotCandidates.length > 0) {
+    debug('checkBaseVdis, got snapshot candidates,', snapshotCandidates.size)
+
+    if (snapshotCandidates.size > 0) {
       // reset before searching for candidates
       this.#baseVdisBySourceUuid = new Map()
       this._targetVmRef = undefined
@@ -64,10 +107,12 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       for (const [sourceUuid, vdi] of baseVdisBySourceUuid) {
         this.#baseVdisBySourceUuid.set(sourceUuid, vdi)
       }
+      debug(' this.#baseVdisBySourceUuid ', this.#baseVdisBySourceUuid.size)
       if (targetVmRef !== undefined) {
         this._targetVmRef = targetVmRef
       }
     } else {
+      debug('legacy fallback ( no content key ) ')
       // Legacy fallback (upgrade from pre-6.3): no target snapshots exist yet,
       // look for active (non-snapshot) VDIs with matching COPY_OF, like the old code did.
       debug('checkBaseVdis, no snapshot candidates, falling back to legacy active VDI lookup')
@@ -92,6 +137,9 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
    * 6.3+ snapshot-based validation: for each snapshot candidate, check whether
    * the active VDI has diverged from the snapshot. Returns a baseVdisBySourceUuid
    * map and, when all disks are clean, the targetVmRef to reuse.
+   *
+   * @param {Map<XenApiVdi['id'], import('@vates/types').XenApiVdi>} snapshotCandidates - Snapshot VDIs on the target SR to validate.
+   * @returns {Promise<{ baseVdisBySourceUuid: Map<string, import('@vates/types').XenApiVdi>, targetVmRef:  import('@vates/types').XenApiVm['$ref'] | undefined }>}
    */
   async #validateSnapshotCandidates(snapshotCandidates) {
     const sr = this._sr
@@ -100,24 +148,36 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     let canChainToTargetVm = true
 
     await asyncEach(
-      snapshotCandidates,
-      async snapshot => {
+      snapshotCandidates.entries(),
+      async ([sourceUuid, snapshot]) => {
         let diffDisk
         let activeVdi
         try {
           activeVdi = sr.$xapi.getObject(snapshot.$snapshot_of)
           const userVbds = activeVdi.$VBDs?.filter(vbd => vbd.$VM && !vbd.$VM.is_control_domain) ?? []
           if (userVbds.length !== 1) {
+            canChainToTargetVm = false
             debug('checkBaseVdis, shared vbd ', { ref: snapshot.$ref, userVbds })
-            // shared vdi ignore
+            // shared vdi ignore / don't chain
             return
           }
           const vm = userVbds[0].$VM
-          if (!('start' in vm.blocked_operations)) {
-            debug('checkBaseVdis, vm not blocked', { vmRef: vm.$ref })
-            // vm start unlocked
-            // not really an issue since we have check the delta
-            // but it indicates the users played with the blocked operations
+
+          // a running VM will fail to compute disk exports
+          // also a running VM can be assumed to have changed data
+          if (vm.power_state !== VM_POWER_STATE.HALTED && vm.power_state !== VM_POWER_STATE.SUSPENDED) {
+            canChainToTargetVm = false
+            debug('checkBaseVdis, target vm is not halted or suspended', {
+              ref: snapshot.$ref,
+              userVbds,
+              powerState: vm.power_state,
+            })
+          }
+          // from this disk of from another
+          // skip the costly part, only do the disk chaining
+          if (!canChainToTargetVm) {
+            debug("Can't chain VM anyway , fast return and chain with snapshot")
+            baseVdisBySourceUuid.set(sourceUuid, snapshot)
             return
           }
           diffDisk = new XapiDiskSource({
@@ -127,18 +187,16 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
             onlyListChangedBlocks: true,
           })
           await diffDisk.init()
-          const sourceUuid = snapshot.other_config?.[COPY_OF]
           if (diffDisk.getBlockIndexes().length === 0) {
+            debug(' NO CHANGE , source detected ? ', !!sourceUuid)
             // no block modification since the common snapshot, we can chain VM and disk
-            if (sourceUuid) {
-              baseVdisBySourceUuid.set(sourceUuid, activeVdi)
-            }
+            // the disk is chained with the active to keep the chain linear
+            baseVdisBySourceUuid.set(sourceUuid, activeVdi)
             // Track the target VM (the replicated VM to update on the next transfer).
             targetVmRef = vm.$ref
           } else {
-            if (sourceUuid) {
-              baseVdisBySourceUuid.set(sourceUuid, snapshot)
-            }
+            debug(' GOT CHANGE, source detected ? ', !!sourceUuid)
+            baseVdisBySourceUuid.set(sourceUuid, snapshot)
             // there are changed block since the snapshot
             // we can reuse it to transfer a delta, but we will
             // create a new VM
@@ -165,6 +223,7 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     )
 
     if (!canChainToTargetVm) {
+      debug('checkBaseVdis,NOT a valid vm target')
       // if at least one disk has new data, create a new VM
       // instead of updating it
       targetVmRef = undefined
@@ -172,6 +231,7 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       debug('checkBaseVdis,got a valid vm target', targetVmRef)
     }
 
+    debug('checkBaseVdis,base vdis found : ', baseVdisBySourceUuid.size)
     return { baseVdisBySourceUuid, targetVmRef }
   }
 
@@ -269,6 +329,10 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     }
 
     Object.values(backup.vdis).forEach(vdi => {
+      // setVmSnapshotContentKeys sets CONTENT_KEY = the snapshot VDI's own UUID, but
+      // that XenAPI write may not be visible in the xapi cache yet when exportIncrementalVm
+      // reads vdi.other_config. Derive the correct value directly instead of relying on cache.
+      vdi.other_config[CONTENT_KEY] = vdi.uuid
       vdi.other_config[COPY_OF] = vdi.uuid
       vdi.other_config[JOB_ID] = job.id
       vdi.other_config[SCHEDULE_ID] = scheduleId
@@ -327,6 +391,7 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
         await xapi.VM_snapshot(targetVmRef, {
           name_label: `${vm.name_label} - ${job.name} / ${schedule.name} ${formatFilenameDate(timestamp)}`,
         })
+        await resetVmOtherConfig(xapi, targetVmRef)
       })
 
       return {

package/_runners/_writers/_MixinRemoteWriter.mjs

@@ -31,7 +31,6 @@ export const MixinRemoteWriter = (BaseClass = Object) =>
         return await Task.run({ properties: { name: 'clean-vm' } }, () => {
           return this._adapter.cleanVm(this._vmBackupDir, {
             ...options,
-            fixMetadata: true,
             logInfo: info,
             logWarn: (message, data) => {
               warn(message, data)
@@ -39,7 +38,6 @@ export const MixinRemoteWriter = (BaseClass = Object) =>
             },
             lock: false,
             mergeBlockConcurrency: this._config.mergeBlockConcurrency,
-            removeTmp: true,
           })
         })
       } catch (error) {

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.72.1",
+  "version": "0.73.0",
   "engines": {
     "node": ">=14.18"
   },
@@ -30,12 +30,14 @@
     "@vates/nbd-client": "^3.4.0",
     "@vates/parse-duration": "^0.1.1",
     "@vates/task": "^0.7.0",
+    "@vates/types": "^1.25.0",
     "@xen-orchestra/async-map": "^0.1.3",
-    "@xen-orchestra/disk-transform": "^1.2.3",
-    "@xen-orchestra/fs": "^4.8.0",
+    "@xen-orchestra/disk-transform": "^1.3.0",
+    "@xen-orchestra/fs": "^4.9.0",
     "@xen-orchestra/log": "^0.7.2",
     "@xen-orchestra/qcow2": "^1.3.0",
     "@xen-orchestra/template": "^0.1.1",
+    "@xen-orchestra/backup-archive": "^2.0.0",
     "app-conf": "^3.0.0",
     "compare-versions": "^6.0.0",
     "d3-time-format": "^4.1.0",
@@ -61,10 +63,11 @@
     "fs-extra": "^11.1.0",
     "rimraf": "^6.0.1",
     "sinon": "^18.0.0",
-    "tmp": "^0.2.1"
+    "tmp": "^0.2.1",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^8.7.2"
+    "@xen-orchestra/xapi": "^8.8.0"
   },
   "license": "AGPL-3.0-or-later",
   "author": {
@@ -72,7 +75,6 @@
     "url": "https://vates.fr"
   },
   "exports": {
-    "./disks": "./disks/index.mjs",
     "./*": "./*"
   }
 }