@xen-orchestra/backups 0.71.2 → 0.72.0

package/HealthCheckVmBackup.mjs

@@ -1,4 +1,4 @@
-import { Task } from './Task.mjs'
+import { Task } from '@vates/task'
 
 export class HealthCheckVmBackup {
   #restoredVm
@@ -14,7 +14,7 @@ export class HealthCheckVmBackup {
   async run() {
     return Task.run(
       {
-        name: 'vmstart',
+        properties: { name: 'vmstart' },
       },
       async () => {
         let restoredVm = this.#restoredVm

package/ImportVmBackup.mjs

@@ -2,9 +2,9 @@ import assert from 'node:assert'
 
 import { formatFilenameDate } from './_filenameDate.mjs'
 import { importIncrementalVm } from './_incrementalVm.mjs'
-import { Task } from './Task.mjs'
 import { watchStreamSize } from './_watchStreamSize.mjs'
 import { decorateClass } from '@vates/decorate-with'
+import { Task } from '@vates/task'
 import { createLogger } from '@xen-orchestra/log'
 import { dirname, join } from 'node:path'
 import pickBy from 'lodash/pickBy.js'
@@ -244,7 +244,7 @@ export class ImportVmBackup {
 
     return Task.run(
       {
-        name: 'transfer',
+        properties: { name: 'transfer' },
       },
       async () => {
         const xapi = this._xapi

package/_backupWorker.mjs

@@ -14,10 +14,10 @@ import { decorateMethodsWith } from '@vates/decorate-with'
 import { deduped } from '@vates/disposable/deduped.js'
 import { getHandler } from '@xen-orchestra/fs'
 import { parseDuration } from '@vates/parse-duration'
+import { Task } from '@vates/task'
 import { Xapi } from '@xen-orchestra/xapi'
 
 import { RemoteAdapter } from './RemoteAdapter.mjs'
-import { Task } from './Task.mjs'
 
 createCachedLookup().patchGlobal()
 
@@ -178,8 +178,8 @@ process.on('message', async message => {
       const result = message.runWithLogs
         ? await Task.run(
             {
-              name: 'backup run',
-              onLog: data =>
+              properties: { name: 'backup run', ...message.data.jobData },
+              onProgress: data =>
                 emitMessage({
                   data,
                   type: 'log',

package/_cleanVm.mjs

@@ -9,8 +9,8 @@ import { RemoteVhdDisk } from './disks/RemoteVhdDisk.mjs'
 import { RemoteVhdDiskChain } from './disks/RemoteVhdDiskChain.mjs'
 import { MergeRemoteDisk } from './disks/MergeRemoteDisk.mjs'
 
-import { Task } from './Task.mjs'
 import { Disposable } from 'promise-toolbox'
+import { Task } from '@vates/task'
 import handlerPath from '@xen-orchestra/fs/path'
 
 const { DISK_TYPES } = Constants
@@ -514,23 +514,27 @@ export async function cleanVm(
     })
   }
 
+  let totalMergedDataSize = 0
   const metadataWithMergedVhd = {}
   const doMerge = async () => {
     await asyncMap(toMerge, async chain => {
-      const { finalDiskSize } = await limitedMergeVhdChain(handler, chain, {
+      const { finalDiskSize, mergedDataSize } = await limitedMergeVhdChain(handler, chain, {
         logInfo,
         logWarn,
         remove,
         mergeBlockConcurrency,
       })
+      totalMergedDataSize += mergedDataSize
       const metadataPath = vhdsToJSons[chain[chain.length - 1]] // all the chain should have the same metadata file
       metadataWithMergedVhd[metadataPath] = (metadataWithMergedVhd[metadataPath] ?? 0) + finalDiskSize
     })
+
+    return { size: totalMergedDataSize }
   }
 
   await Promise.all([
     ...unusedVhdsDeletion,
-    toMerge.length !== 0 && (merge ? Task.run({ name: 'merge' }, doMerge) : () => Promise.resolve()),
+    toMerge.length !== 0 && (merge ? Task.run({ properties: { name: 'merge' } }, doMerge) : () => Promise.resolve()),
     asyncMap(unusedXvas, path => {
       logWarn('unused XVA', { path })
       if (remove) {
@@ -619,5 +623,6 @@ export async function cleanVm(
   return {
     // boolean whether some VHDs were merged (or should be merged)
     merge: toMerge.length !== 0,
+    size: totalMergedDataSize,
   }
 }

package/_incrementalVm.mjs

@@ -4,9 +4,9 @@ import { asyncMap } from '@xen-orchestra/async-map'
 import { CancelToken } from 'promise-toolbox'
 import { compareVersions } from 'compare-versions'
 import { defer } from 'golike-defer'
+import { Task } from '@vates/task'
 
 import { cancelableMap } from './_cancelableMap.mjs'
-import { Task } from './Task.mjs'
 import pick from 'lodash/pick.js'
 import { BASE_DELTA_VDI, CONTENT_KEY, COPY_OF, VM_UUID } from './_otherConfig.mjs'
 

package/_runners/Metadata.mjs

@@ -1,4 +1,5 @@
 import { asyncMap } from '@xen-orchestra/async-map'
+import { Task } from '@vates/task'
 import Disposable from 'promise-toolbox/Disposable'
 import ignoreErrors from 'promise-toolbox/ignoreErrors'
 
@@ -6,9 +7,10 @@ import { extractIdsFromSimplePattern } from '../extractIdsFromSimplePattern.mjs'
 import { PoolMetadataBackup } from './_PoolMetadataBackup.mjs'
 import { XoMetadataBackup } from './_XoMetadataBackup.mjs'
 import { DEFAULT_SETTINGS, Abstract } from './_Abstract.mjs'
-import { runTask } from './_runTask.mjs'
 import { getAdaptersByRemote } from './_getAdaptersByRemote.mjs'
 
+const noop = Function.prototype
+
 const DEFAULT_METADATA_SETTINGS = {
   retentionPoolMetadata: 0,
   retentionXoMetadata: 0,
@@ -55,13 +57,16 @@ export const Metadata = class MetadataBackupRunner extends Abstract {
         poolIds.map(id =>
           this._getRecord('pool', id).catch(error => {
             // See https://github.com/vatesfr/xen-orchestra/commit/6aa6cfba8ec939c0288f0fa740f6dfad98c43cbb
-            runTask(
+            Task.run(
               {
-                name: 'get pool record',
-                data: { type: 'pool', id },
+                properties: {
+                  id,
+                  name: 'get pool record',
+                  type: 'pool',
+                },
               },
               () => Promise.reject(error)
-            )
+            ).catch(noop)
           })
         )
       ),
@@ -81,11 +86,11 @@ export const Metadata = class MetadataBackupRunner extends Abstract {
         if (pools.length !== 0 && settings.retentionPoolMetadata !== 0) {
           promises.push(
             asyncMap(pools, async pool =>
-              runTask(
+              Task.run(
                 {
-                  name: `Starting metadata backup for the pool (${pool.$id}). (${job.id})`,
-                  data: {
+                  properties: {
                     id: pool.$id,
+                    name: `Starting metadata backup for the pool (${pool.$id}). (${job.id})`,
                     pool,
                     poolMaster: await ignoreErrors.call(pool.$xapi.getRecord('host', pool.master)),
                     type: 'pool',
@@ -100,17 +105,17 @@ export const Metadata = class MetadataBackupRunner extends Abstract {
                     schedule,
                     settings,
                   }).run()
-              )
+              ).catch(noop)
             )
           )
         }
 
         if (job.xoMetadata !== undefined && settings.retentionXoMetadata !== 0) {
           promises.push(
-            runTask(
+            Task.run(
               {
-                name: `Starting XO metadata backup. (${job.id})`,
-                data: {
+                properties: {
+                  name: `Starting XO metadata backup. (${job.id})`,
                   type: 'xo',
                 },
               },
@@ -122,7 +127,7 @@ export const Metadata = class MetadataBackupRunner extends Abstract {
                   schedule,
                   settings,
                 }).run()
-            )
+            ).catch(noop)
           )
         }
         await Promise.all(promises)

package/_runners/VmsRemote.mjs

@@ -1,9 +1,9 @@
 import { asyncMapSettled } from '@xen-orchestra/async-map'
 import Disposable from 'promise-toolbox/Disposable'
 import { limitConcurrency } from 'limit-concurrency-decorator'
+import { Task } from '@vates/task'
 
 import { extractIdsFromSimplePattern } from '../extractIdsFromSimplePattern.mjs'
-import { Task } from '../Task.mjs'
 import { DEFAULT_SETTINGS, Abstract } from './_Abstract.mjs'
 import { getAdaptersByRemote } from './_getAdaptersByRemote.mjs'
 import { FullRemote } from './_vmRunners/FullRemote.mjs'
@@ -78,7 +78,7 @@ export const VmsRemote = class RemoteVmsBackupRunner extends Abstract {
           }
           nTriesByVmId[vmUuid]++
 
-          const taskStart = { name: 'backup VM', data: { type: 'VM', id: vmUuid } }
+          const taskStart = { properties: { id: vmUuid, name: 'backup VM', type: 'VM' } }
           const vmSettings = { ...settings, ...allSettings[vmUuid] }
           const isLastRun = nTriesByVmId[vmUuid] === vmSettings.nRetriesVmBackupFailures + 1
 
@@ -113,23 +113,27 @@ export const VmsRemote = class RemoteVmsBackupRunner extends Abstract {
                   taskByVmId[vmUuid] = new Task(taskStart)
                 }
                 const task = taskByVmId[vmUuid]
+                // 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
-                  .run(async () => {
-                    try {
-                      const result = await vmBackup.run()
-                      task.success(result)
-                      return result
-                    } catch (error) {
-                      if (isLastRun) {
-                        throw error
-                      } else {
-                        Task.warning(`Retry the VM mirror backup due to an error`, {
-                          attempt: nTriesByVmId[vmUuid],
-                          error: error.message,
-                        })
-                        queue.add(vmUuid)
-                      }
+                  .runInside(async () =>
+                    vmBackup.run().catch(error => {
+                      taskError = error
+                    })
+                  )
+                  .then(result => {
+                    if (taskError === undefined) {
+                      return task.success(result)
                     }
+                    if (isLastRun) {
+                      return task.failure(taskError)
+                    }
+                    // don't end the task
+                    task.warning(`Retry the VM mirror backup due to an error`, {
+                      attempt: nTriesByVmId[vmUuid],
+                      error: taskError.message,
+                    })
+                    queue.add(vmUuid)
                   })
                   .catch(noop)
               }

package/_runners/VmsXapi.mjs

@@ -1,11 +1,10 @@
 import { asyncMapSettled } from '@xen-orchestra/async-map'
 import Disposable from 'promise-toolbox/Disposable'
 import { limitConcurrency } from 'limit-concurrency-decorator'
+import { Task } from '@vates/task'
 
 import { extractIdsFromSimplePattern } from '../extractIdsFromSimplePattern.mjs'
-import { Task } from '../Task.mjs'
 import { DEFAULT_SETTINGS, Abstract } from './_Abstract.mjs'
-import { runTask } from './_runTask.mjs'
 import { getAdaptersByRemote } from './_getAdaptersByRemote.mjs'
 import { IncrementalXapi } from './_vmRunners/IncrementalXapi.mjs'
 import { FullXapi } from './_vmRunners/FullXapi.mjs'
@@ -65,13 +64,12 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
       Disposable.all(
         extractIdsFromSimplePattern(job.srs).map(id =>
           this._getRecord('SR', id).catch(error => {
-            runTask(
+            Task.run(
               {
-                name: 'get SR record',
-                data: { type: 'SR', id },
+                properties: { id, name: 'get SR record', type: 'SR' },
               },
               () => Promise.reject(error)
-            )
+            ).catch(noop)
           })
         )
       ),
@@ -108,11 +106,12 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
             }
             return taskByVmId[vmUuid]
           }
-          const vmBackupFailed = error => {
+          const vmBackupFailed = async (error, task) => {
             if (isLastRun) {
-              throw error
+              return task.failure(error)
             } else {
-              Task.warning(`Retry the VM backup due to an error`, {
+              // don't end the task
+              task.warning(`Retry the VM backup due to an error`, {
                 attempt: nTriesByVmId[vmUuid],
                 error: error.message,
               })
@@ -126,19 +125,21 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
           nTriesByVmId[vmUuid]++
 
           const vmSettings = { ...settings, ...allSettings[vmUuid] }
-          const taskStart = { name: 'backup VM', data: { type: 'VM', id: vmUuid } }
+          const taskStart = { properties: { id: vmUuid, name: 'backup VM', type: 'VM' } }
           const isLastRun = nTriesByVmId[vmUuid] === vmSettings.nRetriesVmBackupFailures + 1
 
           return this._getRecord('VM', vmUuid).then(
             disposableVm =>
               Disposable.use(disposableVm, async vm => {
-                if (taskStart.data.name_label === undefined) {
-                  taskStart.data.name_label = vm.name_label
+                if (taskStart.properties.name_label === undefined) {
+                  taskStart.properties.name_label = vm.name_label
                 }
 
                 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
-                  .run(async () => {
+                  .runInside(async () => {
                     const opts = {
                       baseSettings,
                       config,
@@ -164,21 +165,21 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
                         throw new Error(`Job mode ${job.mode} not implemented`)
                       }
                     }
-
-                    try {
-                      const result = await vmBackup.run()
+                    return vmBackup.run().catch(error => {
+                      taskError = error
+                    })
+                  })
+                  .then(result => {
+                    if (taskError === undefined) {
                       task.success(result)
-                      return result
-                    } catch (error) {
-                      vmBackupFailed(error)
+                    } else {
+                      // ending the task with error or not ending the task
+                      vmBackupFailed(taskError, task)
                     }
                   })
                   .catch(noop) // errors are handled by logs
               }),
-            error =>
-              getVmTask().run(() => {
-                vmBackupFailed(error)
-              })
+            error => vmBackupFailed(error, getVmTask())
           )
         }
         const { concurrency } = settings

package/_runners/_Abstract.mjs

@@ -1,8 +1,10 @@
 import Disposable from 'promise-toolbox/Disposable'
 import pTimeout from 'promise-toolbox/timeout'
 import { compileTemplate } from '@xen-orchestra/template'
-import { runTask } from './_runTask.mjs'
 import { RemoteTimeoutError } from './_RemoteTimeoutError.mjs'
+import { Task } from '@vates/task'
+
+const noop = Function.prototype
 
 export const DEFAULT_SETTINGS = {
   getRemoteTimeout: 300e3,
@@ -36,13 +38,16 @@ export const Abstract = class AbstractRunner {
         })
       } catch (error) {
         // See https://github.com/vatesfr/xen-orchestra/commit/6aa6cfba8ec939c0288f0fa740f6dfad98c43cbb
-        runTask(
+        Task.run(
           {
-            name: 'get remote adapter',
-            data: { type: 'remote', id: remoteId },
+            properties: {
+              id: remoteId,
+              name: 'get remote adapter',
+              type: 'remote',
+            },
           },
           () => Promise.reject(error)
-        )
+        ).catch(noop)
       }
     }
   }

package/_runners/_PoolMetadataBackup.mjs

@@ -1,9 +1,9 @@
 import { asyncMap } from '@xen-orchestra/async-map'
+import { Task } from '@vates/task'
 
 import { DIR_XO_POOL_METADATA_BACKUPS } from '../RemoteAdapter.mjs'
 import { forkStreamUnpipe } from './_forkStreamUnpipe.mjs'
 import { formatFilenameDate } from '../_filenameDate.mjs'
-import { Task } from '../Task.mjs'
 
 export const PATH_DB_DUMP = '/pool/xmldbdump'
 
@@ -54,8 +54,8 @@ export class PoolMetadataBackup {
       ([remoteId, adapter]) =>
         Task.run(
           {
-            name: `Starting metadata backup for the pool (${pool.$id}) for the remote (${remoteId}). (${job.id})`,
-            data: {
+            properties: {
+              name: `Starting metadata backup for the pool (${pool.$id}) for the remote (${remoteId}). (${job.id})`,
               id: remoteId,
               type: 'remote',
             },

package/_runners/_XoMetadataBackup.mjs

@@ -1,9 +1,9 @@
 import { asyncMap } from '@xen-orchestra/async-map'
 import { join } from '@xen-orchestra/fs/path'
+import { Task } from '@vates/task'
 
 import { DIR_XO_CONFIG_BACKUPS } from '../RemoteAdapter.mjs'
 import { formatFilenameDate } from '../_filenameDate.mjs'
-import { Task } from '../Task.mjs'
 
 export class XoMetadataBackup {
   constructor({ config, job, remoteAdapters, schedule, settings }) {
@@ -51,8 +51,8 @@ export class XoMetadataBackup {
       ([remoteId, adapter]) =>
         Task.run(
           {
-            name: `Starting XO metadata backup for the remote (${remoteId}). (${job.id})`,
-            data: {
+            properties: {
+              name: `Starting XO metadata backup for the remote (${remoteId}). (${job.id})`,
               id: remoteId,
               type: 'remote',
             },

package/_runners/_vmRunners/IncrementalXapi.mjs

@@ -1,4 +1,5 @@
 import { createLogger } from '@xen-orchestra/log'
+import { Task } from '@vates/task'
 import keyBy from 'lodash/keyBy.js'
 
 import { AbstractXapi } from './_AbstractXapi.mjs'
@@ -6,7 +7,6 @@ import { forkDeltaExport } from './_forkDeltaExport.mjs'
 import { exportIncrementalVm } from '../../_incrementalVm.mjs'
 import { IncrementalRemoteWriter } from '../_writers/IncrementalRemoteWriter.mjs'
 import { IncrementalXapiWriter } from '../_writers/IncrementalXapiWriter.mjs'
-import { Task } from '../../Task.mjs'
 import {
   DATETIME,
   DELTA_CHAIN_LENGTH,

package/_runners/_vmRunners/_Abstract.mjs

@@ -1,6 +1,6 @@
 import { asyncMap } from '@xen-orchestra/async-map'
 import { createLogger } from '@xen-orchestra/log'
-import { Task } from '../../Task.mjs'
+import { Task } from '@vates/task'
 
 const { debug, warn } = createLogger('xo:backups:AbstractVmRunner')
 
@@ -83,7 +83,7 @@ export const Abstract = class AbstractVmBackupRunner {
       // create a task to have an info in the logs and reports
       return Task.run(
         {
-          name: 'health check',
+          properties: { name: 'health check' },
         },
         () => {
           Task.info(`This VM doesn't match the health check's tags for this schedule`)

package/_runners/_vmRunners/_AbstractRemote.mjs

@@ -4,12 +4,12 @@ import { decorateMethodsWith } from '@vates/decorate-with'
 import { defer } from 'golike-defer'
 import { Disposable } from 'promise-toolbox'
 import { createPredicate } from 'value-matcher'
+import { Task } from '@vates/task'
 
 import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
 
 import { Abstract } from './_Abstract.mjs'
 import { extractIdsFromSimplePattern } from '../../extractIdsFromSimplePattern.mjs'
-import { Task } from '../../Task.mjs'
 
 export const AbstractRemote = class AbstractRemoteVmBackupRunner extends Abstract {
   _filterPredicate

package/_runners/_vmRunners/_AbstractXapi.mjs

@@ -6,9 +6,9 @@ import { asyncMap } from '@xen-orchestra/async-map'
 import { asyncEach } from '@vates/async-each'
 import { decorateMethodsWith } from '@vates/decorate-with'
 import { defer } from 'golike-defer'
+import { Task } from '@vates/task'
 
 import { getOldEntries } from '../../_getOldEntries.mjs'
-import { Task } from '../../Task.mjs'
 import { Abstract } from './_Abstract.mjs'
 import {
   COPY_OF,
@@ -186,7 +186,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
     const settings = this._settings
 
     if (await this._mustDoSnapshot()) {
-      await Task.run({ name: 'snapshot' }, async () => {
+      await Task.run({ properties: { name: 'snapshot' } }, async () => {
         if (!settings.bypassVdiChainsCheck) {
           await vm.$assertHealthyVdiChains()
         }

package/_runners/_writers/FullRemoteWriter.mjs

@@ -1,6 +1,7 @@
+import { Task } from '@vates/task'
+
 import { formatFilenameDate } from '../../_filenameDate.mjs'
 import { getOldEntries } from '../../_getOldEntries.mjs'
-import { Task } from '../../Task.mjs'
 
 import { MixinRemoteWriter } from './_MixinRemoteWriter.mjs'
 import { AbstractFullWriter } from './_AbstractFullWriter.mjs'
@@ -9,11 +10,11 @@ export class FullRemoteWriter extends MixinRemoteWriter(AbstractFullWriter) {
   constructor(props) {
     super(props)
 
-    this.run = Task.wrapFn(
+    this.run = Task.wrap(
       {
-        name: 'export',
-        data: {
+        properties: {
           id: props.remoteId,
+          name: 'export',
           type: 'remote',
 
           // necessary?
@@ -64,7 +65,7 @@ export class FullRemoteWriter extends MixinRemoteWriter(AbstractFullWriter) {
       await deleteOldBackups()
     }
 
-    await Task.run({ name: 'transfer' }, async () => {
+    await Task.run({ properties: { name: 'transfer' } }, async () => {
       await adapter.outputStream(dataFilename, stream, {
         maxStreamLength,
         streamLength,

package/_runners/_writers/FullXapiWriter.mjs

@@ -1,9 +1,9 @@
 import ignoreErrors from 'promise-toolbox/ignoreErrors'
 import { asyncMap, asyncMapSettled } from '@xen-orchestra/async-map'
+import { Task } from '@vates/task'
 
 import { formatFilenameDate } from '../../_filenameDate.mjs'
 import { getOldEntries } from '../../_getOldEntries.mjs'
-import { Task } from '../../Task.mjs'
 
 import { AbstractFullWriter } from './_AbstractFullWriter.mjs'
 import { MixinXapiWriter } from './_MixinXapiWriter.mjs'
@@ -14,11 +14,11 @@ export class FullXapiWriter extends MixinXapiWriter(AbstractFullWriter) {
   constructor(props) {
     super(props)
 
-    this.run = Task.wrapFn(
+    this.run = Task.wrap(
       {
-        name: 'export',
-        data: {
+        properties: {
           id: props.sr.uuid,
+          name: 'export',
           name_label: this._sr.name_label,
           type: 'SR',
 
@@ -52,7 +52,7 @@ export class FullXapiWriter extends MixinXapiWriter(AbstractFullWriter) {
     }
 
     let targetVmRef
-    await Task.run({ name: 'transfer' }, async () => {
+    await Task.run({ properties: { name: 'transfer' } }, async () => {
       targetVmRef = await xapi.VM_import(stream, sr.$ref, vm =>
         Promise.all([
           !_warmMigration && vm.add_tags('Disaster Recovery'),

package/_runners/_writers/IncrementalRemoteWriter.mjs

@@ -7,10 +7,10 @@ import { createLogger } from '@xen-orchestra/log'
 import { decorateClass } from '@vates/decorate-with'
 import { defer } from 'golike-defer'
 import { dirname, basename } from 'node:path'
+import { Task } from '@vates/task'
 
 import { formatFilenameDate } from '../../_filenameDate.mjs'
 import { getOldEntries } from '../../_getOldEntries.mjs'
-import { Task } from '../../Task.mjs'
 
 import { MixinRemoteWriter } from './_MixinRemoteWriter.mjs'
 import { AbstractIncrementalWriter } from './_AbstractIncrementalWriter.mjs'
@@ -72,19 +72,20 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
   prepare({ isFull }) {
     // create the task related to this export and ensure all methods are called in this context
     const task = new Task({
-      name: 'export',
-      data: {
+      properties: {
         id: this._remoteId,
         isFull,
+        name: 'export',
         type: 'remote',
       },
     })
-    this.transfer = task.wrapFn(this.transfer)
-    this.healthCheck = task.wrapFn(this.healthCheck)
-    this.cleanup = task.wrapFn(this.cleanup)
-    this.afterBackup = task.wrapFn(this.afterBackup, true)
+    this._prepare = task.wrapInside(this._prepare)
+    this.transfer = task.wrapInside(this.transfer)
+    this.healthCheck = task.wrapInside(this.healthCheck)
+    this.cleanup = task.wrapInside(this.cleanup)
+    this.afterBackup = task.wrap(this.afterBackup)
 
-    return task.run(() => this._prepare())
+    return this._prepare()
   }
 
   async _prepare() {
@@ -223,7 +224,7 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
       vtpms: deltaExport.vtpms,
     }
     let size = 0
-    await Task.run({ name: 'transfer' }, async () => {
+    await Task.run({ properties: { name: 'transfer' } }, async () => {
       await asyncEach(
         Object.entries(deltaExport.disks),
         async ([diskRef, disk]) => {

package/_runners/_writers/IncrementalXapiWriter.mjs

@@ -1,11 +1,11 @@
 import humanFormat from 'human-format'
 
 import { asyncMapSettled } from '@xen-orchestra/async-map'
+import { Task } from '@vates/task'
 import ignoreErrors from 'promise-toolbox/ignoreErrors'
 
 import { getOldEntries } from '../../_getOldEntries.mjs'
 import { importIncrementalVm } from '../../_incrementalVm.mjs'
-import { Task } from '../../Task.mjs'
 
 import { AbstractIncrementalWriter } from './_AbstractIncrementalWriter.mjs'
 import { MixinXapiWriter } from './_MixinXapiWriter.mjs'
@@ -65,8 +65,9 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
         snapshotCandidates,
         async snapshot => {
           let diffDisk
+          let activeVdi
           try {
-            const activeVdi = sr.$xapi.getObject(snapshot.$snapshot_of)
+            activeVdi = sr.$xapi.getObject(snapshot.$snapshot_of)
             const userVbds = activeVdi.$VBDs?.filter(vbd => vbd.$VM && !vbd.$VM.is_control_domain) ?? []
             if (userVbds.length !== 1) {
               debug('checkBaseVdis, share vbd ', { ref: snapshot.$ref, userVbds })
@@ -81,7 +82,12 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
               // but it indicates the users played with the blocked operations
               return
             }
-            diffDisk = new XapiDiskSource({ xapi: sr.$xapi, vdiRef: activeVdi.$ref, baseRef: snapshot.$ref })
+            diffDisk = new XapiDiskSource({
+              xapi: sr.$xapi,
+              vdiRef: activeVdi.$ref,
+              baseRef: snapshot.$ref,
+              onlyListChangedBlocks: true,
+            })
             await diffDisk.init()
             if (diffDisk.getBlockIndexes().length === 0) {
               const sourceUuid = snapshot.other_config?.[COPY_OF]
@@ -103,6 +109,10 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
             return
           } finally {
             await diffDisk?.close().catch(error => debug('checkBaseVdis, error closing', error))
+            await sr.$xapi.VDI_disconnectFromControlDomain(snapshot.$ref)
+            if (activeVdi !== undefined) {
+              await sr.$xapi.VDI_disconnectFromControlDomain(activeVdi.$ref)
+            }
           }
         },
         {
@@ -141,20 +151,24 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
   prepare({ isFull }) {
     // create the task related to this export and ensure all methods are called in this context
     const task = new Task({
-      name: 'export',
-      data: {
+      properties: {
         id: this._sr.uuid,
         isFull,
+        name: 'export',
         name_label: this._sr.name_label,
         type: 'SR',
       },
     })
-    const hasHealthCheckSr = this._healthCheckSr !== undefined
-    this.transfer = task.wrapFn(this.transfer)
-    this.cleanup = task.wrapFn(this.cleanup, !hasHealthCheckSr)
-    this.healthCheck = task.wrapFn(this.healthCheck, hasHealthCheckSr)
+    this._prepare = task.wrapInside(this._prepare)
+    this.transfer = task.wrapInside(this.transfer)
+    if (this._healthCheckSr !== undefined) {
+      this.cleanup = task.wrapInside(this.cleanup)
+      this.healthCheck = task.wrap(this.healthCheck)
+    } else {
+      this.cleanup = task.wrap(this.cleanup)
+    }
 
-    return task.run(() => this._prepare(isFull))
+    return this._prepare(isFull)
   }
 
   async _prepare(isFull) {
@@ -255,7 +269,7 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     const { uuid: srUuid, $xapi: xapi } = sr
 
     let targetVmRef
-    await Task.run({ name: 'transfer' }, async () => {
+    await Task.run({ properties: { name: 'transfer' } }, async () => {
       targetVmRef = await importIncrementalVm(this.#decorateVmMetadata(deltaExport, timestamp), sr, {
         targetRef: this._targetVmRef,
       })
@@ -279,7 +293,7 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
           ` -- last replication: ${formatFilenameDate(timestamp)} ${humanFormat.bytes(size)} read`
       )
       // take a snapshot to ensure these data are not modified until next snapshot
-      await Task.run({ name: 'target snapshot' }, async () => {
+      await Task.run({ properties: { name: 'target snapshot' } }, async () => {
         await xapi.VM_snapshot(targetVmRef, {
           name_label: `${vm.name_label} - ${job.name} / ${schedule.name} ${formatFilenameDate(timestamp)}`,
         })

package/_runners/_writers/_MixinRemoteWriter.mjs

@@ -1,12 +1,12 @@
 import { createLogger } from '@xen-orchestra/log'
 import { join } from 'node:path'
+import { Task } from '@vates/task'
 import assert from 'node:assert'
 
 import { formatFilenameDate } from '../../_filenameDate.mjs'
 import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
 import { HealthCheckVmBackup } from '../../HealthCheckVmBackup.mjs'
 import { ImportVmBackup } from '../../ImportVmBackup.mjs'
-import { Task } from '../../Task.mjs'
 import * as MergeWorker from '../../merge-worker/index.mjs'
 import ms from 'ms'
 import { getEntryStatus } from '../../_getOldEntries.mjs'
@@ -28,7 +28,7 @@ export const MixinRemoteWriter = (BaseClass = Object) =>
 
     async _cleanVm(options) {
       try {
-        return await Task.run({ name: 'clean-vm' }, () => {
+        return await Task.run({ properties: { name: 'clean-vm' } }, () => {
           return this._adapter.cleanVm(this._vmBackupDir, {
             ...options,
             fixMetadata: true,
@@ -100,7 +100,7 @@ export const MixinRemoteWriter = (BaseClass = Object) =>
       }
       return Task.run(
         {
-          name: 'health check',
+          properties: { name: 'health check' },
         },
         async () => {
           const xapi = sr.$xapi

package/_runners/_writers/_MixinXapiWriter.mjs

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
+import { Task } from '@vates/task'
 
 import { HealthCheckVmBackup } from '../../HealthCheckVmBackup.mjs'
-import { Task } from '../../Task.mjs'
 import ms from 'ms'
 
 export const MixinXapiWriter = (BaseClass = Object) =>
@@ -33,7 +33,7 @@ export const MixinXapiWriter = (BaseClass = Object) =>
       // copy VM
       return Task.run(
         {
-          name: 'health check',
+          properties: { name: 'health check' },
         },
         async () => {
           const { $xapi: xapi } = sr
@@ -47,12 +47,12 @@ export const MixinXapiWriter = (BaseClass = Object) =>
             }
             if (await this.#isAlreadyOnHealthCheckSr(baseVm)) {
               healthCheckVmRef = await Task.run(
-                { name: 'cloning-vm' },
+                { properties: { name: 'cloning-vm' } },
                 async () => await xapi.callAsync('VM.clone', this._targetVmRef, `Health Check - ${baseVm.name_label}`)
               )
             } else {
               healthCheckVmRef = await Task.run(
-                { name: 'copying-vm' },
+                { properties: { name: 'copying-vm' } },
                 async () =>
                   await xapi.callAsync(
                     'VM.copy',

package/disks/MergeRemoteDisk.mjs

@@ -10,6 +10,7 @@ import { createLogger } from '@xen-orchestra/log'
 
 import { basename, dirname } from 'path'
 import { asyncEach } from '@vates/async-each'
+import { relativeFromFile } from '@xen-orchestra/fs/path'
 
 // @ts-ignore
 const { warn } = createLogger('remote-disk:merge')
@@ -18,6 +19,7 @@ const { warn } = createLogger('remote-disk:merge')
  * @typedef {Object} MergeState
  * @property {{ uuid: string }} child
  * @property {{ uuid: string }} parent
+ * @property { string[]  | undefined} chain
  * @property {number} currentBlock
  * @property {number} mergedDataSize
  * @property {'mergeBlocks' | 'cleanup'} step
@@ -32,6 +34,7 @@ export class MergeRemoteDisk {
   #state = {
     child: { uuid: '0' },
     parent: { uuid: '0' },
+    chain: undefined,
     currentBlock: 0,
     mergedDataSize: 0,
     step: 'mergeBlocks',
@@ -205,6 +208,9 @@ export class MergeRemoteDisk {
     } else {
       this.#state.child = { uuid: childDisk.getUuid() ?? undefined }
       this.#state.parent = { uuid: parentDisk.getUuid() ?? undefined }
+      this.#state.chain = [parentDisk.getPath(), ...childDisk.getPaths()].map(path =>
+        relativeFromFile(this.#statePath, path)
+      )
 
       // Finds first allocated block for the 2 following loops
       while (this.#state.currentBlock < getMaxBlockCount && !childDisk.hasBlock(this.#state.currentBlock)) {

package/disks/RemoteDisk.mjs

@@ -55,6 +55,16 @@ export class RemoteDisk extends RandomAccessDisk {
     throw new Error(`getPath must be implemented`)
   }
 
+  /**
+   * Abstract
+   * Returns an array of disk paths.
+   *
+   * @returns {string[]}
+   */
+  getPaths() {
+    throw new Error(`getPaths must be implemented`)
+  }
+
   /**
    * Abstract
    * @returns {string}

package/disks/RemoteVhdDisk.mjs

@@ -16,6 +16,7 @@ import { DISK_TYPES } from 'vhd-lib/_constants.js'
 import { isVhdAlias, resolveVhdAlias } from 'vhd-lib/aliases.js'
 import { stringify } from 'uuid'
 import { dirname, join } from 'node:path'
+import { RemoteVhdDiskChain } from './RemoteVhdDiskChain.mjs'
 
 export class RemoteVhdDisk extends RemoteDisk {
   /**
@@ -140,6 +141,15 @@ export class RemoteVhdDisk extends RemoteDisk {
     return this.#path
   }
 
+  /**
+   * Returns the disk path in an array.
+   *
+   * @returns {string[]}
+   */
+  getPaths() {
+    return [this.getPath()]
+  }
+
   /**
    * @returns {string}
    */
@@ -259,7 +269,11 @@ export class RemoteVhdDisk extends RemoteDisk {
    * @returns {Promise<number>} blockSize
    */
   async mergeBlock(childDisk, index, isResumingMerge) {
-    if ((await this.isDirectory()) && childDisk instanceof RemoteVhdDisk && (await childDisk.isDirectory())) {
+    if (
+      (childDisk instanceof RemoteVhdDisk || childDisk instanceof RemoteVhdDiskChain) &&
+      (await this.isDirectory()) &&
+      (await childDisk.isDirectory())
+    ) {
       try {
         await this.#handler.rename(childDisk.getBlockPath(index), this.getBlockPath(index))
 

package/disks/RemoteVhdDiskChain.mjs

@@ -123,6 +123,15 @@ export class RemoteVhdDiskChain extends RemoteDisk {
     return this.#disks[this.#disks.length - 1].getPath()
   }
 
+  /**
+   * Disk chains return an array of disk paths.
+   *
+   * @returns {string[]}
+   */
+  getPaths() {
+    return this.#disks.map(disk => disk.getPath())
+  }
+
   /**
    * @returns {string}
    */
@@ -134,12 +143,7 @@ export class RemoteVhdDiskChain extends RemoteDisk {
    * @returns {Promise<boolean>} canMergeConcurently
    */
   async canMergeConcurently() {
-    for (const disk of this.#disks) {
-      if (!(await disk.isDirectory())) {
-        return true
-      }
-    }
-    return false
+    return this.isDirectory()
   }
 
   /**
@@ -221,6 +225,21 @@ export class RemoteVhdDiskChain extends RemoteDisk {
     throw new Error(`Can't merge block into a disk chain`)
   }
 
+  /**
+   * Gets a specific block path from the VHD directory disk.
+   * @param {number} index
+   * @returns {string} blockPath
+   */
+  getBlockPath(index) {
+    for (const disk of [...this.#disks].reverse()) {
+      if (disk.hasBlock(index)) {
+        return disk.getBlockPath(index)
+      }
+    }
+
+    throw new Error(`Block ${index} not found in chain`)
+  }
+
   /**
    * @returns {VhdFooter}
    */
@@ -269,4 +288,17 @@ export class RemoteVhdDiskChain extends RemoteDisk {
       await disk.unlink()
     }
   }
+
+  /**
+   * Check if all the disks in the chain are VHD directories.
+   * @returns {Promise<boolean>}
+   */
+  async isDirectory() {
+    for (const disk of this.#disks) {
+      if (!(await disk.isDirectory())) {
+        return false
+      }
+    }
+    return true
+  }
 }

package/package.json

@@ -8,32 +8,34 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.71.2",
+  "version": "0.72.0",
   "engines": {
     "node": ">=14.18"
   },
   "scripts": {
     "postversion": "npm publish --access public",
+    "test": "node --test",
     "test-integration": "node --test *.integ.mjs"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
     "@kldzj/stream-throttle": "^1.1.1",
-    "@vates/async-each": "^1.0.2",
+    "@vates/async-each": "^1.0.3",
     "@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.1",
-    "@vates/nbd-client": "^3.3.0",
+    "@vates/generator-toolbox": "^1.1.2",
+    "@vates/nbd-client": "^3.4.0",
     "@vates/parse-duration": "^0.1.1",
-    "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/disk-transform": "^1.2.2",
-    "@xen-orchestra/fs": "^4.7.0",
-    "@xen-orchestra/log": "^0.7.1",
-    "@xen-orchestra/qcow2": "^1.2.0",
-    "@xen-orchestra/template": "^0.1.0",
+    "@vates/task": "^0.7.0",
+    "@xen-orchestra/async-map": "^0.1.3",
+    "@xen-orchestra/disk-transform": "^1.2.3",
+    "@xen-orchestra/fs": "^4.8.0",
+    "@xen-orchestra/log": "^0.7.2",
+    "@xen-orchestra/qcow2": "^1.3.0",
+    "@xen-orchestra/template": "^0.1.1",
     "app-conf": "^3.0.0",
     "compare-versions": "^6.0.0",
     "d3-time-format": "^4.1.0",
@@ -41,7 +43,7 @@
     "golike-defer": "^0.5.1",
     "human-format": "^1.2.0",
     "limit-concurrency-decorator": "^0.6.0",
-    "lodash": "^4.17.20",
+    "lodash": "^4.18.0",
     "moment-timezone": "^0.5.46",
     "ms": "^2.1.3",
     "node-zone": "^0.4.0",
@@ -51,8 +53,8 @@
     "tar": "^7.5.3",
     "uuid": "^9.0.0",
     "value-matcher": "^0.2.0",
-    "vhd-lib": "^4.15.0",
-    "xen-api": "^4.7.6",
+    "vhd-lib": "^4.16.0",
+    "xen-api": "^4.7.7",
     "yazl": "^2.5.1"
   },
   "devDependencies": {
@@ -62,7 +64,7 @@
     "tmp": "^0.2.1"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^8.7.0"
+    "@xen-orchestra/xapi": "^8.7.2"
   },
   "license": "AGPL-3.0-or-later",
   "author": {

package/Task.mjs

@@ -1,155 +0,0 @@
-import CancelToken from 'promise-toolbox/CancelToken'
-import Zone from 'node-zone'
-
-const logAfterEnd = log => {
-  const error = new Error('task has already ended')
-  error.log = log
-  throw error
-}
-
-const noop = Function.prototype
-
-const serializeErrors = errors => (Array.isArray(errors) ? errors.map(serializeError) : errors)
-
-// Create a serializable object from an error.
-//
-// Otherwise some fields might be non-enumerable and missing from logs.
-const serializeError = error =>
-  error instanceof Error
-    ? {
-        ...error, // Copy enumerable properties.
-        code: error.code,
-        errors: serializeErrors(error.errors), // supports AggregateError
-        message: error.message,
-        name: error.name,
-        stack: error.stack,
-      }
-    : error
-
-const $$task = Symbol('@xen-orchestra/backups/Task')
-
-export class Task {
-  static get cancelToken() {
-    const task = Zone.current.data[$$task]
-    return task !== undefined ? task.#cancelToken : CancelToken.none
-  }
-
-  static run(opts, fn) {
-    return new this(opts).run(fn, true)
-  }
-
-  static wrapFn(opts, fn) {
-    // compatibility with @decorateWith
-    if (typeof fn !== 'function') {
-      ;[fn, opts] = [opts, fn]
-    }
-
-    return function () {
-      return Task.run(typeof opts === 'function' ? opts.apply(this, arguments) : opts, () => fn.apply(this, arguments))
-    }
-  }
-
-  #cancelToken
-  #id = Math.random().toString(36).slice(2)
-  #onLog
-  #zone
-
-  constructor({ name, data, onLog }) {
-    let parentCancelToken, parentId
-    if (onLog === undefined) {
-      const parent = Zone.current.data[$$task]
-      if (parent === undefined) {
-        onLog = noop
-      } else {
-        onLog = log => parent.#onLog(log)
-        parentCancelToken = parent.#cancelToken
-        parentId = parent.#id
-      }
-    }
-
-    const zone = Zone.current.fork('@xen-orchestra/backups/Task')
-    zone.data[$$task] = this
-    this.#zone = zone
-
-    const { cancel, token } = CancelToken.source(parentCancelToken && [parentCancelToken])
-    this.#cancelToken = token
-    this.cancel = cancel
-
-    this.#onLog = onLog
-
-    this.#log('start', {
-      data,
-      message: name,
-      parentId,
-    })
-  }
-
-  failure(error) {
-    this.#end('failure', serializeError(error))
-  }
-
-  info(message, data) {
-    this.#log('info', { data, message })
-  }
-
-  /**
-   * Run a function in the context of this task
-   *
-   * In case of error, the task will be failed.
-   *
-   * @typedef Result
-   * @param {() => Result} fn
-   * @param {boolean} last - Whether the task should succeed if there is no error
-   * @returns Result
-   */
-  run(fn, last = false) {
-    return this.#zone.run(() => {
-      try {
-        const result = fn()
-        let then
-        if (result != null && typeof (then = result.then) === 'function') {
-          then.call(result, last && (value => this.success(value)), error => this.failure(error))
-        } else if (last) {
-          this.success(result)
-        }
-        return result
-      } catch (error) {
-        this.failure(error)
-        throw error
-      }
-    })
-  }
-
-  success(value) {
-    this.#end('success', value)
-  }
-
-  warning(message, data) {
-    this.#log('warning', { data, message })
-  }
-
-  wrapFn(fn, last) {
-    const task = this
-    return function () {
-      return task.run(() => fn.apply(this, arguments), last)
-    }
-  }
-
-  #end(status, result) {
-    this.#log('end', { result, status })
-    this.#onLog = logAfterEnd
-  }
-
-  #log(event, props) {
-    this.#onLog({
-      ...props,
-      event,
-      taskId: this.#id,
-      timestamp: Date.now(),
-    })
-  }
-}
-
-for (const method of ['info', 'warning']) {
-  Task[method] = (...args) => Zone.current.data[$$task]?.[method](...args)
-}

package/_runners/_runTask.mjs

@@ -1,5 +0,0 @@
-import { Task } from '../Task.mjs'
-
-const noop = Function.prototype
-
-export const runTask = (...args) => Task.run(...args).catch(noop) // errors are handled by logs