@xen-orchestra/backups 0.71.3 → 0.72.1

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/RemoteAdapter.mjs

@@ -702,7 +702,7 @@ export class RemoteAdapter {
     const handler = this._handler
 
     if (this.useVhdDirectory()) {
-      await writeToVhdDirectory({
+      return await writeToVhdDirectory({
         disk,
         target: {
           handler,
@@ -714,8 +714,9 @@ export class RemoteAdapter {
       })
     } else {
       const stream = await toVhdStream(disk)
-      await this.outputStream(path, stream, { validator, checksum: false })
+      const size = await this.outputStream(path, stream, { validator, checksum: false })
       await validator(path)
+      return size
     }
   }
 

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) {
@@ -582,18 +586,13 @@ export async function cleanVm(
       return
     }
 
-    // systematically update size and differentials after a merge
-
-    // @todo : after 2024-04-01 remove the fixmetadata options since the size computation is fixed
-    if (mergedSize || (fixMetadata && fileSystemSize !== size)) {
-      metadata.size = mergedSize ?? fileSystemSize ?? size
-
-      if (mergedSize) {
-        // all disks are now key disk
-        metadata.isVhdDifferencing = {}
-        for (const id of Object.keys(metadata.vdis ?? {})) {
-          metadata.isVhdDifferencing[id] = false
-        }
+    // Rewrite metadata when a merge changed the backup layout.
+    if (mergedSize) {
+      metadata.size = mergedSize
+      // all disks are now key disk
+      metadata.isVhdDifferencing = {}
+      for (const id of Object.keys(metadata.vdis ?? {})) {
+        metadata.isVhdDifferencing[id] = false
       }
       mustRegenerateCache = true
       try {
@@ -619,5 +618,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()
         }
@@ -338,6 +338,20 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
     }
 
     this._jobSnapshotVdis = Object.values(vdiCandidates)
+
+    // For VMs with no disks, retention must be tracked directly on VM snapshots
+    // since there are no VDIs to anchor the discovery.
+    if (vdiUuids.length === 0) {
+      this._disklessJobSnapshotVms = this._vm.$snapshots.filter(Boolean).filter(
+        ({ other_config, $snapshot_of }) =>
+          $snapshot_of !== undefined &&
+          other_config[JOB_ID] === jobId &&
+          other_config[VM_UUID] === this._vm.uuid &&
+          other_config[COPY_OF] === undefined
+      )
+    } else {
+      this._disklessJobSnapshotVms = []
+    }
   }
 
   async _removeUnusedSnapshots() {
@@ -349,9 +363,10 @@ 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))
+    const disklessVmSnapshots = this._disklessJobSnapshotVms.map(vm => xapi.getObject(vm.$ref))
 
-    // get the datetime of the most recent snapshot
-    const lastSnapshotDateTime = this._jobSnapshotVdis
+    // get the datetime of the most recent snapshot across both VDI and diskless VM snapshots
+    const lastSnapshotDateTime = [...this._jobSnapshotVdis, ...disklessVmSnapshots]
       .map(({ other_config }) => other_config[DATETIME])
       .sort()
       .pop()
@@ -428,6 +443,28 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
       })
     })
 
+    // Retention for VMs with no disks: VM snapshots are not reachable via VDIs
+    if (disklessVmSnapshots.length > 0) {
+      const snapshotsPerSchedule = groupBy(disklessVmSnapshots, _ => _.other_config[SCHEDULE_ID])
+      await asyncEach(Object.entries(snapshotsPerSchedule), async ([scheduleId, snapshots]) => {
+        // we only have one snapshot per date time since it's at the VM level 
+        const snapshotPerDatetime = Object.fromEntries(snapshots.map(s => [s.other_config[DATETIME], s.$ref]))
+        const datetimes = Object.keys(snapshotPerDatetime).sort()
+        const settings = {
+          ...baseSettings,
+          ...allSettings[scheduleId],
+          ...allSettings[this._vm.uuid],
+        }
+        const retention = settings.snapshotRetention ?? 0
+        await asyncEach(getOldEntries(retention, datetimes), async datetime => {
+          if (this.job.mode === 'delta' && datetime === lastSnapshotDateTime) {
+            return
+          }
+          await xapi.VM_destroy(snapshotPerDatetime[datetime])
+        })
+      })
+    }
+
     // 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)

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,19 +224,18 @@ 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]) => {
           const path = `${this._vmBackupDir}/${vhds[diskRef]}`
-          await adapter.writeVhd(path, disk, {
+          size += await adapter.writeVhd(path, disk, {
             // no checksum for VHDs, because they will be invalidated by
             // merges and chains
             checksum: false,
             validator: tmpPath => checkVhd(handler, tmpPath),
             writeBlockConcurrency: this._config.writeBlockConcurrency,
           })
-          size = size + disk.getNbGeneratedBlock() * disk.getBlockSize()
         },
         {
           concurrency: settings.diskPerVmConcurrency,

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'
@@ -57,71 +57,14 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
     debug('checkBaseVdis, got snapshot candidates,', snapshotCandidates.length)
 
     if (snapshotCandidates.length > 0) {
-      // New snapshot-based flow (6.3+): verify no data was written between
-      // the target snapshot and its active VDI.
-      let targetVmRef
-      let canChainToTargetVm = true
-      await asyncEach(
-        snapshotCandidates,
-        async snapshot => {
-          let diffDisk
-          let activeVdi
-          try {
-            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 })
-              // shared vdi ignore
-              return
-            }
-            const vm = userVbds[0].$VM
-            if (!('start' in vm.blocked_operations)) {
-              debug('checkBaseVdis, vm not blocked', { vmRef: vm.$ref })
-              // vm start unlocked
-              // not really an issue since we have check the delta
-              // but it indicates the users played with the blocked operations
-              return
-            }
-            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]
-              if (sourceUuid) {
-                this.#baseVdisBySourceUuid.set(sourceUuid, activeVdi)
-              }
-              // Track the target VM (the replicated VM to update on the next transfer).
-              targetVmRef = vm.$ref
-            } else {
-              // not empty, we will create a new VM
-              canChainToTargetVm = false
-              debug('checkBaseVdis, data between snapshot and active disk', {
-                vdiRef: snapshot.$ref,
-                nbBlocks: diffDisk.getBlockIndexes().length,
-              })
-            }
-          } catch (error) {
-            debug('checkBaseVdis, skipping snapshot', { ref: snapshot.$ref, error })
-            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)
-            }
-          }
-        },
-        {
-          concurrency: 4,
-        }
-      )
-
-      if (canChainToTargetVm && targetVmRef !== undefined) {
-        debug('checkBaseVdis,got a valid vm target', targetVmRef)
+      // reset before searching for candidates
+      this.#baseVdisBySourceUuid = new Map()
+      this._targetVmRef = undefined
+      const { baseVdisBySourceUuid, targetVmRef } = await this.#validateSnapshotCandidates(snapshotCandidates)
+      for (const [sourceUuid, vdi] of baseVdisBySourceUuid) {
+        this.#baseVdisBySourceUuid.set(sourceUuid, vdi)
+      }
+      if (targetVmRef !== undefined) {
         this._targetVmRef = targetVmRef
       }
     } else {
@@ -145,26 +88,117 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       }
     }
   }
