@xen-orchestra/backups 0.69.3 → 0.70.0

package/ImportVmBackup.mjs

@@ -255,6 +255,14 @@ export class ImportVmBackup {
           : await importIncrementalVm(backup, await xapi.getRecord('SR', srRef), {
               newMacAddresses,
             })
+        let size = 0
+        if (isFull) {
+          size = sizeContainer.size
+        } else {
+          for (const disk of Object.values(backup.disks)) {
+            size += disk.getNbGeneratedBlock() * disk.getBlockSize()
+          }
+        }
         const remoteName = adapter._handler._remote.name
         let desc = `Restored on ${formatFilenameDate(+new Date())}`
         if (remoteName !== undefined) {
@@ -275,7 +283,7 @@ export class ImportVmBackup {
         ])
 
         return {
-          size: sizeContainer.size,
+          size,
           id: await xapi.getField('VM', vmRef, 'uuid'),
         }
       }

package/_incrementalVm.mjs

@@ -8,7 +8,7 @@ import { defer } from 'golike-defer'
 import { cancelableMap } from './_cancelableMap.mjs'
 import { Task } from './Task.mjs'
 import pick from 'lodash/pick.js'
-import { BASE_DELTA_VDI, COPY_OF, VM_UUID } from './_otherConfig.mjs'
+import { BASE_DELTA_VDI, CONTENT_KEY, COPY_OF, VM_UUID } from './_otherConfig.mjs'
 
 import { VHD_MAX_SIZE, XapiDiskSource } from '@xen-orchestra/xapi'
 import { toVhdStream } from 'vhd-lib/disk-consumer/index.mjs'
@@ -124,7 +124,7 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
   $defer,
   incrementalVm,
   sr,
