@xen-orchestra/backups 0.54.0 → 0.54.2

package/ImportVmBackup.mjs

@@ -79,8 +79,13 @@ export class ImportVmBackup {
         debug('found disks, wlll search its snapshots', { snapshots: xapiDisk.snapshots })
         for (const snapshotRef of xapiDisk.snapshots) {
           const snapshot = await this._xapi.getRecord('VDI', snapshotRef)
-          debug('handling snapshot', { snapshot })
 
+          debug('handling snapshot', { snapshot })
+          if (snapshot.type === 'cbt_metadata') {
+            // disk without data can't be used as a base
+            debug('cbt metadata snapshot, skip')
+            continue
+          }
           // take only the first snapshot
           if (snapshotCandidate && snapshotCandidate.snapshot_time < snapshot.snapshot_time) {
             debug('already got a better candidate')

package/RemoteAdapter.mjs

@@ -107,10 +107,13 @@ export class RemoteAdapter {
   async *_getLvmLogicalVolumes(devicePath, pvId, vgName) {
     yield this._getLvmPhysicalVolume(devicePath, pvId && (await this._findPartition(devicePath, pvId)))
 
+    debug('activate LVM volume group', { vgName })
     await fromCallback(execFile, 'vgchange', ['-ay', vgName])
     try {
+      debug('get LVM volume group name and path', { vgName })
       yield lvs(['lv_name', 'lv_path'], vgName)
     } finally {
+      debug('deactivate LVM volume group', { vgName })
       await fromCallback(execFile, 'vgchange', ['-an', vgName])
     }
   }
@@ -121,15 +124,22 @@ export class RemoteAdapter {
       args.push('-o', partition.start * 512, '--sizelimit', partition.size)
     }
     args.push('--show', '-f', devicePath)
+
+    debug('attach loop device', { devicePath, partition })
     const path = (await fromCallback(execFile, 'losetup', args)).trim()
     try {
+      debug('list LVM physical volume', { path })
       await fromCallback(execFile, 'pvscan', ['--cache', path])
+
       yield path
     } finally {
       try {
         const vgNames = await pvs('vg_name', path)
+
+        debug('deactivate LVM volume groups', { vgNames })
         await fromCallback(execFile, 'vgchange', ['-an', ...vgNames])
       } finally {
+        debug('detach loop device', { path })
         await fromCallback(execFile, 'losetup', ['-d', path])
       }
     }
@@ -150,6 +160,7 @@ export class RemoteAdapter {
 
     const path = yield getTmpDir()
     const mount = options => {
+      debug('mount device', { devicePath, mountPath: path })
       return fromCallback(execFile, 'mount', [
         `--options=${options.join(',')}`,
         `--source=${devicePath}`,
@@ -167,6 +178,7 @@ export class RemoteAdapter {
     try {
       yield path
     } finally {
+      debug('umount device', { devicePath, mountPath: path })
       await fromCallback(execFile, 'umount', ['--lazy', path])
     }
   }
@@ -336,6 +348,8 @@ export class RemoteAdapter {
 
     const diskPath = handler.getFilePath('/' + diskId)
     const mountDir = yield getTmpDir()
+
+    debug('mount VHD (vhdimount)', { diskPath, mountPath: mountDir })
     await fromCallback(execFile, 'vhdimount', [diskPath, mountDir])
     try {
       let max = 0
@@ -357,6 +371,7 @@ export class RemoteAdapter {
 
       yield `${mountDir}/${maxEntry}`
     } finally {
+      debug('umount VHD (fusermount)', { diskPath, mountPath: mountDir })
       await fromCallback(execFile, 'fusermount', ['-uz', mountDir])
     }
   }

package/_cleanVm.mjs

@@ -121,7 +121,19 @@ export async function checkAliases(
 ) {
   const aliasFound = []
   for (const alias of aliasPaths) {
-    const target = await resolveVhdAlias(handler, alias)
+    let target
+    try {
+      target = await resolveVhdAlias(handler, alias)
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        logWarn('missing target of alias', { alias })
+        if (remove) {
+          logInfo('removing alias and non VHD target', { alias, target })
+          await handler.unlink(target)
+          await handler.unlink(alias)
+        }
+      }
+    }
 
     if (!isVhdFile(target)) {
       logWarn('alias references non VHD target', { alias, target })
@@ -201,9 +213,9 @@ export async function cleanVm(
 
   // remove broken VHDs
   await asyncMap(vhds, async path => {
-    if(removeTmp && basename(path)[0] === '.'){
+    if (removeTmp && basename(path)[0] === '.') {
       logInfo('deleting temporary VHD', { path })
-        return VhdAbstract.unlink(handler, path)
+      return VhdAbstract.unlink(handler, path)
     }
     try {
       await Disposable.use(openVhd(handler, path, { checkSecondFooter: !interruptedVhds.has(path) }), vhd => {

package/_getTmpDir.mjs

@@ -1,16 +1,23 @@
 import Disposable from 'promise-toolbox/Disposable'
+import { createLogger } from '@xen-orchestra/log'
 import { join } from 'node:path'
 import { mkdir, rmdir } from 'node:fs/promises'
 import { tmpdir } from 'os'
 
+const { debug } = createLogger('xo:backups:getTmpDir')
+
 const MAX_ATTEMPTS = 3
 
 export async function getTmpDir() {
   for (let i = 0; true; ++i) {
     const path = join(tmpdir(), Math.random().toString(36).slice(2))
     try {
+      debug('creating directory', { path })
       await mkdir(path)
-      return new Disposable(() => rmdir(path), path)
+      return new Disposable(() => {
+        debug('removing directory', { path })
+        return rmdir(path)
+      }, path)
     } catch (error) {
       if (i === MAX_ATTEMPTS) {
         throw error

package/_incrementalVm.mjs

@@ -52,14 +52,32 @@ export async function exportIncrementalVm(
       $snapshot_of$uuid: vdi.$snapshot_of?.uuid,
       $SR$uuid: vdi.$SR.uuid,
     }
-
-    streams[`${vdiRef}.vhd`] = await vdi.$exportContent({
-      baseRef: baseVdi?.$ref,
-      cancelToken,
-      format: 'vhd',
-      nbdConcurrency,
-      preferNbd,
-    })
+    try {
+      streams[`${vdiRef}.vhd`] = await vdi.$exportContent({
+        baseRef: baseVdi?.$ref,
+        cancelToken,
+        format: 'vhd',
+        nbdConcurrency,
+        preferNbd,
+      })
+    } catch (err) {
+      if (err.code === 'VDI_CANT_DO_DELTA') {
+        // fall back to a base
+        Task.info(`Can't do delta, will try to get a full stream`, { vdi })
+        streams[`${vdiRef}.vhd`] = await vdi.$exportContent({
+          cancelToken,
+          format: 'vhd',
+          nbdConcurrency,
+          preferNbd,
+        })
+        // only warn if the fall back succeed
+        Task.warning(`Can't do delta with this vdi, transfer will be a full`, {
+          vdi,
+        })
+      } else {
+        throw err
+      }
+    }
   })
 
   const suspendVdi = vm.$suspend_VDI

package/_runners/_vmRunners/IncrementalRemote.mjs

@@ -1,3 +1,5 @@
+import { createLogger } from '@xen-orchestra/log'
+
 import { asyncEach } from '@vates/async-each'
 import assert from 'node:assert'
 import * as UUID from 'uuid'
@@ -11,6 +13,7 @@ import { Disposable } from 'promise-toolbox'
 import { openVhd } from 'vhd-lib'
 import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
 
+const { warn } = createLogger('xo:backups:Incrementalremote')
 class IncrementalRemoteVmBackupRunner extends AbstractRemote {
   _getRemoteWriter() {
     return IncrementalRemoteWriter
@@ -46,11 +49,7 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
     })
 
     const presentBaseVdis = new Map(baseUuidToSrcVdi)
-    await this._callWriters(
-      writer => presentBaseVdis.size !== 0 && writer.checkBaseVdis(presentBaseVdis),
-      'writer.checkBaseVdis()',
-      false
-    )
+    await this._callWriters(writer => writer.checkBaseVdis(presentBaseVdis), 'writer.checkBaseVdis()', false)
     // check if the parent vdi are present in all the remotes
     baseUuidToSrcVdi.forEach((srcVdiUuid, baseUuid) => {
       if (!presentBaseVdis.has(baseUuid)) {
@@ -64,17 +63,29 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
 
     for (const metadata of transferList) {
       assert.strictEqual(metadata.mode, 'delta')
-      await this._selectBaseVm(metadata)
-      await this._callWriters(writer => writer.prepare({ isBase: metadata.isBase }), 'writer.prepare()')
       const incrementalExport = await this._sourceRemoteAdapter.readIncrementalVmBackup(metadata, undefined, {
         useChain: false,
       })
-
+      // don't trust metadata too much
+      // recompute if it's a base backup
+      // recompute if disks are differencing or not
       const isVhdDifferencing = {}
 
       await asyncEach(Object.entries(incrementalExport.streams), async ([key, stream]) => {
         isVhdDifferencing[key] = await isVhdDifferencingDisk(stream)
       })
+      const hasDifferencingDisk = Object.values(isVhdDifferencing).includes(true)
+      if (metadata.isBase === hasDifferencingDisk) {
+        warn(`Metadata isBase and real disk value are different`, {
+          metadataIsBase: metadata.isBase,
+          diskIsBase: !hasDifferencingDisk,
+          isVhdDifferencing,
+        })
+      }
+      metadata.isBase = !hasDifferencingDisk
+      metadata.isVhdDifferencing = isVhdDifferencing
+      await this._selectBaseVm(metadata)
+      await this._callWriters(writer => writer.prepare({ isBase: metadata.isBase }), 'writer.prepare()')
 
       incrementalExport.streams = mapValues(incrementalExport.streams, this._throttleStream)
       await this._callWriters(

package/_runners/_vmRunners/_AbstractXapi.mjs

@@ -203,7 +203,13 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
     for (const srcVdi of srcVdis) {
       const snapshots = await xapi.getRecords('VDI', srcVdi.snapshots)
       for (const snapshot of snapshots) {
-        if (snapshot.other_config[JOB_ID] === jobId) {
+        // only keep the snapshot related to this backup job
+        // and only if the job is still using  purge snapshot data or if the disk
+        // is not a cbt metadata disk ( expect a type: user for normal disks)
+        if (
+          snapshot.other_config[JOB_ID] === jobId &&
+          (this._settings.cbtDestroySnapshotData || snapshot.type !== 'cbt_metadata')
+        ) {
           this._jobSnapshotVdis.push(snapshot)
         }
       }
@@ -219,6 +225,14 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
     await xapi.barrier()
     // ensure cached object are up to date
     this._jobSnapshotVdis = this._jobSnapshotVdis.map(vdi => xapi.getObject(vdi.$ref))
+
+    // get the datetime of the most recent snapshot
+    const lastSnapshotDateTime = this._jobSnapshotVdis
+      .map(({ other_config }) => other_config[DATETIME])
+      .sort()
+      .pop()
+
+    // remove older snapshot schedule per schedule
     const snapshotsPerSchedule = groupBy(this._jobSnapshotVdis, _ => _.other_config[SCHEDULE_ID])
     await asyncMap(Object.entries(snapshotsPerSchedule), async ([scheduleId, snapshots]) => {
       const snapshotPerDatetime = groupBy(snapshots, _ => _.other_config[DATETIME])
@@ -231,10 +245,13 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
         ...allSettings[scheduleId],
         ...allSettings[this._vm.uuid],
       }
-      // ensure we never delete the last one for delta
-      const minRetention = this.job.mode === 'delta' ? 1 : 0
-      const retention = Math.max(settings.snapshotRetention ?? 0, minRetention)
+      const retention = settings.snapshotRetention ?? 0
       await asyncMap(getOldEntries(retention, datetimes), async datetime => {
+        // keep the last snapshot across all schedules for delta
+        // since we'll need it to compute delta for next backup
+        if (this.job.mode === 'delta' && datetime === lastSnapshotDateTime) {
+          return
+        }
         const vdis = snapshotPerDatetime[datetime]
         let vmRef
         // if there is an attached VM => destroy the VM (Non CBT backups)

package/_runners/_writers/IncrementalRemoteWriter.mjs

@@ -66,7 +66,7 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
 
   async beforeBackup() {
     await super.beforeBackup()
-    return this._cleanVm({ merge: true })
+    return this._cleanVm({ merge: true, remove: true })
   }
 
   prepare({ isFull }) {
@@ -149,6 +149,9 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
         assert.notStrictEqual(parentPath, undefined, 'A differential VHD must have a parent')
         // forbid any kind of loop
         assert.ok(basename(parentPath) < basename(path), `vhd must be sorted to be chained`)
+        // re-chainVhd is mandatory
+        // since the parent may be a alias or not
+        // and the child may be the other
         await chainVhd(handler, parentPath, handler, path)
       }
 

package/_runners/_writers/IncrementalXapiWriter.mjs

@@ -15,11 +15,15 @@ import assert from 'node:assert'
 export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
   async checkBaseVdis(baseUuidToSrcVdi) {
     const sr = this._sr
+    if (baseUuidToSrcVdi.size === 0) {
+      // searching for the vdis is expensive
+      // don't do it if there is nothing to find
+      return
+    }
 
     // @todo use an index if possible
     // @todo : this seems similare to decorateVmMetadata
-
-    const replicatedVdis = sr.$VDIs 
+    const replicatedVdis = sr.$VDIs
       .filter(vdi => {
         // REPLICATED_TO_SR_UUID is not used here since we are already filtering from sr.$VDIs
         return baseUuidToSrcVdi.has(vdi?.other_config[COPY_OF])
@@ -103,11 +107,10 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       .filter(_ => !!_)
     // @todo use index ?
 
-    const replicatedVdis = sr.$VDIs
-      .filter(vdi => {
-        // REPLICATED_TO_SR_UUID is not used here since we are already filtering from sr.$VDIs
-        return sourceVdiUuids.includes(vdi?.other_config[COPY_OF])
-      })
+    const replicatedVdis = sr.$VDIs.filter(vdi => {
+      // REPLICATED_TO_SR_UUID is not used here since we are already filtering from sr.$VDIs
+      return sourceVdiUuids.includes(vdi?.other_config[COPY_OF])
+    })
 
     Object.values(backup.vdis).forEach(vdi => {
       vdi.other_config[COPY_OF] = vdi.uuid

package/package.json

@@ -8,13 +8,13 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.54.0",
+  "version": "0.54.2",
   "engines": {
     "node": ">=14.18"
   },
   "scripts": {
     "postversion": "npm publish --access public",
-    "test-integration": "node--test *.integ.mjs"
+    "test-integration": "node --test *.integ.mjs"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
@@ -23,13 +23,13 @@
     "@vates/cached-dns.lookup": "^1.0.0",
     "@vates/compose": "^2.1.0",
     "@vates/decorate-with": "^2.1.0",
-    "@vates/disposable": "^0.1.5",
-    "@vates/fuse-vhd": "^2.1.1",
-    "@vates/nbd-client": "^3.1.0",
+    "@vates/disposable": "^0.1.6",
+    "@vates/fuse-vhd": "^2.1.2",
+    "@vates/nbd-client": "^3.1.1",
     "@vates/parse-duration": "^0.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/fs": "^4.1.7",
-    "@xen-orchestra/log": "^0.6.0",
+    "@xen-orchestra/fs": "^4.2.1",
+    "@xen-orchestra/log": "^0.7.0",
     "@xen-orchestra/template": "^0.1.0",
     "app-conf": "^3.0.0",
     "compare-versions": "^6.0.0",
@@ -47,19 +47,18 @@
     "tar": "^6.1.15",
     "uuid": "^9.0.0",
     "value-matcher": "^0.2.0",
-    "vhd-lib": "^4.11.0",
-    "xen-api": "^4.3.0",
+    "vhd-lib": "^4.11.1",
+    "xen-api": "^4.5.0",
     "yazl": "^2.5.1"
   },
   "devDependencies": {
     "fs-extra": "^11.1.0",
     "rimraf": "^5.0.1",
     "sinon": "^18.0.0",
-    "test": "^3.2.1",
     "tmp": "^0.2.1"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^7.5.0"
+    "@xen-orchestra/xapi": "^7.7.0"
   },
   "license": "AGPL-3.0-or-later",
   "author": {