+  /**
+   * 6.3+ snapshot-based validation: for each snapshot candidate, check whether
+   * the active VDI has diverged from the snapshot. Returns a baseVdisBySourceUuid
+   * map and, when all disks are clean, the targetVmRef to reuse.
+   */
+  async #validateSnapshotCandidates(snapshotCandidates) {
+    const sr = this._sr
+    const baseVdisBySourceUuid = new Map()
+    let targetVmRef
+    let canChainToTargetVm = true
+
+    await asyncEach(
+      snapshotCandidates,
+      async snapshot => {
+        let diffDisk
+        let activeVdi
+        try {
+          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, shared vbd ', { ref: snapshot.$ref, userVbds })
+            // shared vdi ignore
+            return
+          }
+          const vm = userVbds[0].$VM
+          if (!('start' in vm.blocked_operations)) {
+            debug('checkBaseVdis, vm not blocked', { vmRef: vm.$ref })
+            // vm start unlocked
+            // not really an issue since we have check the delta
+            // but it indicates the users played with the blocked operations
+            return
+          }
+          diffDisk = new XapiDiskSource({
+            xapi: sr.$xapi,
+            vdiRef: activeVdi.$ref,
+            baseRef: snapshot.$ref,
+            onlyListChangedBlocks: true,
+          })
+          await diffDisk.init()
+          const sourceUuid = snapshot.other_config?.[COPY_OF]
+          if (diffDisk.getBlockIndexes().length === 0) {
+            // no block modification since the common snapshot, we can chain VM and disk
+            if (sourceUuid) {
+              baseVdisBySourceUuid.set(sourceUuid, activeVdi)
+            }
+            // Track the target VM (the replicated VM to update on the next transfer).
+            targetVmRef = vm.$ref
+          } else {
+            if (sourceUuid) {
+              baseVdisBySourceUuid.set(sourceUuid, snapshot)
+            }
+            // there are changed block since the snapshot
+            // we can reuse it to transfer a delta, but we will
+            // create a new VM
+            canChainToTargetVm = false
+            debug('checkBaseVdis, data between snapshot and active disk', {
+              vdiRef: snapshot.$ref,
+              nbBlocks: diffDisk.getBlockIndexes().length,
+            })
+          }
+        } catch (error) {
+          debug('checkBaseVdis, skipping snapshot', { ref: snapshot.$ref, error })
+          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)
+          }
+        }
+      },
+      {
+        concurrency: 4,
+      }
+    )
+
+    if (!canChainToTargetVm) {
+      // if at least one disk has new data, create a new VM
+      // instead of updating it
+      targetVmRef = undefined
+    } else if (targetVmRef !== undefined) {
+      debug('checkBaseVdis,got a valid vm target', targetVmRef)
+    }
+
+    return { baseVdisBySourceUuid, targetVmRef }
+  }
+
   updateUuidAndChain() {
     // nothing to do, the chaining is not modified in this case
   }
   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) {
@@ -265,7 +299,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,
       })
@@ -289,7 +323,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

@@ -222,6 +222,7 @@ export class MergeRemoteDisk {
     await this.#mergeBlocks(parentDisk, childDisk)
     await parentDisk.flushMetadata(childDisk)
     await parentDisk.mergeMetadata(childDisk)
+    this.#state.diskSize = parentDisk.getSizeOnDisk()
   }
 
   /**
@@ -266,8 +267,6 @@ export class MergeRemoteDisk {
 
     await this.#writeState()
 
-    this.#state.diskSize = childDisk.getSizeOnDisk()
-
     this.#onProgress({ total: nBlocks, done: nBlocks })
   }
 

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.71.3",
+  "version": "0.72.1",
   "engines": {
     "node": ">=14.18"
   },
@@ -20,21 +20,22 @@
   "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",
@@ -42,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",
@@ -52,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": {
@@ -63,7 +64,7 @@
     "tmp": "^0.2.1"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^8.7.1"
+    "@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