@xen-orchestra/backups 0.73.3 → 0.73.5

package/_incrementalVm.mjs

@@ -16,6 +16,44 @@ import { toQcow2Stream } from '@xen-orchestra/qcow2'
 
 const ensureArray = value => (value === undefined ? [] : Array.isArray(value) ? value : [value])
 
+const orderedMemoryLimits = ['memory_static_min', 'memory_dynamic_min', 'memory_dynamic_max', 'memory_static_max']
+
+// The dynamic memory range MUST respect this inequality at any moment: static_min <= dynamic_min <= dynamic_max <= static_max.
+// We must update these properties in the right order to avoid XAPI error.
+// The order depends on the values. It can be an increase, a decrease or a mix of both, so any order could be required.
+export async function updateMemoryFields(xapi, targetVm, vmRecord) {
+  const memoryValues = {}
+  for (const key of orderedMemoryLimits) {
+    memoryValues[key] = {
+      currentValue: targetVm[key],
+      newValue: vmRecord[key] ?? targetVm[key],
+    }
+  }
+
+  while (await updateNextMemoryField(xapi, memoryValues, targetVm.$ref)) {
+    /* execute until all memory fields are updated */
+  }
+}
+
+// Update one more memory field if needed, then return a boolean describing if a field was updated or if all fields are up to date
+async function updateNextMemoryField(xapi, memoryValues, vmRef) {
+  for (let i = 0; i < orderedMemoryLimits.length; i++) {
+    const currentField = memoryValues[orderedMemoryLimits[i]]
+    const nextField = i === orderedMemoryLimits.length - 1 ? undefined : memoryValues[orderedMemoryLimits[i + 1]]
+    if (
+      currentField.newValue !== currentField.currentValue &&
+      (nextField === undefined || currentField.newValue <= nextField.currentValue)
+    ) {
+      // no need to check that previousField.currentValue <= currentField.newValue, as we can deduce it
+      await xapi.setField('VM', vmRef, orderedMemoryLimits[i], currentField.newValue)
+      await xapi.barrier()
+      currentField.currentValue = currentField.newValue
+      return true
+    }
+  }
+  return false
+}
+
 export async function exportIncrementalVm(
   vm,
   baseVdis = {},
@@ -160,6 +198,9 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
   let vmRef
   if (isUpdate) {
     vmRef = targetRef
+
+    await updateMemoryFields(xapi, targetVm, vmRecord)
+
     await Promise.all([
       xapi.setFields('VM', vmRef, {
         actions_after_crash: vmRecord.actions_after_crash,
@@ -171,10 +212,6 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
         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,

package/_runners/VmsXapi.mjs

@@ -101,10 +101,14 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
 
         const handleVm = vmUuid => {
           const getVmTask = () => {
-            if (taskByVmId[vmUuid] === undefined) {
+            const started = taskByVmId[vmUuid] !== undefined
+            if (!started) {
               taskByVmId[vmUuid] = new Task(taskStart)
             }
-            return taskByVmId[vmUuid]
+            return {
+              task: taskByVmId[vmUuid],
+              started,
+            }
           }
           const vmBackupFailed = async (error, task) => {
             if (isLastRun) {
@@ -135,7 +139,7 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
                   taskStart.properties.name_label = vm.name_label
                 }
 
-                const task = getVmTask()
+                const { task } = getVmTask()
                 // error has to be caught in the task to prevent its failure, but handled outside the task to execute another task.run()
                 let taskError
                 return task
@@ -174,12 +178,19 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
                       task.success(result)
                     } else {
                       // ending the task with error or not ending the task
-                      vmBackupFailed(taskError, task)
+                      return vmBackupFailed(taskError, task)
                     }
                   })
                   .catch(noop) // errors are handled by logs
               }),
-            error => vmBackupFailed(error, getVmTask())
+            error => {
+              const { task: vmTask, started } = getVmTask()
+              if (!started) {
+                // the task is not started (except if it's a retry), and an unstarted task can't be failed
+                vmTask.start()
+              }
+              return vmBackupFailed(error, vmTask)
+            }
           )
         }
         const { concurrency } = settings

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.73.3",
+  "version": "0.73.5",
   "engines": {
     "node": ">=14.18"
   },
@@ -30,7 +30,7 @@
     "@vates/nbd-client": "^3.4.0",
     "@vates/parse-duration": "^0.1.1",
     "@vates/task": "^0.7.0",
-    "@vates/types": "^1.27.0",
+    "@vates/types": "^1.28.0",
     "@xen-orchestra/async-map": "^0.1.3",
     "@xen-orchestra/disk-transform": "^1.3.1",
     "@xen-orchestra/fs": "^4.9.1",