@xen-orchestra/backups 0.68.0 → 0.68.1

package/RemoteAdapter.mjs

@@ -613,6 +613,11 @@ export class RemoteAdapter {
   // if cache is missing  or broken  => regenerate it and return
 
   async _readCacheListVmBackups(vmUuid) {
+    // immutable remote can't use any caching
+    // since the cache file may be non modifiable
+    if (this._handler.isImmutable()) {
+      return this.#getCacheableDataListVmBackups(`${BACKUP_DIR}/${vmUuid}`)
+    }
     const path = this.#getVmBackupsCache(vmUuid)
 
     const cache = await this._readCache(path)

package/_incrementalVm.mjs

@@ -291,10 +291,16 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
       await xapi.VTPM_create({ VM: vmRef, contents })
     })
   )
-
+  const vm = await xapi.getRecord('VM', vmRef)
   await Promise.all([
-    incrementalVm.vm.ha_always_run && xapi.setField('VM', vmRef, 'ha_always_run', true),
-    xapi.setField('VM', vmRef, 'name_label', incrementalVm.vm.name_label),
+    vmRecord.ha_always_run && xapi.setField('VM', vmRef, 'ha_always_run', true),
+    xapi.setField('VM', vmRef, 'name_label', vmRecord.name_label),
+    // correctly unlock the VM and reapply the target blocked operations
+    vm.update_blocked_operations({
+      start: null,
+      start_on: null,
+      ...vmRecord.blocked_operations,
+    }),
   ])
 
   return vmRef

package/_runners/_vmRunners/_AbstractXapi.mjs

@@ -3,6 +3,7 @@ import groupBy from 'lodash/groupBy.js'
 import { createLogger } from '@xen-orchestra/log'
 import ignoreErrors from 'promise-toolbox/ignoreErrors'
 import { asyncMap } from '@xen-orchestra/async-map'
+import { asyncEach } from '@vates/async-each'
 import { decorateMethodsWith } from '@vates/decorate-with'
 import { defer } from 'golike-defer'
 
@@ -13,6 +14,8 @@ import { DATETIME, JOB_ID, SCHEDULE_ID, VM_UUID, resetVmOtherConfig, setVmOtherC
 
 const { warn, info } = createLogger('xo:backups:AbstractXapi')
 
+const TEMP_SNAPSHOT_NAME = 'xo-backup-temp-snapshot-name'
+
 export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
   constructor({
     config,
@@ -156,7 +159,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
 
         const snapshotRef = await vm[settings.checkpointSnapshot ? '$checkpoint' : '$snapshot']({
           ignoredVdisTag: '[NOBAK]',
-          name_label: this._getSnapshotNameLabel(vm),
+          name_label: TEMP_SNAPSHOT_NAME,
           unplugVusbs: true,
         })
         this.timestamp = Date.now()
@@ -166,6 +169,9 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
           scheduleId: this.scheduleId,
           vmUuid: vm.uuid,
         })
+        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
         this._exportedVm = await xapi.getRecord('VM', snapshotRef)
         return this._exportedVm.uuid
       })
@@ -371,6 +377,11 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
         }
       })
     })