-  { cancelToken = CancelToken.none, newMacAddresses = false } = {}
+  { cancelToken = CancelToken.none, newMacAddresses = false, targetRef = undefined } = {}
 ) {
   const { version } = incrementalVm
   if (compareVersions(version, '1.0.0') < 0) {
@@ -136,44 +136,106 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
 
   const vdiRecords = incrementalVm.vdis
 
-  // 0. Create suspend_VDI
+  // When targetRef is provided, update the existing VM instead of creating a new one.
+  const targetVm = targetRef !== undefined ? xapi.getObjectByRef(targetRef, undefined) : undefined
+  const isUpdate = targetVm !== undefined && !targetVm.is_a_snapshot && !targetVm.is_a_template
+
+  // 0. Create suspend_VDI (only when creating a new VM).
   let suspendVdi
-  if (vmRecord.suspend_VDI !== undefined && vmRecord.suspend_VDI !== 'OpaqueRef:NULL') {
-    const vdi = vdiRecords[vmRecord.suspend_VDI]
-    if (vdi === undefined) {
-      Task.warning('Suspend VDI not available for this suspended VM', {
-        vm: pick(vmRecord, 'uuid', 'name_label', 'suspend_VDI'),
-      })
-    } else {
-      suspendVdi = await xapi.getRecord('VDI', await xapi.VDI_create(vdi))
-      $defer.onFailure(() => suspendVdi.$destroy())
+  if (!isUpdate) {
+    if (vmRecord.suspend_VDI !== undefined && vmRecord.suspend_VDI !== 'OpaqueRef:NULL') {
+      const vdi = vdiRecords[vmRecord.suspend_VDI]
+      if (vdi === undefined) {
+        Task.warning('Suspend VDI not available for this suspended VM', {
+          vm: pick(vmRecord, 'uuid', 'name_label', 'suspend_VDI'),
+        })
+      } else {
+        suspendVdi = await xapi.getRecord('VDI', await xapi.VDI_create(vdi))
+        $defer.onFailure(() => suspendVdi.$destroy())
+      }
     }
   }
 
-  // 1. Create the VM.
-  const vmRef = await xapi.VM_create(
-    {
-      ...vmRecord,
-      affinity: undefined,
-      blocked_operations: {
-        ...vmRecord.blocked_operations,
+  // 1. Create the VM or update the existing one.
+  let vmRef
+  if (isUpdate) {
+    vmRef = targetRef
+    await Promise.all([
+      xapi.setFields('VM', vmRef, {
+        actions_after_crash: vmRecord.actions_after_crash,
+        actions_after_reboot: vmRecord.actions_after_reboot,
+        actions_after_shutdown: vmRecord.actions_after_shutdown,
+        domain_type: vmRecord.domain_type,
+        ha_restart_priority: vmRecord.ha_restart_priority,
+        has_vendor_device: vmRecord.has_vendor_device,
+        HVM_boot_params: vmRecord.HVM_boot_params,
+        HVM_boot_policy: vmRecord.HVM_boot_policy,
+        HVM_shadow_multiplier: vmRecord.HVM_shadow_multiplier,
+        memory_dynamic_max: vmRecord.memory_dynamic_max,
+        memory_dynamic_min: vmRecord.memory_dynamic_min,
+        memory_static_max: vmRecord.memory_static_max,
+        memory_static_min: vmRecord.memory_static_min,
+        name_label: vmRecord.name_label,
+        name_description: vmRecord.name_description,
+        order: vmRecord.order,
+        other_config: vmRecord.other_config,
+        platform: vmRecord.platform,
+        PV_args: vmRecord.PV_args,
+        PV_bootloader: vmRecord.PV_bootloader,
+        PV_bootloader_args: vmRecord.PV_bootloader_args,
+        PV_kernel: vmRecord.PV_kernel,
+        PV_legacy_args: vmRecord.PV_legacy_args,
+        PV_ramdisk: vmRecord.PV_ramdisk,
+        recommendations: vmRecord.recommendations,
+        shutdown_delay: vmRecord.shutdown_delay,
+        start_delay: vmRecord.start_delay,
+        suspend_SR: vmRecord.suspend_SR,
+        tags: vmRecord.tags,
+        user_version: vmRecord.user_version,
+        VCPUs_at_startup: vmRecord.VCPUs_at_startup,
+        VCPUs_max: vmRecord.VCPUs_max,
+        VCPUs_params: vmRecord.VCPUs_params,
+        xenstore_data: vmRecord.xenstore_data,
+      }),
+      targetVm.update_blocked_operations({
         start: 'Importing…',
         start_on: 'Importing…',
+      }),
+    ])
+  } else {
+    vmRef = await xapi.VM_create(
+      {
+        ...vmRecord,
+        affinity: undefined,
+        blocked_operations: {
+          ...vmRecord.blocked_operations,
+          start: 'Importing…',
+          start_on: 'Importing…',
+        },
+        ha_always_run: false,
+        is_a_template: false,
+        name_label: '[Importing…] ' + vmRecord.name_label,
       },
-      ha_always_run: false,
-      is_a_template: false,
-      name_label: '[Importing…] ' + vmRecord.name_label,
-    },
-    {
-      bios_strings: vmRecord.bios_strings,
-      generateMacSeed: newMacAddresses,
-      suspend_VDI: suspendVdi?.$ref,
-    }
-  )
-  $defer.onFailure.call(xapi, 'VM_destroy', vmRef)
+      {
+        bios_strings: vmRecord.bios_strings,
+        generateMacSeed: newMacAddresses,
+        suspend_VDI: suspendVdi?.$ref,
+      }
+    )
+    $defer.onFailure.call(xapi, 'VM_destroy', vmRef)
+  }
 
   // 2. Delete all VBDs which may have been created by the import.
-  await asyncMap(await xapi.getField('VM', vmRef, 'VBDs'), ref => ignoreErrors.call(xapi.call('VBD.destroy', ref)))
+  // In update mode, also collect the VDI refs so orphaned VDIs can be destroyed after new ones are created.
+  const existingVbdRefs = await xapi.getField('VM', vmRef, 'VBDs')
+  const oldVdiRefs = new Set(
+    isUpdate
+      ? (await asyncMap(existingVbdRefs, ref => xapi.getField('VBD', ref, 'VDI'))).filter(
+          ref => ref !== undefined && ref !== 'OpaqueRef:NULL'
+        )
+      : []
+  )
+  await asyncMap(existingVbdRefs, ref => ignoreErrors.call(xapi.call('VBD.destroy', ref)))
 
   // 3. Create VDIs & VBDs.
   const vbdRecords = incrementalVm.vbds
@@ -184,10 +246,18 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
     let newVdi
 
     if (vdi.baseVdi?.$ref !== undefined) {
-      newVdi = await xapi.getRecord('VDI', await xapi.VDI_clone(vdi.baseVdi.$ref))
-      $defer.onFailure(() => newVdi.$destroy())
-
+      if (isUpdate) {
+        // In update mode, reuse the existing target VDI directly — no clone needed.
+        newVdi = vdi.baseVdi
+        oldVdiRefs.delete(newVdi.$ref)
+      } else {
+        newVdi = await xapi.getRecord('VDI', await xapi.VDI_clone(vdi.baseVdi.$ref))
+        $defer.onFailure(() => newVdi.$destroy())
+      }
       await newVdi.update_other_config(COPY_OF, vdi.uuid)
+      if (vdi.other_config[CONTENT_KEY] !== undefined) {
+        await newVdi.update_other_config(CONTENT_KEY, vdi.other_config[CONTENT_KEY])
+      }
       if (vdi.virtual_size > newVdi.virtual_size) {
         await newVdi.$callAsync('resize', vdi.virtual_size)
       }
@@ -213,6 +283,16 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
     newVdis[vdiRef] = newVdi
   })
 
+  // 3.5. Destroy old VDIs that are no longer attached to the VM.
+  // Uses ignoreErrors because some storage backends refuse to destroy a VDI that still has snapshot children;
+  // those VDIs will become truly orphaned once the old snapshot VMs are cleaned up by _deleteOldEntries.
+  await asyncMap([...oldVdiRefs], ref => ignoreErrors.call(xapi.call('VDI.destroy', ref)))
+
+  // 4. For updates, destroy existing VIFs before recreating them.
+  if (isUpdate) {
+    await asyncMap(await xapi.getField('VM', vmRef, 'VIFs'), ref => ignoreErrors.call(xapi.call('VIF.destroy', ref)))
+  }
+
   const networksByNameLabelByVlan = {}
   let defaultNetwork
   Object.values(xapi.objects.all).forEach(object => {

package/_otherConfig.mjs

@@ -28,6 +28,11 @@ export const EXPORTED_SUCCESSFULLY = 'xo:backup:exported'
 // the VM ( not the snapshot) uuid
 export const VM_UUID = 'xo:backup:vm'
 
+// in `other_config` of source snapshot VDIs and replicated target VDIs
+// contains the UUID of the source snapshot VDI whose content this VDI represents
+// allows direction-agnostic discovery of common base VDIs (e.g. for failback/reverse replication)
+export const CONTENT_KEY = 'xo:backup:contentKey'
+
 async function listVdiRefs(xapi, vmRef) {
   return xapi.VM_getDisks(vmRef)
 }
@@ -131,3 +136,24 @@ export async function markExportSuccessfull(xapi, vmRef) {
     xapi.setFieldEntry(type, ref, 'other_config', EXPORTED_SUCCESSFULLY, 'true')
   )
 }
+
+/**
+ * Set CONTENT_KEY on each VDI of a VM snapshot to its own UUID.
+ *
+ * This marks each snapshot VDI with a unique content identifier that can be
+ * propagated to replicated copies for direction-agnostic base VDI discovery
+ * (e.g. for failback / reverse replication).
+ *
+ * @param {Xapi} xapi
+ * @param {String} snapshotRef
+ * @returns {Promise}
+ */
+export async function setVmSnapshotContentKeys(xapi, snapshotRef) {
+  return applyToVmAndVdis(xapi, snapshotRef, async (type, ref) => {
+    if (type !== 'VDI') {
+      return
+    }
+    const uuid = await xapi.getField(type, ref, 'uuid')
+    return xapi.setFieldEntry(type, ref, 'other_config', CONTENT_KEY, uuid)
+  })
+}

package/_runners/_vmRunners/IncrementalXapi.mjs

@@ -135,16 +135,6 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
     const deltaChainLength = Math.max(
       ...lastExportedVdis.map(({ other_config }) => Number(other_config[DELTA_CHAIN_LENGTH] ?? 0))
     )
-    const fullInterval = this._settings.fullInterval
-    if (fullInterval !== 0 && fullInterval <= deltaChainLength + 1) {
-      debug('not using base VM because fullInterval reached', {
-        fullInterval,
-        deltaChainLength,
-        eq: fullInterval < deltaChainLength + 1,
-        dc1: deltaChainLength + 1,
-      })
-      return
-    }
 
     const srcVdis = keyBy(await xapi.getRecords('VDI', await this._vm.$getDisks()), '$ref')
 
@@ -173,6 +163,20 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
       debug('no base VM found')
       return
     }
+
+    // we do tafter checkbasevdis because we want the writer to know the target VM
+    // especially on replication when we alwayr update the same VM
+    const fullInterval = this._settings.fullInterval
+    if (fullInterval !== 0 && fullInterval <= deltaChainLength + 1) {
+      debug('not using base VM because fullInterval reached', {
+        fullInterval,
+        deltaChainLength,
+        eq: fullInterval < deltaChainLength + 1,
+        dc1: deltaChainLength + 1,
+      })
+      return
+    }
+
     baseUuidToSrcVdiUuid.forEach((srcVdiUuid, baseUuid) => {
       if (presentBaseVdis.has(baseUuid)) {
         debug('found base VDI', {

package/_runners/_vmRunners/_AbstractXapi.mjs

@@ -10,7 +10,16 @@ import { defer } from 'golike-defer'
 import { getOldEntries } from '../../_getOldEntries.mjs'
 import { Task } from '../../Task.mjs'
 import { Abstract } from './_Abstract.mjs'
-import { DATETIME, JOB_ID, SCHEDULE_ID, VM_UUID, resetVmOtherConfig, setVmOtherConfig } from '../../_otherConfig.mjs'
+import {
+  COPY_OF,
+  DATETIME,
+  JOB_ID,
+  SCHEDULE_ID,
+  VM_UUID,
+  resetVmOtherConfig,
+  setVmOtherConfig,
+  setVmSnapshotContentKeys,
+} from '../../_otherConfig.mjs'
 
 const { warn, info } = createLogger('xo:backups:AbstractXapi')
 
@@ -205,6 +214,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
           scheduleId: this.scheduleId,
           vmUuid: vm.uuid,
         })
+        await setVmSnapshotContentKeys(xapi, snapshotRef)
         const snapshot = await xapi.getRecord('VM', snapshotRef)
         await snapshot.set_name_label(this._getSnapshotNameLabel(vm))
         // reload data to ensure it is up to date with the new name label
@@ -233,11 +243,16 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
     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 $snapshot_of !== undefined && other_config[JOB_ID] === jobId && other_config[VM_UUID] === this._vm.uuid
+      .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
@@ -310,6 +325,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
       // if not => remove it from the list to ensure we won't half destroy VM later
       vm.$VBDs
         .filter(({ $VDI }) => !!$VDI) // filter missing keys
+        .filter(({ $VDI }) => $VDI.$snapshot_of !== undefined) // skip non-snapshot VDIs (e.g., ISOs/CD-ROMs)
         .filter(({ $VDI }) => $VDI && vdiCandidates[$VDI.uuid] === undefined)
         .forEach(({ $VDI: outOfSnapshotsVdi, ...other }) => {
           warn(

package/_runners/_writers/IncrementalXapiWriter.mjs

@@ -7,7 +7,7 @@ import { Task } from '../../Task.mjs'
 
 import { AbstractIncrementalWriter } from './_AbstractIncrementalWriter.mjs'
 import { MixinXapiWriter } from './_MixinXapiWriter.mjs'
-import { listReplicatedVms } from './_listReplicatedVms.mjs'
+import { compareReplicatedVmDatetime, listReplicatedVms } from './_listReplicatedVms.mjs'
 import {
   COPY_OF,
   setVmOtherConfig,
@@ -30,25 +30,38 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       return
     }
 
-    // @todo use an index if possible
-    // @todo : this seems similar to decorateVmMetadata
-    const replicatedVdis = sr.$VDIs
-      .filter(vdi => {
-        // REPLICATED_TO_SR_UUID is not used here since we are already filtering from sr.$VDIs
-        return (
-          vdi?.managed &&
-          !vdi?.is_a_snapshot /* only look for real vdi */ &&
-          baseUuidToSrcVdi.has(vdi?.other_config[COPY_OF])
-        )
-      })
-      .map(({ other_config }) => other_config?.[COPY_OF])
-      .filter(_ => !!_)
+    // Only match live (non-snapshot) VDIs attached to exactly one
+    // non-control-domain VM that is a valid replication target for this job.
+    // This must stay consistent with the filter in #decorateVmMetadata.
+    const replicatedVdis = sr.$VDIs.filter(vdi => {
+      if (!vdi?.managed || vdi?.is_a_snapshot || !baseUuidToSrcVdi.has(vdi?.other_config[COPY_OF])) {
+        return false
+      }
+      const userVbds = vdi.$VBDs?.filter(vbd => vbd.$VM && !vbd.$VM.is_control_domain) ?? []
+      if (userVbds.length !== 1) {
+        return false
+      }
+      const vm = userVbds[0].$VM
+      return (
+        vm.other_config[JOB_ID] === this._job.id &&
+        vm.other_config[VM_UUID] === this._vmUuid &&
+        'start' in vm.blocked_operations
+      )
+    })
+
+    const replicatedCopyOfUuids = replicatedVdis.map(({ other_config }) => other_config?.[COPY_OF]).filter(_ => !!_)
 
     for (const uuid of baseUuidToSrcVdi.keys()) {
-      if (!replicatedVdis.includes(uuid)) {
+      if (!replicatedCopyOfUuids.includes(uuid)) {
         baseUuidToSrcVdi.delete(uuid)
       }
     }
+
+    // Track the target VM (the replicated VM to update on the next transfer).
+    if (replicatedVdis.length > 0) {
+      const vbd = replicatedVdis[0].$VBDs.find(vbd => vbd.$VM && !vbd.$VM.is_control_domain)
+      this._targetVmRef = vbd.$VM.$ref
+    }
   }
   updateUuidAndChain() {
     // nothing to do, the chaining is not modified in this case
@@ -81,7 +94,16 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     // delete previous interrupted copies
     ignoreErrors.call(asyncMapSettled(listReplicatedVms(xapi, scheduleId, undefined, vmUuid), vm => vm.$destroy))
 
-    this._oldEntries = getOldEntries(settings.copyRetention - 1, listReplicatedVms(xapi, scheduleId, srUuid, vmUuid))
+    const allEntries = listReplicatedVms(xapi, scheduleId, srUuid, vmUuid)
+
+    // In the snapshot-based flow a non-snapshot VM (the live target) coexists with its
+    // snapshots (one per transfer). That VM must not be subject to retention — only its
+    // snapshots are. Build the set of VM refs that already have snapshots in the list so
+    // we can exclude them, while keeping old-style non-snapshot VMs (no snapshots).
+    const vmRefsWithSnapshots = new Set(allEntries.filter(e => e.is_a_snapshot).map(e => e.snapshot_of))
+    const retentionEntries = allEntries.filter(e => e.is_a_snapshot || !vmRefsWithSnapshots.has(e.$ref))
+    retentionEntries.sort(compareReplicatedVmDatetime)
+    this._oldEntries = getOldEntries(settings.copyRetention - 1, retentionEntries)
 
     if (settings.deleteFirst && settings.skipDeleteOldEntries) {
       // we want to keep the baseVM when copying a delta
@@ -112,7 +134,7 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     const job = this._job
     const scheduleId = this._scheduleId
 
-    vm.name_label = `${vm.name_label} - ${job.name} - (${formatFilenameDate(timestamp)})`
+    vm.name_label = `${vm.name_label} - ${job.name}`
     // update other_config data as soon as possible to ensure the next job
     // will be able to detect any partial transfer and lean them
     vm.other_config[COPY_OF] = vm.uuid
@@ -180,7 +202,24 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
 
     let targetVmRef
     await Task.run({ name: 'transfer' }, async () => {
-      targetVmRef = await importIncrementalVm(this.#decorateVmMetadata(deltaExport, timestamp), sr)
+      targetVmRef = await importIncrementalVm(this.#decorateVmMetadata(deltaExport, timestamp), sr, {
+        targetRef: this._targetVmRef,
+      })
+      // this also ensure the data are up to date on the snapshot
+      await setVmOtherConfig(xapi, targetVmRef, {
+        timestamp, // updated at the end to mark the transfer as complete
+        jobId: job.id,
+        scheduleId,
+        vmUuid: vm.uuid,
+        srUuid,
+      })
+
+      // take a snapshot to ensure these data are not modified until next snapshot
+      await Task.run({ name: 'target snapshot' }, () =>
+        xapi.VM_snapshot(targetVmRef, {
+          name_label: `${vm.name_label} - ${job.name} - (${formatFilenameDate(timestamp)})`,
+        })
+      )
       // size is mandatory to ensure the task have the right data
       return {
         size: Object.values(deltaExport.disks).reduce(
@@ -197,13 +236,6 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       !_warmMigration &&
         targetVm.ha_restart_priority !== '' &&
         Promise.all([targetVm.set_ha_restart_priority(''), targetVm.add_tags('HA disabled')]),
-      setVmOtherConfig(xapi, targetVmRef, {
-        timestamp, // updated at the end to mark the transfer as complete
-        jobId: job.id,
-        scheduleId,
-        vmUuid: vm.uuid,
-        srUuid,
-      }),
     ])
   }
 }

package/_runners/_writers/_listReplicatedVms.mjs

@@ -23,12 +23,13 @@ export function listReplicatedVms(xapi, scheduleOrJobId, srUuid, vmUuid) {
     const oc = object.other_config
     if (
       object.$type === 'VM' &&
-      !object.is_a_snapshot &&
       !object.is_a_template &&
-      'start' in object.blocked_operations &&
       (oc[JOB_ID] === scheduleOrJobId || oc[SCHEDULE_ID] === scheduleOrJobId) &&
       oc[REPLICATED_TO_SR_UUID] === srUuid &&
-      oc[VM_UUID] === vmUuid
+      oc[VM_UUID] === vmUuid &&
+      // Old-style replication: one VM per transfer (non-snapshot, start blocked)
+      // New-style replication: snapshots of the target VM represent each transfer
+      (!object.is_a_snapshot ? 'start' in object.blocked_operations : true)
     ) {
       vms[object.$id] = object
     }

package/disks/MergeRemoteDisk.mjs

@@ -22,6 +22,7 @@ const { warn } = createLogger('remote-disk:merge')
  * @property {number} mergedDataSize
  * @property {'mergeBlocks' | 'cleanup'} step
  * @property {number} diskSize
+ * @typedef {(message: string, data?: Record<string, unknown>) => void} Logger
  */
 
 export class MergeRemoteDisk {
@@ -85,11 +86,11 @@ export class MergeRemoteDisk {
   /**
    * @param {FileAccessor} handler
    * @param {Object} params
-   * @param {Function} params.onProgress
-   * @param {Logger | Function} params.logInfo
-   * @param {boolean} params.removeUnused
-   * @param {number} params.mergeBlockConcurrency
-   * @param {number} params.writeStateDelay
+   * @param {Function} [params.onProgress]
+   * @param {Logger | Function} [params.logInfo]
+   * @param {boolean} [params.removeUnused]
+   * @param {number} [params.mergeBlockConcurrency]
+   * @param {number} [params.writeStateDelay]
    */
   constructor(
     handler,
@@ -202,8 +203,8 @@ export class MergeRemoteDisk {
 
       parentDisk.setAllocatedBlocks(alreadyMergedBlocks)
     } else {
-      this.#state.child = { uuid: childDisk.getUuid() ?? 0 }
-      this.#state.parent = { uuid: parentDisk.getUuid() ?? 0 }
+      this.#state.child = { uuid: childDisk.getUuid() ?? undefined }
+      this.#state.parent = { uuid: parentDisk.getUuid() ?? undefined }
 
       // Finds first allocated block for the 2 following loops
       while (this.#state.currentBlock < getMaxBlockCount && !childDisk.hasBlock(this.#state.currentBlock)) {

package/disks/index.mjs

@@ -0,0 +1,49 @@
+import { RemoteVhdDisk } from './RemoteVhdDisk.mjs'
+
+export { RemoteDisk } from './RemoteDisk.mjs'
+export { openDiskChain } from './openDiskChain.mjs'
+
+/**
+ * @typedef {import('../../disk-transform/src/FileAccessor.mjs').FileAccessor} FileAccessor
+ * @typedef {import('./RemoteDisk.mjs').RemoteDisk} RemoteDisk
+ */
+
+/**
+ * @param {Object} params
+ * @param {FileAccessor} params.handler
+ * @param {string} params.path
+ * @returns {Promise<RemoteDisk>}
+ */
+export async function openDisk({ handler, path }) {
+  const disk = new RemoteVhdDisk({ handler, path })
+  await disk.init()
+  return disk
+}
+/**
+ *
+ * @param {Object} params
+ * @param {FileAccessor} params.handler
+ * @param {string} params.path
+ * @returns {Promise<Disposable<RemoteDisk>>}
+ */
+export async function openDisposableDisk({ handler, path }) {
+  const disk = new RemoteVhdDisk({ handler, path })
+  await disk.init()
+  return {
+    value: disk,
+    dispose: () => disk.close(),
+  }
+}
+
+const DISK_EXTENSIONS = ['.vhd']
+
+/**
+ * Returns true if the path points to a supported disk format.
+ *
+ * @param {FileAccessor} _handler - Remote file handler (reserved for future use)
+ * @param {string} path - Path to check
+ * @returns {boolean}
+ */
+export function isDisk(_handler, path) {
+  return DISK_EXTENSIONS.some(ext => path.endsWith(ext))
+}

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.69.3",
+  "version": "0.70.0",
   "engines": {
     "node": ">=14.18"
   },
@@ -19,20 +19,20 @@
   "dependencies": {
     "@iarna/toml": "^2.2.5",
     "@kldzj/stream-throttle": "^1.1.1",
-    "@vates/async-each": "^1.0.1",
+    "@vates/async-each": "^1.0.2",
     "@vates/cached-dns.lookup": "^1.0.0",
     "@vates/compose": "^2.1.0",
     "@vates/decorate-with": "^2.1.0",
     "@vates/disposable": "^0.1.6",
     "@vates/fuse-vhd": "^2.1.2",
-    "@vates/generator-toolbox": "^1.1.0",
-    "@vates/nbd-client": "^3.2.3",
+    "@vates/generator-toolbox": "^1.1.1",
+    "@vates/nbd-client": "^3.3.0",
     "@vates/parse-duration": "^0.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/disk-transform": "^1.2.1",
-    "@xen-orchestra/fs": "^4.6.7",
+    "@xen-orchestra/disk-transform": "^1.2.2",
+    "@xen-orchestra/fs": "^4.7.0",
     "@xen-orchestra/log": "^0.7.1",
-    "@xen-orchestra/qcow2": "^1.1.2",
+    "@xen-orchestra/qcow2": "^1.2.0",
     "@xen-orchestra/template": "^0.1.0",
     "app-conf": "^3.0.0",
     "compare-versions": "^6.0.0",
@@ -51,7 +51,7 @@
     "tar": "^7.5.3",
     "uuid": "^9.0.0",
     "value-matcher": "^0.2.0",
-    "vhd-lib": "^4.14.7",
+    "vhd-lib": "^4.15.0",
     "xen-api": "^4.7.6",
     "yazl": "^2.5.1"
   },
@@ -68,5 +68,9 @@
   "author": {
     "name": "Vates SAS",
     "url": "https://vates.fr"
+  },
+  "exports": {
+    "./disks": "./disks/index.mjs",
+    "./*": "./*"
   }
 }