+
+    // list and remove the snapshot were the jobs failed between
+    // makesnapshot and update_other_config
+    const snapshots = this._vm.$snapshots.filter(_ => !!_).filter(({ name_label }) => name_label === TEMP_SNAPSHOT_NAME)
+    await asyncEach(snapshots, snapshot => snapshot.$destroy())
   }
 
   async _removeSnapshotData() {

package/_runners/_writers/IncrementalXapiWriter.mjs

@@ -1,7 +1,6 @@
-import { asyncMap, asyncMapSettled } from '@xen-orchestra/async-map'
+import { asyncMapSettled } from '@xen-orchestra/async-map'
 import ignoreErrors from 'promise-toolbox/ignoreErrors'
 
-import { formatFilenameDate } from '../../_filenameDate.mjs'
 import { getOldEntries } from '../../_getOldEntries.mjs'
 import { importIncrementalVm } from '../../_incrementalVm.mjs'
 import { Task } from '../../Task.mjs'
@@ -9,8 +8,18 @@ import { Task } from '../../Task.mjs'
 import { AbstractIncrementalWriter } from './_AbstractIncrementalWriter.mjs'
 import { MixinXapiWriter } from './_MixinXapiWriter.mjs'
 import { listReplicatedVms } from './_listReplicatedVms.mjs'
-import { COPY_OF, setVmOtherConfig, BASE_DELTA_VDI } from '../../_otherConfig.mjs'
+import {
+  COPY_OF,
+  setVmOtherConfig,
+  BASE_DELTA_VDI,
+  JOB_ID,
+  SCHEDULE_ID,
+  REPLICATED_TO_SR_UUID,
+  DATETIME,
+  VM_UUID,
+} from '../../_otherConfig.mjs'
 import assert from 'node:assert'
+import { formatFilenameDate } from '../../_filenameDate.mjs'
 
 export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
   async checkBaseVdis(baseUuidToSrcVdi) {
@@ -94,12 +103,28 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     return asyncMapSettled(this._oldEntries, vm => vm.$destroy())
   }
 
-  #decorateVmMetadata(backup) {
+  #decorateVmMetadata(backup, timestamp) {
     const { _warmMigration } = this._settings
     const sr = this._sr
     const vm = backup.vm
+    const job = this._job
+    const scheduleId = this._scheduleId
 
+    vm.name_label = `${vm.name_label} - ${job.name} - (${formatFilenameDate(timestamp)})`
+    // 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
+    vm.other_config[JOB_ID] = job.id
+    vm.other_config[SCHEDULE_ID] = scheduleId
+    vm.other_config[REPLICATED_TO_SR_UUID] = sr.uuid
+    // set the timestamp in the past to ensure any incomplete VM will be deleted on next run
+    vm.other_config[DATETIME] = formatFilenameDate(0)
+
+    vm.blocked_operations = {
+      start: 'Start operation for this vm is blocked, clone it if you want to use it.',
+      start_on: 'Start operation for this vm is blocked, clone it if you want to use it.',
+    }
+
     if (!_warmMigration) {
       vm.tags.push('Continuous Replication')
     }
@@ -118,6 +143,11 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
 
     Object.values(backup.vdis).forEach(vdi => {
       vdi.other_config[COPY_OF] = vdi.uuid
+      vdi.other_config[JOB_ID] = job.id
+      vdi.other_config[SCHEDULE_ID] = scheduleId
+      vdi.other_config[REPLICATED_TO_SR_UUID] = sr.uuid
+      vdi.other_config[VM_UUID] = vm.uuid
+
       if (sourceVdiUuids.length > 0) {
         const baseReplicatedTo = replicatedVdis.filter(
           replicatedVdi => replicatedVdi.other_config[COPY_OF] === vdi.other_config[BASE_DELTA_VDI]
@@ -144,12 +174,11 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     const sr = this._sr
     const job = this._job
     const scheduleId = this._scheduleId
-
     const { uuid: srUuid, $xapi: xapi } = sr
-
+    
     let targetVmRef
     await Task.run({ name: 'transfer' }, async () => {
-      targetVmRef = await importIncrementalVm(this.#decorateVmMetadata(deltaExport), sr)
+      targetVmRef = await importIncrementalVm(this.#decorateVmMetadata(deltaExport, timestamp), sr)
       // size is mandatory to ensure the task have the right data
       return {
         size: Object.values(deltaExport.disks).reduce(
@@ -166,15 +195,8 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       !_warmMigration &&
         targetVm.ha_restart_priority !== '' &&
         Promise.all([targetVm.set_ha_restart_priority(''), targetVm.add_tags('HA disabled')]),
-      targetVm.set_name_label(`${vm.name_label} - ${job.name} - (${formatFilenameDate(timestamp)})`),
-      asyncMap(['start', 'start_on'], op =>
-        targetVm.update_blocked_operations(
-          op,
-          'Start operation for this vm is blocked, clone it if you want to use it.'
-        )
-      ),
       setVmOtherConfig(xapi, targetVmRef, {
-        timestamp,
+        timestamp, // updated at the end to mark the transfer as complete
         jobId: job.id,
         scheduleId,
         vmUuid: vm.uuid,

package/_runners/_writers/_listReplicatedVms.mjs

@@ -20,9 +20,7 @@ export function listReplicatedVms(xapi, scheduleOrJobId, srUuid, vmUuid) {
       'start' in object.blocked_operations &&
       (oc[JOB_ID] === scheduleOrJobId || oc[SCHEDULE_ID] === scheduleOrJobId) &&
       oc[REPLICATED_TO_SR_UUID] === srUuid &&
-      (oc[VM_UUID] === vmUuid ||
-        // 2018-03-28, JFT: to catch VMs replicated before this fix
-        oc[VM_UUID] === undefined)
+      oc[VM_UUID] === vmUuid
     ) {
       vms[object.$id] = object
     }

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.68.0",
+  "version": "0.68.1",
   "engines": {
     "node": ">=14.18"
   },
@@ -26,7 +26,7 @@
     "@vates/disposable": "^0.1.6",
     "@vates/fuse-vhd": "^2.1.2",
     "@vates/generator-toolbox": "^1.1.0",
-    "@vates/nbd-client": "^3.2.2",
+    "@vates/nbd-client": "^3.2.3",
     "@vates/parse-duration": "^0.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
     "@xen-orchestra/disk-transform": "^1.2.1",
@@ -62,7 +62,7 @@
     "tmp": "^0.2.1"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^8.6.4"
+    "@xen-orchestra/xapi": "^8.6.5"
   },
   "license": "AGPL-3.0-or-later",
   "author": {