WiP

.eslintrc.js

@@ -65,11 +65,10 @@ module.exports = {
           typescript: true,
           'eslint-import-resolver-custom-alias': {
             alias: {
-              '@core': '../web-core/lib',
               '@': './src',
             },
             extensions: ['.ts'],
-            packages: ['@xen-orchestra/lite', '@xen-orchestra/web'],
+            packages: ['@xen-orchestra/lite'],
           },
         },
       },

@xen-orchestra/backups/ImportVmBackup.mjs

@@ -160,10 +160,10 @@ export class ImportVmBackup {
           // update the stream with the negative vhd stream
           stream = await negativeVhd.stream()
           vdis[vdiRef].baseVdi = snapshotCandidate
-        } catch (error) {
+        } catch (err) {
           // can be a broken VHD chain, a vhd chain with a key backup, ....
           // not an irrecuperable error, don't dispose parentVhd, and fallback to full restore
-          warn(`can't use differential restore`, { error })
+          warn(`can't use differential restore`, err)
           disposableDescendants?.dispose()
         }
       }

@xen-orchestra/backups/RemoteAdapter.mjs

@@ -191,14 +191,13 @@ export class RemoteAdapter {
   // check if we will be allowed to merge a a vhd created in this adapter
   // with the vhd at path `path`
   async isMergeableParent(packedParentUid, path) {
-    return await Disposable.use(VhdSynthetic.fromVhdChain(this.handler, path), vhd => {
+    return await Disposable.use(openVhd(this.handler, path), vhd => {
       // this baseUuid is not linked with this vhd
       if (!vhd.footer.uuid.equals(packedParentUid)) {
         return false
       }
 
-      // check if all the chain is composed of vhd directory
-      const isVhdDirectory = vhd.checkVhdsClass(VhdDirectory)
+      const isVhdDirectory = vhd instanceof VhdDirectory
       return isVhdDirectory
         ? this.useVhdDirectory() && this.#getCompressionType() === vhd.compressionType
         : !this.useVhdDirectory()

@xen-orchestra/backups/_runners/_vmRunners/IncrementalRemote.mjs

@@ -2,7 +2,6 @@ import { asyncEach } from '@vates/async-each'
 import { decorateMethodsWith } from '@vates/decorate-with'
 import { defer } from 'golike-defer'
 import assert from 'node:assert'
-import * as UUID from 'uuid'
 import isVhdDifferencingDisk from 'vhd-lib/isVhdDifferencingDisk.js'
 import mapValues from 'lodash/mapValues.js'
 
@@ -10,48 +9,11 @@ import { AbstractRemote } from './_AbstractRemote.mjs'
 import { forkDeltaExport } from './_forkDeltaExport.mjs'
 import { IncrementalRemoteWriter } from '../_writers/IncrementalRemoteWriter.mjs'
 import { Task } from '../../Task.mjs'
-import { Disposable } from 'promise-toolbox'
-import { openVhd } from 'vhd-lib'
-import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
 
 class IncrementalRemoteVmBackupRunner extends AbstractRemote {
   _getRemoteWriter() {
     return IncrementalRemoteWriter
   }
-  async _selectBaseVm(metadata) {
-    // for each disk , get the parent
-    const baseUuidToSrcVdi = new Map()
-
-    // no previous backup for a base( =key) backup
-    if (metadata.isBase) {
-      return
-    }
-    await asyncEach(Object.entries(metadata.vdis), async ([id, vdi]) => {
-      const isDifferencing = metadata.isVhdDifferencing[`${id}.vhd`]
-      if (isDifferencing) {
-        const vmDir = getVmBackupDir(metadata.vm.uuid)
-        const path = `${vmDir}/${metadata.vhds[id]}`
-        // don't catch error : we can't recover if the source vhd are missing
-        await Disposable.use(openVhd(this._sourceRemoteAdapter._handler, path), vhd => {
-          baseUuidToSrcVdi.set(UUID.stringify(vhd.header.parentUuid), vdi.$snapshot_of$uuid)
-        })
-      }
-    })
-
-    const presentBaseVdis = new Map(baseUuidToSrcVdi)
-    await this._callWriters(
-      writer => presentBaseVdis.size !== 0 && writer.checkBaseVdis(presentBaseVdis),
-      'writer.checkBaseVdis()',
-      false
-    )
-    // check if the parent vdi are present in all the remotes
-    baseUuidToSrcVdi.forEach((srcVdiUuid, baseUuid) => {
-      if (!presentBaseVdis.has(baseUuid)) {
-        throw new Error(`Missing vdi ${baseUuid} which is a base for a delta`)
-      }
-    })
-    // yeah , let's go
-  }
   async _run($defer) {
     const transferList = await this._computeTransferList(({ mode }) => mode === 'delta')
     await this._callWriters(async writer => {
@@ -64,7 +26,7 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
     if (transferList.length > 0) {
       for (const metadata of transferList) {
         assert.strictEqual(metadata.mode, 'delta')
-        await this._selectBaseVm(metadata)
+
         await this._callWriters(writer => writer.prepare({ isBase: metadata.isBase }), 'writer.prepare()')
         const incrementalExport = await this._sourceRemoteAdapter.readIncrementalVmBackup(metadata, undefined, {
           useChain: false,
@@ -88,17 +50,6 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
             }),
           'writer.transfer()'
         )
-        // this will update parent name with the needed alias
-        await this._callWriters(
-          writer =>
-            writer.updateUuidAndChain({
-              isVhdDifferencing,
-              timestamp: metadata.timestamp,
-              vdis: incrementalExport.vdis,
-            }),
-          'writer.updateUuidAndChain()'
-        )
-
         await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
         // for healthcheck
         this._tags = metadata.vm.tags

@xen-orchestra/backups/_runners/_vmRunners/IncrementalXapi.mjs

@@ -78,18 +78,6 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
       'writer.transfer()'
     )
 
-    // we want to control the uuid of the vhd in the chain
-    // and ensure they are correctly chained
-    await this._callWriters(
-      writer =>
-        writer.updateUuidAndChain({
-          isVhdDifferencing,
-          timestamp,
-          vdis: deltaExport.vdis,
-        }),
-      'writer.updateUuidAndChain()'
-    )
-
     this._baseVm = exportedVm
 
     if (baseVm !== undefined) {
@@ -145,7 +133,7 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
       ])
       const srcVdi = srcVdis[snapshotOf]
       if (srcVdi !== undefined) {
-        baseUuidToSrcVdi.set(baseUuid, srcVdi.uuid)
+        baseUuidToSrcVdi.set(baseUuid, srcVdi)
       } else {
         debug('ignore snapshot VDI because no longer present on VM', {
           vdi: baseUuid,
@@ -166,18 +154,18 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
     }
 
     const fullVdisRequired = new Set()
-    baseUuidToSrcVdi.forEach((srcVdiUuid, baseUuid) => {
+    baseUuidToSrcVdi.forEach((srcVdi, baseUuid) => {
       if (presentBaseVdis.has(baseUuid)) {
         debug('found base VDI', {
           base: baseUuid,
-          vdi: srcVdiUuid,
+          vdi: srcVdi.uuid,
         })
       } else {
         debug('missing base VDI', {
           base: baseUuid,
-          vdi: srcVdiUuid,
+          vdi: srcVdi.uuid,
         })
-        fullVdisRequired.add(srcVdiUuid)
+        fullVdisRequired.add(srcVdi.uuid)
       }
     })
 

@xen-orchestra/backups/_runners/_writers/IncrementalRemoteWriter.mjs

@@ -1,15 +1,17 @@
 import assert from 'node:assert'
 import mapValues from 'lodash/mapValues.js'
+import ignoreErrors from 'promise-toolbox/ignoreErrors'
 import { asyncEach } from '@vates/async-each'
 import { asyncMap } from '@xen-orchestra/async-map'
-import { chainVhd, openVhd } from 'vhd-lib'
+import { chainVhd, checkVhdChain, openVhd, VhdAbstract } from 'vhd-lib'
 import { createLogger } from '@xen-orchestra/log'
 import { decorateClass } from '@vates/decorate-with'
 import { defer } from 'golike-defer'
-import { dirname, basename } from 'node:path'
+import { dirname } from 'node:path'
 
 import { formatFilenameDate } from '../../_filenameDate.mjs'
 import { getOldEntries } from '../../_getOldEntries.mjs'
+import { TAG_BASE_DELTA } from '../../_incrementalVm.mjs'
 import { Task } from '../../Task.mjs'
 
 import { MixinRemoteWriter } from './_MixinRemoteWriter.mjs'
@@ -21,45 +23,42 @@ import { Disposable } from 'promise-toolbox'
 const { warn } = createLogger('xo:backups:DeltaBackupWriter')
 
 export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWriter) {
-  #parentVdiPaths
-  #vhds
   async checkBaseVdis(baseUuidToSrcVdi) {
-    this.#parentVdiPaths = {}
     const { handler } = this._adapter
     const adapter = this._adapter
 
     const vdisDir = `${this._vmBackupDir}/vdis/${this._job.id}`
 
-    await asyncMap(baseUuidToSrcVdi, async ([baseUuid, srcVdiUuid]) => {
-      let parentDestPath
-      const vhdDir = `${vdisDir}/${srcVdiUuid}`
+    await asyncMap(baseUuidToSrcVdi, async ([baseUuid, srcVdi]) => {
+      let found = false
       try {
-        const vhds = await handler.list(vhdDir, {
+        const vhds = await handler.list(`${vdisDir}/${srcVdi.uuid}`, {
           filter: _ => _[0] !== '.' && _.endsWith('.vhd'),
           ignoreMissing: true,
           prependDir: true,
         })
         const packedBaseUuid = packUuid(baseUuid)
-        // the last one is probably the right one
-
-        for (let i = vhds.length - 1; i >= 0 && parentDestPath === undefined; i--) {
-          const path = vhds[i]
+        await asyncMap(vhds, async path => {
           try {
-            if (await adapter.isMergeableParent(packedBaseUuid, path)) {
-              parentDestPath = path
-            }
+            await checkVhdChain(handler, path)
+            // Warning, this should not be written as found = found || await adapter.isMergeableParent(packedBaseUuid, path)
+            //
+            // since all the checks of a path are done in parallel, found would be containing
+            // only the last answer of isMergeableParent which is probably not the right one
+            // this led to the support tickets  https://help.vates.fr/#ticket/zoom/4751 , 4729, 4665 and 4300
+
+            const isMergeable = await adapter.isMergeableParent(packedBaseUuid, path)
+            found = found || isMergeable
           } catch (error) {
             warn('checkBaseVdis', { error })
+            await ignoreErrors.call(VhdAbstract.unlink(handler, path))
           }
-        }
+        })
       } catch (error) {
         warn('checkBaseVdis', { error })
       }
-      // no usable parent => the runner will have to decide to fall back to a full or stop backup
-      if (parentDestPath === undefined) {
+      if (!found) {
         baseUuidToSrcVdi.delete(baseUuid)
-      } else {
-        this.#parentVdiPaths[vhdDir] = parentDestPath
       }
     })
   }
@@ -124,44 +123,6 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
     }
   }
 
-  async updateUuidAndChain({ isVhdDifferencing, vdis }) {
-    assert.notStrictEqual(
-      this.#vhds,
-      undefined,
-      '_transfer must be called before updateUuidAndChain for incremental backups'
-    )
-
-    const parentVdiPaths = this.#parentVdiPaths
-    const { handler } = this._adapter
-    const vhds = this.#vhds
-    await asyncEach(Object.entries(vdis), async ([id, vdi]) => {
-      const isDifferencing = isVhdDifferencing[`${id}.vhd`]
-      const path = `${this._vmBackupDir}/${vhds[id]}`
-      if (isDifferencing) {
-        assert.notStrictEqual(
-          parentVdiPaths,
-          'checkbasevdi must be called before updateUuidAndChain for incremental backups'
-        )
-        const parentPath = parentVdiPaths[dirname(path)]
-        // we are in a incremental backup
-        // we already computed the chain in checkBaseVdis
-        assert.notStrictEqual(parentPath, undefined, 'A differential VHD must have a parent')
-        // forbid any kind of loop
-        assert.ok(basename(parentPath) < basename(path), `vhd must be sorted to be chained`)
-        await chainVhd(handler, parentPath, handler, path)
-      }
-
-      // set the correct UUID in the VHD if needed
-      await Disposable.use(openVhd(handler, path), async vhd => {
-        if (!vhd.footer.uuid.equals(packUuid(vdi.uuid))) {
-          vhd.footer.uuid = packUuid(vdi.uuid)
-          await vhd.readBlockAllocationTable() // required by writeFooter()
-          await vhd.writeFooter()
-        }
-      })
-    })
-  }
-
   async _deleteOldEntries() {
     const adapter = this._adapter
     const oldEntries = this._oldEntries
@@ -180,10 +141,14 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
     const jobId = job.id
     const handler = adapter.handler
 
+    let metadataContent = await this._isAlreadyTransferred(timestamp)
+    if (metadataContent !== undefined) {
+      // @todo : should skip backup while being vigilant to not stuck the forked stream
+      Task.info('This backup has already been transfered')
+    }
+
     const basename = formatFilenameDate(timestamp)
-    // update this.#vhds before eventually skipping transfer, so that
-    // updateUuidAndChain has all the mandatory data
-    const vhds = (this.#vhds = mapValues(
+    const vhds = mapValues(
       deltaExport.vdis,
       vdi =>
         `vdis/${jobId}/${
@@ -193,15 +158,7 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
               vdi.uuid
             : vdi.$snapshot_of$uuid
         }/${adapter.getVhdFileName(basename)}`
-    ))
-
-    let metadataContent = await this._isAlreadyTransferred(timestamp)
-    if (metadataContent !== undefined) {
-      // skip backup while being vigilant to not stuck the forked stream
-      Task.info('This backup has already been transfered')
-      Object.values(deltaExport.streams).forEach(stream => stream.destroy())
-      return { size: 0 }
-    }
+    )
 
     metadataContent = {
       isVhdDifferencing,
@@ -217,13 +174,38 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
       vm,
       vmSnapshot,
     }
-
     const { size } = await Task.run({ name: 'transfer' }, async () => {
       let transferSize = 0
       await asyncEach(
-        Object.keys(deltaExport.vdis),
-        async id => {
+        Object.entries(deltaExport.vdis),
+        async ([id, vdi]) => {
           const path = `${this._vmBackupDir}/${vhds[id]}`
+
+          const isDifferencing = isVhdDifferencing[`${id}.vhd`]
+          let parentPath
+          if (isDifferencing) {
+            const vdiDir = dirname(path)
+            parentPath = (
+              await handler.list(vdiDir, {
+                filter: filename => filename[0] !== '.' && filename.endsWith('.vhd'),
+                prependDir: true,
+              })
+            )
+              .sort()
+              .pop()
+
+            assert.notStrictEqual(
+              parentPath,
+              undefined,
+              `missing parent of ${id} in ${dirname(path)}, looking for ${vdi.other_config[TAG_BASE_DELTA]}`
+            )
+
+            parentPath = parentPath.slice(1) // remove leading slash
+
+            // TODO remove when this has been done before the export
+            await checkVhd(handler, parentPath)
+          }
+
           // don't write it as transferSize += await async function
           // since i += await asyncFun lead to race condition
           // as explained : https://eslint.org/docs/latest/rules/require-atomic-updates
@@ -235,6 +217,17 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
             writeBlockConcurrency: this._config.writeBlockConcurrency,
           })
           transferSize += transferSizeOneDisk
+
+          if (isDifferencing) {
+            await chainVhd(handler, parentPath, handler, path)
+          }
+
+          // set the correct UUID in the VHD
+          await Disposable.use(openVhd(handler, path), async vhd => {
+            vhd.footer.uuid = packUuid(vdi.uuid)
+            await vhd.readBlockAllocationTable() // required by writeFooter()
+            await vhd.writeFooter()
+          })
         },
         {
           concurrency: settings.diskPerVmConcurrency,

@xen-orchestra/backups/_runners/_writers/IncrementalXapiWriter.mjs

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import { asyncMap, asyncMapSettled } from '@xen-orchestra/async-map'
 import ignoreErrors from 'promise-toolbox/ignoreErrors'
 import { formatDateTime } from '@xen-orchestra/xapi'
@@ -15,7 +14,6 @@ import find from 'lodash/find.js'
 
 export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
   async checkBaseVdis(baseUuidToSrcVdi, baseVm) {
-    assert.notStrictEqual(baseVm, undefined)
     const sr = this._sr
     const replicatedVm = listReplicatedVms(sr.$xapi, this._job.id, sr.uuid, this._vmUuid).find(
       vm => vm.other_config[TAG_COPY_SRC] === baseVm.uuid
@@ -38,9 +36,7 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
       }
     }
   }
-  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({

@xen-orchestra/backups/_runners/_writers/_AbstractIncrementalWriter.mjs

@@ -5,10 +5,6 @@ export class AbstractIncrementalWriter extends AbstractWriter {
     throw new Error('Not implemented')
   }
 
-  updateUuidAndChain() {
-    throw new Error('Not implemented')
-  }
-
   cleanup() {
     throw new Error('Not implemented')
   }

@xen-orchestra/backups/_runners/_writers/_MixinRemoteWriter.mjs

@@ -113,13 +113,13 @@ export const MixinRemoteWriter = (BaseClass = Object) =>
       )
     }
 
-    async _isAlreadyTransferred(timestamp) {
+    _isAlreadyTransferred(timestamp) {
       const vmUuid = this._vmUuid
       const adapter = this._adapter
       const backupDir = getVmBackupDir(vmUuid)
       try {
         const actualMetadata = JSON.parse(
-          await adapter._handler.readFile(`${backupDir}/${formatFilenameDate(timestamp)}.json`)
+          adapter._handler.readFile(`${backupDir}/${formatFilenameDate(timestamp)}.json`)
         )
         return actualMetadata
       } catch (error) {}

@xen-orchestra/backups/docs/VM backups/README.md

@@ -230,7 +230,6 @@ Settings are described in [`@xen-orchestra/backups/\_runners/VmsXapi.mjs``](http
     - `checkBaseVdis(baseUuidToSrcVdi, baseVm)`
     - `prepare({ isFull })`
     - `transfer({ timestamp, deltaExport, sizeContainers })`
-    - `updateUuidAndChain({ isVhdDifferencing, vdis })`
     - `cleanup()`
     - `healthCheck()` // is not executed if no health check sr or tag doesn't match
   - **Full**

@xen-orchestra/fs/src/path.js

@@ -20,7 +20,5 @@ export function split(path) {
   return parts
 }
 
-// paths are made absolute otherwise fs.relative() would resolve them against working directory
-export const relativeFromFile = (file, path) => relative(dirname(normalize(file)), normalize(path))
-
+export const relativeFromFile = (file, path) => relative(dirname(file), path)
 export const resolveFromFile = (file, path) => resolve('/', dirname(file), path).slice(1)

@xen-orchestra/fs/src/path.test.js

@@ -1,17 +0,0 @@
-import { describe, it } from 'test'
-import { strict as assert } from 'assert'
-
-import { relativeFromFile } from './path.js'
-
-describe('relativeFromFile()', function () {
-  for (const [title, args] of Object.entries({
-    'file absolute and path absolute': ['/foo/bar/file.vhd', '/foo/baz/path.vhd'],
-    'file relative and path absolute': ['foo/bar/file.vhd', '/foo/baz/path.vhd'],
-    'file absolute and path relative': ['/foo/bar/file.vhd', 'foo/baz/path.vhd'],
-    'file relative and path relative': ['foo/bar/file.vhd', 'foo/baz/path.vhd'],
-  })) {
-    it('works with ' + title, function () {
-      assert.equal(relativeFromFile(...args), '../baz/path.vhd')
-    })
-  }
-})

@xen-orchestra/immutable-backups/protectRemotes.mjs

@@ -54,10 +54,10 @@ async function handleExistingFile(root, indexPath, path) {
         await indexFile(fullPath, indexPath)
       }
     }
-  } catch (error) {
-    if (error.code !== 'EEXIST') {
+  } catch (err) {
+    if (err.code !== 'EEXIST') {
       // there can be a symbolic link in the tree
-      warn('handleExistingFile', { error })
+      warn('handleExistingFile', err)
     }
   }
 }
@@ -106,7 +106,7 @@ export async function watchRemote(remoteId, { root, immutabilityDuration, rebuil
     await File.liftImmutability(settingPath)
   } catch (error) {
     // file may not exists, and it's not really a problem
-    info('lifting immutability on current settings', { error })
+    info('lifting immutability on current settings', error)
   }
   await fs.writeFile(
     settingPath,

@xen-orchestra/lite/src/libs/xapi-stats.ts

@@ -50,17 +50,7 @@ const RRD_POINTS_PER_STEP: { [key in RRD_STEP]: number } = {
 // Utils
 // -------------------------------------------------------------------
 
-function parseNumber(value: number | string) {
-  // Starting from XAPI 23.31, numbers in the JSON payload are encoded as
-  // strings to support NaN, Infinity and -Infinity
-  if (typeof value === 'string') {
-    const asNumber = +value
-    if (isNaN(asNumber) && value !== 'NaN') {
-      throw new Error('cannot parse number: ' + value)
-    }
-    value = asNumber
-  }
-
+function convertNanToNull(value: number) {
   return isNaN(value) ? null : value
 }
 
@@ -69,7 +59,7 @@ function parseNumber(value: number | string) {
 // -------------------------------------------------------------------
 
 const computeValues = (dataRow: any, legendIndex: number, transformValue = identity) =>
-  map(dataRow, ({ values }) => transformValue(parseNumber(values[legendIndex])))
+  map(dataRow, ({ values }) => transformValue(convertNanToNull(values[legendIndex])))
 
 const createGetProperty = (obj: object, property: string, defaultValue: unknown) =>
   defaults(obj, { [property]: defaultValue })[property] as any
@@ -329,14 +319,8 @@ export default class XapiStats {
       },
       abortSignal,
     })
-    const text = await resp.text()
-    try {
-      // starting from XAPI 23.31, the response is valid JSON
-      return JSON.parse(text)
-    } catch (error) {
-      // eslint-disable-next-line import/no-named-as-default-member -- https://github.com/json5/json5/issues/287
-      return JSON5.parse(text)
-    }
+    // eslint-disable-next-line import/no-named-as-default-member -- https://github.com/json5/json5/issues/287
+    return JSON5.parse(await resp.text())
   }
 
   // To avoid multiple requests, we keep a cache for the stats and
@@ -399,10 +383,7 @@ export default class XapiStats {
         abortSignal,
       })
 
-      const actualStep = parseNumber(json.meta.step)
-      if (actualStep !== step) {
-        throw new FaultyGranularity(`Unable to get the true granularity: ${actualStep}`)
-      }
+      const actualStep = json.meta.step as number
 
       if (json.data.length > 0) {
         // fetched data is organized from the newest to the oldest
@@ -426,15 +407,14 @@ export default class XapiStats {
 
           let stepStats = xoObjectStats[actualStep]
           let cacheStepStats = cacheXoObjectStats[actualStep]
-          const endTimestamp = parseNumber(json.meta.end)
-          if (stepStats === undefined || stepStats.endTimestamp !== endTimestamp) {
+          if (stepStats === undefined || stepStats.endTimestamp !== json.meta.end) {
             stepStats = xoObjectStats[actualStep] = {
-              endTimestamp,
+              endTimestamp: json.meta.end,
               interval: actualStep,
               canBeExpired: false,
             }
             cacheStepStats = cacheXoObjectStats[actualStep] = {
-              endTimestamp,
+              endTimestamp: json.meta.end,
               interval: actualStep,
               canBeExpired: true,
             }
@@ -458,6 +438,10 @@ export default class XapiStats {
           })
         })
       }
+
+      if (actualStep !== step) {
+        throw new FaultyGranularity(`Unable to get the true granularity: ${actualStep}`)
+      }
     } catch (error) {
       if (error instanceof Error && error.name === 'AbortError') {
         return

@xen-orchestra/lite/tsconfig.app.json

@@ -1,15 +1,13 @@
 {
   "extends": "@vue/tsconfig/tsconfig.dom.json",
-  "include": ["env.d.ts", "src/**/*", "src/**/*.vue", "../web-core/lib/**/*", "../web-core/lib/**/*.vue"],
+  "include": ["env.d.ts", "src/**/*", "src/**/*.vue"],
   "exclude": ["src/**/__tests__/*"],
   "compilerOptions": {
     "composite": true,
     "noEmit": true,
     "baseUrl": ".",
-    "rootDir": "..",
     "paths": {
-      "@/*": ["./src/*"],
-      "@core/*": ["../web-core/lib/*"]
+      "@/*": ["./src/*"]
     }
   }
 }

@xen-orchestra/lite/vite.config.ts

@@ -23,7 +23,6 @@ export default defineConfig({
   resolve: {
     alias: {
       '@': fileURLToPath(new URL('./src', import.meta.url)),
-      '@core': fileURLToPath(new URL('../web-core/lib', import.meta.url)),
     },
   },
 

@xen-orchestra/log/.USAGE.md

@@ -27,16 +27,6 @@ log.error('could not join server', {
 })
 ```
 
-A logging method has the following signature:
-
-```ts
-interface LoggingMethod {
-  (error): void
-
-  (message: string, data?: { error?: Error; [property: string]: any }): void
-}
-```
-
 ### Consumer
 
 Then, at application level, configure the logs are handled:

@xen-orchestra/log/README.md

@@ -45,16 +45,6 @@ log.error('could not join server', {
 })
 ```
 
-A logging method has the following signature:
-
-```ts
-interface LoggingMethod {
-  (error): void
-
-  (message: string, data?: { error?: Error; [property: string]: any }): void
-}
-```
-
 ### Consumer
 
 Then, at application level, configure the logs are handled:

@xen-orchestra/web-core/docs/composables/context.composable.md

@@ -1,158 +0,0 @@
-<!-- TOC -->
-
-- [Overview](#overview)
-  - [Simple Context](#simple-context)
-    - [1. Create the context](#1-create-the-context)
-    - [2. Use the context](#2-use-the-context)
-      - [2.1. Read](#21-read)
-      - [2.2. Update](#22-update)
-  - [Advanced Context](#advanced-context)
-    - [1. Create the context](#1-create-the-context-1)
-    - [2. Use the context](#2-use-the-context-1)
-      - [2.1. Read](#21-read-1)
-      - [2.2. Update](#22-update-1)
-  - [Caveats (boolean props)](#caveats-boolean-props)
-  <!-- TOC -->
-
-# Overview
-
-`createContext` lets you create a context that is both readable and writable, and is accessible by a component and all
-its descendants at any depth.
-
-Each descendant has the ability to change the context value, affecting itself and all of its descendants at any level.
-
-## Simple Context
-
-### 1. Create the context
-
-`createContext` takes the initial context value as first argument.
-
-```ts
-// context.ts
-
-const CounterContext = createContext(0)
-```
-
-### 2. Use the context
-
-#### 2.1. Read
-
-You can get the current Context value by using `useContext(CounterContext)`.
-
-```ts
-const counter = useContext(CounterContext)
-
-console.log(counter.value) // 0
-```
-
-#### 2.2. Update
-
-You can pass a `MaybeRefOrGetter` as second argument to update the context value.
-
-```ts
-// MyComponent.vue
-
-const props = defineProps<{
-  counter?: number
-}>()
-
-const counter = useContext(CounterContext, () => props.counter)
-
-// When calling <MyComponent />
-console.log(counter.value) // 0
-
-// When calling <MyComponent :counter="20" />
-console.log(counter.value) // 20
-```
-
-## Advanced Context
-
-To customize the context output, you can pass a custom context builder as the second argument of `createContext`.
-
-### 1. Create the context
-
-```ts
-// context.ts
-
-// Example 1. Return a object
-const CounterContext = createContext(10, counter => ({
-  counter,
-  isEven: computed(() => counter.value % 2 === 0),
-}))
-
-// Example 2. Return a computed value
-const DoubleContext = createContext(10, num => computed(() => num.value * 2))
-
-// Example 3. Use a previous value
-const ColorContext = createContext('info' as Color, (color, previousColor) => ({
-  name: color,
-  colorContextClass: computed(() => (previousColor.value === color.value ? undefined : `color-context-${color.value}`)),
-}))
-```
-
-### 2. Use the context
-
-#### 2.1. Read
-
-When using the context, it will return your custom value.
-
-```ts
-const { counter, isEven } = useContext(CounterContext)
-const double = useContext(DoubleContext)
-
-console.log(counter.value) // 10
-console.log(isEven.value) // true
-console.log(double.value) // 20
-```
-
-#### 2.2. Update
-
-Same as with a simple context, you can pass a `MaybeRefOrGetter` as second argument.
-
-```ts
-// Parent.vue
-useContext(CounterContext, 99)
-useContext(DoubleContext, 99)
-
-// Child.vue
-const { isEven } = useContext(CounterContext)
-const double = useContext(DoubleContext)
-
-console.log(isEven.value) // false
-console.log(double.value) // 198
-```
-
-## Caveats (boolean props)
-
-When working with `boolean` props, there's an important caveat to be aware of.
-
-If the `MaybeRefOrGetter` returns any other value than `undefined`, the context will be updated according to this value.
-
-This could be problematic if the value comes from a `boolean` prop.
-
-```ts
-const props = defineProps<{
-  disabled?: boolean
-}>()
-
-useContext(MyBooleanContext, () => props.disabled) // Update to `false` if `undefined`
-```
-
-In that case, Vue will automatically set the default value for `disabled` prop to `false`.
-
-Even if the `disabled` prop in not provided at all, the current context will not be used and will be replaced
-by `false`.
-
-To circumvent this issue, you need to use `withDefaults` and specifically set the default value for `boolean` props
-to `undefined`:
-
-```ts
-const props = withDefaults(
-  defineProps<{
-    disabled?: boolean
-  }>(),
-  { disabled: undefined }
-)
-
-useContext(MyBoolean, () => props.disabled) // Keep parent value if `undefined`
-```

@xen-orchestra/web-core/docs/contexts/color-context.md

@@ -1,142 +0,0 @@
-<!-- TOC -->
-
-- [Overview](#overview)
-  - [CSS variables](#css-variables)
-  - [Available color contexts](#available-color-contexts)
-  - [Usage](#usage)
-  <!-- TOC -->
-
-# Overview
-
-The color context provides a way to apply a set of colors variants to a component and all its descendants at any depth.
-
-Each descendant has the ability to change the context value, affecting itself and all of its descendants at any level.
-
-The purpose is to colorize a component and its descendants by applying a single CSS class on the parent component (e.g., applying the class on a modal component container will style all children components using the context).
-
-## CSS variables
-
-The color context relies on the usage of the following variables:
-
-```css
---color-context-primary;
---color-context-primary-hover;
---color-context-primary-active;
---color-context-primary-disabled;
-
---color-context-secondary;
---color-context-secondary-hover;
---color-context-secondary-active;
-
---color-context-tertiary;
-```
-
-Any component can use these variables for `color`, `background-color` or any other CSS property, to be usable with the color context.
-
-When you set a color context, the variables are updated with the help of CSS classes defined in `_context.pcss`:
-
-```css
-.color-context-info {
-  --color-context-primary: var(--color-purple-base);
-  --color-context-primary-hover: var(--color-purple-d20);
-  --color-context-primary-active: var(--color-purple-d40);
-  --color-context-primary-disabled: var(--color-grey-400);
-
-  --color-context-secondary: var(--background-color-purple-10);
-  --color-context-secondary-hover: var(--background-color-purple-20);
-  --color-context-secondary-active: var(--background-color-purple-30);
-}
-
-.color-context-success {
-  --color-context-primary: var(--color-green-base);
-  --color-context-primary-hover: var(--color-green-d20);
-  /*...*/
-}
-```
-
-You can add any other context by adding a `color-context-<my-context>` class and setting the desired values for the variables.
-
-**Important note: remember to set a value for all variables to avoid any missing styles.**
-
-## Available color contexts
-
-Color contexts rely on the type `Color` defined in `/lib/types/color.type.ts`:
-
-- `info` (_purple_)
-- `success` (_green_)
-- `warning` (_orange_)
-- `error` (_red_)
-
-## Usage
-
-To get and set the color context in a component, you can pass the `ColorContext` to `useContext` and apply the `colorContextClass` to the root component:
-
-```ts
-// ParentComponent.vue
-
-import { useContext } from '@core/composables/context.composable'
-import { ColorContext } from '@core/context'
-import type { Color } from '@core/types/color.type'
-import { defineProps } from 'vue'
-
-const props = defineProps<{
-  color?: Color
-}>()
-
-const { colorContextClass } = useContext(ColorContext, () => props.color)
-```
-
-All the components using the CSS variables will inherit the color context applied by the `colorContextClass`.
-It's possible to change the color of a component on demand, if the component has a `color` prop, and passing it as the second parameter of the composable.
-
-Then, the only thing to do is to apply the class in the component's `template`:
-
-```vue
-<!-- ParentComponent.vue -->
-
-<template>
-  <div :class="colorContextClass">
-    <!--  Will use the color context defined by the class above-->
-    <MyComponent />
-
-    <!--  Will use the color "info" instead of the context-->
-    <MyComponent color="info" />
-  </div>
-</template>
-```
-
-`MyComponent` using the context:
-
-```vue
-<!-- MyComponent.vue -->
-
-<template>
-  <div :class="colorContextClass" class="my-component">
-    <p>Lorem ipsum dolor sit amet.</p>
-  </div>
-</template>
-
-<script lang="ts" setup>
-import { useContext } from '@core/composables/context.composable'
-import { ColorContext } from '@core/context'
-import type { Color } from '@core/types/color.type'
-import { defineProps } from 'vue'
-
-const props = defineProps<{
-  color?: Color
-}>()
-
-const { colorContextClass } = useContext(ColorContext, () => props.color)
-</script>
-
-<style lang="postcss" scoped>
-.my-component {
-  background-color: var(--color-context-secondary);
-  color: var(--color-context-primary);
-}
-</style>
-```
-
-In the example above, if the `color` prop is not set, the component will use the color context (i.e., if its parent uses a `success` color context, `MyComponent` will be styled with the `success` colors defined in `_context.pcss`).
-
-If the `color` prop is set, the component will use the prop value to update the context for itself and its descendants.

@xen-orchestra/web-core/lib/assets/css/_context.pcss

@@ -45,55 +45,3 @@
 .context-border-color-info {
   border-color: var(--color-purple-base);
 }
-
-.color-context-info {
-  --color-context-primary: var(--color-purple-base);
-  --color-context-primary-hover: var(--color-purple-d20);
-  --color-context-primary-active: var(--color-purple-d40);
-  --color-context-primary-disabled: var(--color-grey-400);
-
-  --color-context-secondary: var(--background-color-purple-10);
-  --color-context-secondary-hover: var(--background-color-purple-20);
-  --color-context-secondary-active: var(--background-color-purple-30);
-
-  --color-context-tertiary: var(--background-color-primary);
-}
-
-.color-context-success {
-  --color-context-primary: var(--color-green-base);
-  --color-context-primary-hover: var(--color-green-d20);
-  --color-context-primary-active: var(--color-green-d40);
-  --color-context-primary-disabled: var(--color-green-l60);
-
-  --color-context-secondary: var(--background-color-green-10);
-  --color-context-secondary-hover: var(--background-color-green-20);
-  --color-context-secondary-active: var(--background-color-green-30);
-
-  --color-context-tertiary: var(--background-color-primary);
-}
-
-.color-context-warning {
-  --color-context-primary: var(--color-orange-base);
-  --color-context-primary-hover: var(--color-orange-d20);
-  --color-context-primary-active: var(--color-orange-d40);
-  --color-context-primary-disabled: var(--color-orange-l60);
-
-  --color-context-secondary: var(--background-color-orange-10);
-  --color-context-secondary-hover: var(--background-color-orange-20);
-  --color-context-secondary-active: var(--background-color-orange-30);
-
-  --color-context-tertiary: var(--background-color-primary);
-}
-
-.color-context-error {
-  --color-context-primary: var(--color-red-base);
-  --color-context-primary-hover: var(--color-red-d20);
-  --color-context-primary-active: var(--color-red-d40);
-  --color-context-primary-disabled: var(--color-red-l60);
-
-  --color-context-secondary: var(--background-color-red-10);
-  --color-context-secondary-hover: var(--background-color-red-20);
-  --color-context-secondary-active: var(--background-color-red-30);
-
-  --color-context-tertiary: var(--background-color-primary);
-}

@xen-orchestra/web-core/lib/composables/context.composable.ts

@@ -1,34 +0,0 @@
-import type { ComputedRef, InjectionKey, MaybeRefOrGetter } from 'vue'
-import { computed, inject, provide, toValue } from 'vue'
-
-export const createContext = <T, Output = ComputedRef<T>>(
-  initialValue: MaybeRefOrGetter<T>,
-  customBuilder?: (value: ComputedRef<T>, previousValue: ComputedRef<T>) => Output
-) => {
-  return {
-    id: Symbol('CONTEXT_ID') as InjectionKey<MaybeRefOrGetter<T>>,
-    initialValue,
-    builder: customBuilder ?? (value => value as Output),
-  }
-}
-
-type Context<T = any, Output = any> = ReturnType<typeof createContext<T, Output>>
-
-type ContextOutput<Ctx extends Context> = Ctx extends Context<any, infer Output> ? Output : never
-
-type ContextValue<Ctx extends Context> = Ctx extends Context<infer T> ? T : never
-
-export const useContext = <Ctx extends Context, T extends ContextValue<Ctx>>(
-  context: Ctx,
-  newValue?: MaybeRefOrGetter<T | undefined>
-): ContextOutput<Ctx> => {
-  const currentValue = inject(context.id, undefined)
-
-  const updatedValue = () => toValue(newValue) ?? toValue(currentValue) ?? context.initialValue
-  provide(context.id, updatedValue)
-
-  return context.builder(
-    computed(() => toValue(updatedValue)),
-    computed(() => toValue(currentValue))
-  )
-}

@xen-orchestra/web-core/lib/context.ts

@@ -1,8 +0,0 @@
-import { createContext } from '@core/composables/context.composable'
-import type { Color } from '@core/types/color.type'
-import { computed } from 'vue'
-
-export const ColorContext = createContext('info' as Color, (color, previousColor) => ({
-  name: color,
-  colorContextClass: computed(() => (previousColor.value === color.value ? undefined : `color-context-${color.value}`)),
-}))

@xen-orchestra/web-core/lib/types/color.type.ts

@@ -1 +0,0 @@
-export type Color = 'info' | 'error' | 'warning' | 'success'

@xen-orchestra/web-core/package.json

@@ -10,8 +10,7 @@
     }
   },
   "devDependencies": {
-    "vue": "^3.4.13",
-    "@vue/tsconfig": "^0.5.1"
+    "vue": "^3.4.13"
   },
   "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/web-core",
   "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
@@ -26,6 +25,6 @@
   },
   "license": "AGPL-3.0-or-later",
   "engines": {
-    "node": ">=18"
+    "node": ">=8.10"
   }
 }

@xen-orchestra/web-core/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "@vue/tsconfig/tsconfig.dom.json",
-  "include": ["env.d.ts", "lib/**/*", "lib/**/*.vue"],
-  "exclude": ["lib/**/__tests__/*"],
-  "compilerOptions": {
-    "noEmit": true,
-    "baseUrl": ".",
-    "paths": {
-      "@core/*": ["./lib/*"]
-    }
-  }
-}

@xen-orchestra/web/tsconfig.app.json

@@ -1,22 +1,13 @@
 {
   "extends": "@vue/tsconfig/tsconfig.dom.json",
-  "include": [
-    "env.d.ts",
-    "typed-router.d.ts",
-    "src/**/*",
-    "src/**/*.vue",
-    "../web-core/lib/**/*",
-    "../web-core/lib/**/*.vue"
-  ],
+  "include": ["env.d.ts", "typed-router.d.ts", "src/**/*", "src/**/*.vue"],
   "exclude": ["src/**/__tests__/*"],
   "compilerOptions": {
     "composite": true,
     "noEmit": true,
     "baseUrl": ".",
-    "rootDir": "..",
     "paths": {
-      "@/*": ["./src/*"],
-      "@core/*": ["../web-core/lib/*"]
+      "@/*": ["./src/*"]
     }
   }
 }

@xen-orchestra/web/vite.config.ts

@@ -11,7 +11,6 @@ export default defineConfig({
   resolve: {
     alias: {
       '@': fileURLToPath(new URL('./src', import.meta.url)),
-      '@core': fileURLToPath(new URL('../web-core/lib', import.meta.url)),
     },
   },
 })

@xen-orchestra/xapi/vif.mjs

@@ -21,23 +21,12 @@ export default class Vif {
       MAC = '',
     } = {}
   ) {
-    if (device === undefined) {
-      const allowedDevices = await this.call('VM.get_allowed_VIF_devices', VM)
-      if (allowedDevices.length === 0) {
-        const error = new Error('could not find an allowed VIF device')
-        error.poolUuid = this.pool.uuid
-        error.vmRef = VM
-        throw error
-      }
-
-      device = allowedDevices[0]
-    }
-
     const [powerState, ...rest] = await Promise.all([
       this.getField('VM', VM, 'power_state'),
-      MTU ?? this.getField('network', network, 'MTU'),
+      device ?? (await this.call('VM.get_allowed_VIF_devices', VM))[0],
+      MTU ?? (await this.getField('network', network, 'MTU')),
     ])
-    ;[MTU] = rest
+    ;[device, MTU] = rest
 
     const vifRef = await this.call('VIF.create', {
       currently_attached: powerState === 'Suspended' ? currently_attached : undefined,

@xen-orchestra/xapi/vm.mjs

@@ -399,6 +399,16 @@ class Vm {
     return ref
   }
 
+  async createFull($defer, { clone = true, boot = false, name_label, name_description, template: templateRef }) {
+    // Clones the template.
+    const vmRef = await (
+      clone
+        ? this.callAsync('VM.clone', templateRef, name_label)
+        : this.callAsync('VM.copy', templateRef, name_label, '')
+    ).then(extractOpaqueRef)
+    $defer.onFailure(() => this.VM_destroy(vmRef))
+  }
+
   async destroy(
     vmRef,
     { deleteDisks = true, force = false, bypassBlockedOperation = force, forceDeleteDefaultTemplate = force } = {}
@@ -699,6 +709,7 @@ export default Vm
 decorateClass(Vm, {
   checkpoint: defer,
   create: defer,
+  createFull: defer,
   export: defer,
   snapshot: defer,
 })

CHANGELOG.unreleased.md

@@ -8,11 +8,6 @@
 > Users must be able to say: “Nice enhancement, I'm eager to test it”
 
 - Disable search engine indexing via a `robots.txt`
-- [Stats] Support format used by XAPI 23.31
-- [REST API] Export host [SMT](https://en.wikipedia.org/wiki/Simultaneous_multithreading) status at `/hosts/:id/smt` [Forum#71374](https://xcp-ng.org/forum/post/71374)
-- [Home & REST API] `$container` field of an halted VM now points to a host if a VDI is on a local storage [Forum#71769](https://xcp-ng.org/forum/post/71769)
-- [Size Input] Ability to select two new units in the dropdown (`TiB`, `PiB`) (PR [#7382](https://github.com/vatesfr/xen-orchestra/pull/7382))
-
 
 ### Bug fixes
 
@@ -20,9 +15,6 @@
 
 - [Settings/XO Config] Sort backups from newest to oldest
 - [Plugins/audit] Don't log `tag.getAllConfigured` calls
-- [Remotes] Correctly clear error when the remote is tested with success
-- [Import/VMWare] Fix importing last snapshot (PR [#7370](https://github.com/vatesfr/xen-orchestra/pull/7370))
-- [Host/Reboot] Fix false positive warning when restarting an host after updates (PR [#7366](https://github.com/vatesfr/xen-orchestra/pull/7366))
 
 ### Packages to release
 
@@ -40,12 +32,8 @@
 
 <!--packages-start-->
 
-- @xen-orchestra/backups patch
-- @xen-orchestra/fs patch
-- @xen-orchestra/xapi patch
-- vhd-lib patch
-- xo-server minor
+- xo-server patch
 - xo-server-audit patch
-- xo-web minor
+- xo-web patch
 
 <!--packages-end-->

docs/xoa.md

@@ -93,21 +93,6 @@ Follow the instructions:
 
 You can also download XOA from xen-orchestra.com in an XVA file. Once you've got the XVA file, you can import it with `xe vm-import filename=xoa_unified.xva` or via XenCenter.
 
-If you want to use static IP address for your appliance:
-
-```sh
-xe vm-param-set uuid="$uuid" \
-  xenstore-data:vm-data/ip="$ip" \
-  xenstore-data:vm-data/netmask="$netmask" \
-  xenstore-data:vm-data/gateway="$gateway"
-```
-
-If you want to replace the default DNS server:
-
-```sh
-xe vm-param-set uuid="$uuid" xenstore-data:vm-data/dns="$dns"
-```
-
 After the VM is imported, you just need to start it with `xe vm-start vm="XOA"` or with XenCenter.
 
 ## First console connection

package.json

@@ -1,6 +1,4 @@
 {
-  "name": "xen-orchestra",
-  "version": "0.0.0",
   "devDependencies": {
     "@babel/core": "^7.0.0",
     "@babel/eslint-parser": "^7.13.8",
@@ -96,7 +94,7 @@
   },
   "private": true,
   "scripts": {
-    "build": "TURBO_TELEMETRY_DISABLED=1 turbo run build --scope xo-server --scope xo-server-'*' --scope xo-web",
+    "build": "turbo run build --scope xo-server --scope xo-server-'*' --scope xo-web",
     "build:xo-lite": "turbo run build --scope @xen-orchestra/lite",
     "clean": "scripts/run-script.js --parallel clean",
     "dev": "scripts/run-script.js --parallel --concurrency 0 --verbose dev",

packages/vhd-lib/Vhd/VhdSynthetic.js

@@ -46,9 +46,9 @@ const VhdSynthetic = class VhdSynthetic extends VhdAbstract {
   }
 
   get compressionType() {
-    const compressionType = this.#vhds[0].compressionType
-    for (let i = 0; i < this.#vhds.length; i++) {
-      if (compressionType !== this.#vhds[i].compressionType) {
+    const compressionType = this.vhds[0].compressionType
+    for (let i = 0; i < this.vhds.length; i++) {
+      if (compressionType !== this.vhds[i].compressionType) {
         return 'MIXED'
       }
     }

packages/vhd-lib/chain.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { relativeFromFile } = require('@xen-orchestra/fs/path')
+const { dirname, relative } = require('path')
 
 const { openVhd } = require('./openVhd')
 const { DISK_TYPES } = require('./_constants')
@@ -21,7 +21,7 @@ module.exports = async function chain(parentHandler, parentPath, childHandler, c
       }
       await childVhd.readBlockAllocationTable()
 
-      const parentName = relativeFromFile(childPath, parentPath)
+      const parentName = relative(dirname(childPath), parentPath)
       header.parentUuid = parentVhd.footer.uuid
       header.parentUnicodeName = parentName
       await childVhd.setUniqueParentLocator(parentName)

packages/xo-server/src/_handleBackupLog.mjs

@@ -27,7 +27,7 @@ async function sendToNagios(app, jobName, vmBackupInfo) {
       jobName
     )
   } catch (error) {
-    warn('sendToNagios:', { error })
+    warn('sendToNagios:', error)
   }
 }
 

packages/xo-server/src/api/host.mjs

@@ -1,4 +1,3 @@
-import semver from 'semver'
 import { createLogger } from '@xen-orchestra/log'
 import assert from 'assert'
 import { format } from 'json-rpc-peer'
@@ -137,38 +136,13 @@ export async function restart({
     const pool = this.getObject(host.$poolId, 'pool')
     const master = this.getObject(pool.master, 'host')
     const hostRebootRequired = host.rebootRequired
-
-    // we are currently in an host upgrade process
-    if (hostRebootRequired && host.id !== master.id) {
-      // this error is not ideal but it means that the pool master must be fully upgraded/rebooted before the current host can be rebooted.
-      //
-      // there is a single error for the 3 cases because the client must handle them the same way
-      const throwError = () =>
-        incorrectState({
-          actual: hostRebootRequired,
-          expected: false,
-          object: master.id,
-          property: 'rebootRequired',
-        })
-
-      if (semver.lt(master.version, host.version)) {
-        log.error(`master version (${master.version}) is older than the host version (${host.version})`, {
-          masterId: master.id,
-          hostId: host.id,
-        })
-        throwError()
-      }
-
-      if (semver.eq(master.version, host.version)) {
-        if ((await this.getXapi(host).listMissingPatches(master._xapiId)).length > 0) {
-          log.error('master has missing patches', { masterId: master.id })
-          throwError()
-        }
-        if (master.rebootRequired) {
-          log.error('master needs to reboot')
-          throwError()
-        }
-      }
+    if (hostRebootRequired && host.id !== master.id && host.version === master.version) {
+      throw incorrectState({
+        actual: hostRebootRequired,
+        expected: false,
+        object: master.id,
+        property: 'rebootRequired',
+      })
     }
   }
 

packages/xo-server/src/api/pusb.mjs

@@ -1,27 +0,0 @@
-export async function scan({ host }) {
-  await this.getXapi(host).call('PUSB.scan', host._xapiRef)
-}
-
-scan.params = {
-  host: { type: 'string' },
-}
-scan.resolve = {
-  host: ['host', 'host', 'operate'],
-}
-
-export async function set({ pusb, enabled }) {
-  const xapi = this.getXapi(pusb)
-
-  if (enabled !== undefined && enabled !== pusb.passthroughEnabled) {
-    await xapi.call('PUSB.set_passthrough_enabled', pusb._xapiRef, enabled)
-  }
-}
-
-set.params = {
-  id: { type: 'string' },
-  enabled: { type: 'boolean', optional: true },
-}
-
-set.resolve = {
-  pusb: ['id', 'PUSB', 'administrate'],
-}

packages/xo-server/src/xapi-object-to-xo.mjs

@@ -328,34 +328,6 @@ const TRANSFORMS = {
 
     const { creation } = xoData.extract(obj) ?? {}
 
-    let $container
-    if (obj.resident_on !== 'OpaqueRef:NULL') {
-      // resident_on is set when the VM is running (or paused or suspended on a host)
-      $container = link(obj, 'resident_on')
-    } else {
-      // if the VM is halted, the $container is the pool
-      $container = link(obj, 'pool')
-
-      // unless one of its VDI is on a non shared SR
-      //
-      // linked objects may not be there when this code run, and it will only be
-      // refreshed when the VM XAPI record change, this value is not guaranteed
-      // to be up-to-date, but it practice it appears to work fine thanks to
-      // `VBDs` and `current_operations` changing when a VDI is
-      // added/removed/migrated
-      for (const vbd of obj.$VBDs) {
-        const sr = vbd?.$VDI?.$SR
-        if (sr !== undefined && !sr.shared) {
-          const pbd = sr.$PBDs[0]
-          const hostId = pbd && link(pbd, 'host')
-          if (hostId !== undefined) {
-            $container = hostId
-            break
-          }
-        }
-      }
-    }
-
     const vm = {
       // type is redefined after for controllers/, templates &
       // snapshots.
@@ -450,7 +422,8 @@ const TRANSFORMS = {
       xenTools,
       ...getVmGuestToolsProps(obj),
 
-      $container,
+      // TODO: handle local VMs (`VM.get_possible_hosts()`).
+      $container: isRunning ? link(obj, 'resident_on') : link(obj, 'pool'),
       $VBDs: link(obj, 'VBDs'),
 
       // TODO: dedupe
@@ -889,17 +862,6 @@ const TRANSFORMS = {
       vm: link(obj, 'VM'),
     }
   },
-
-  pusb(obj) {
-    return {
-      type: 'PUSB',
-
-      description: obj.description,
-      host: link(obj, 'host'),
-      passthroughEnabled: obj.passthrough_enabled,
-      usbGroup: link(obj, 'USB_group'),
-    }
-  },
 }
 
 // ===================================================================

packages/xo-server/src/xapi-stats.mjs

@@ -45,17 +45,7 @@ const RRD_POINTS_PER_STEP = {
 // Utils
 // -------------------------------------------------------------------
 
-function parseNumber(value) {
-  // Starting from XAPI 23.31, numbers in the JSON payload are encoded as
-  // strings to support NaN, Infinity and -Infinity
-  if (typeof value === 'string') {
-    const asNumber = +value
-    if (isNaN(asNumber) && value !== 'NaN') {
-      throw new Error('cannot parse number: ' + value)
-    }
-    value = asNumber
-  }
-
+function convertNanToNull(value) {
   return isNaN(value) ? null : value
 }
 
@@ -68,7 +58,7 @@ async function getServerTimestamp(xapi, hostRef) {
 // -------------------------------------------------------------------
 
 const computeValues = (dataRow, legendIndex, transformValue = identity) =>
-  map(dataRow, ({ values }) => transformValue(parseNumber(values[legendIndex])))
+  map(dataRow, ({ values }) => transformValue(convertNanToNull(values[legendIndex])))
 
 const combineStats = (stats, path, combineValues) => zipWith(...map(stats, path), (...values) => combineValues(values))
 
@@ -255,15 +245,7 @@ export default class XapiStats {
           start: timestamp,
         },
       })
-      .then(response => response.text())
-      .then(data => {
-        try {
-          // starting from XAPI 23.31, the response is valid JSON
-          return JSON.parse(data)
-        } catch (_) {
-          return JSON5.parse(data)
-        }
-      })
+      .then(response => response.text().then(JSON5.parse))
       .catch(err => {
         delete this.#hostCache[hostUuid][step]
         throw err
@@ -317,7 +299,7 @@ export default class XapiStats {
     // To avoid crossing over the boundary, we ask for one less step
     const optimumTimestamp = currentTimeStamp - maxDuration + step
     const json = await this._getJson(xapi, host, optimumTimestamp, step)
-    const actualStep = parseNumber(json.meta.step)
+    const actualStep = json.meta.step
 
     if (actualStep !== step) {
       throw new FaultyGranularity(`Unable to get the true granularity: ${actualStep}`)
@@ -344,10 +326,9 @@ export default class XapiStats {
           return
         }
 
-        const endTimestamp = parseNumber(json.meta.end)
-        if (stepStats === undefined || stepStats.endTimestamp !== endTimestamp) {
+        if (stepStats === undefined || stepStats.endTimestamp !== json.meta.end) {
           stepStats = {
-            endTimestamp,
+            endTimestamp: json.meta.end,
             interval: actualStep,
             stats: {},
           }

packages/xo-server/src/xapi/mixins/vm.mjs

@@ -32,6 +32,9 @@ const methods = {
       name_label, // eslint-disable-line camelcase
       nameLabel = name_label, // eslint-disable-line camelcase
 
+      cloudConfig,
+      networkConfig,
+
       clone = true,
       installRepository = undefined,
       vdis = undefined,
@@ -217,6 +220,35 @@ const methods = {
       await this.createVgpu(vm, gpuGroup, vgpuType)
     }
 
+    // create cloud config drive
+    let cloudConfigVdiUuid
+    if (params.cloudConfig != null) {
+      // Find the SR of the first VDI.
+      let srId
+      forEach(vm.$VBDs, vbdId => {
+        const vbd = this.getObject(vbdId)
+        const vdiId = vbd.VDI
+        if (!vbd.is_cd_drive && vdiId !== undefined) {
+          srId = this.getObject(vdiId).$SR
+          return false
+        }
+      })
+
+      try {
+        cloudConfigVdiUuid = params.coreOs
+          ? await xapi.createCoreOsCloudInitConfigDrive(vm.id, srId, params.cloudConfig)
+          : await xapi.createCloudInitConfigDrive(vm.id, srId, params.cloudConfig, params.networkConfig)
+      } catch (error) {
+        log.warn('vm.create', { vmId: vm.id, srId, error })
+        throw error
+      }
+    }
+
+    if (params.createVtpm) {
+      const vtpmRef = await xapi.VTPM_create({ VM: xapiVm.$ref })
+      $defer.onFailure(() => xapi.call('VTPM.destroy', vtpmRef))
+    }
+
     // wait for the record with all the VBDs and VIFs
     return this.barrier(vm.$ref)
   },

packages/xo-server/src/xo-mixins/migrate-vm.mjs

@@ -280,7 +280,7 @@ export default class MigrateVm {
             const stream = vhd.stream()
             await vdi.$importContent(stream, { format: VDI_FORMAT_VHD })
           }
-          return { vdi, vhd }
+          return vhd
         })
       )
     )

packages/xo-server/src/xo-mixins/remotes.mjs

@@ -1,6 +1,5 @@
 import asyncMapSettled from '@xen-orchestra/async-map/legacy.js'
 import { basename } from 'path'
-import { createLogger } from '@xen-orchestra/log'
 import { format, parse } from 'xo-remote-parser'
 import {
   DEFAULT_ENCRYPTION_ALGORITHM,
@@ -18,35 +17,17 @@ import { Remotes } from '../models/remote.mjs'
 
 // ===================================================================
 
-const { warn } = createLogger('xo:mixins:remotes')
-
 const obfuscateRemote = ({ url, ...remote }) => {
   const parsedUrl = parse(url)
   remote.url = format(sensitiveValues.obfuscate(parsedUrl))
   return remote
 }
 
-// these properties should be defined on the remote object itself and not as
-// part of the remote URL
-//
-// there is a bug somewhere that keep putting them into the URL, this list
-// is here to help track it
-const INVALID_URL_PARAMS = ['benchmarks', 'id', 'info', 'name', 'proxy', 'enabled', 'error', 'url']
-
-function validateUrl(url) {
-  const parsedUrl = parse(url)
-
-  const { path } = parsedUrl
+function validatePath(url) {
+  const { path } = parse(url)
   if (path !== undefined && basename(path) === 'xo-vm-backups') {
     throw invalidParameters('remote url should not end with xo-vm-backups')
   }
-
-  for (const param of INVALID_URL_PARAMS) {
-    if (Object.hasOwn(parsedUrl, param)) {
-      // log with stack trace
-      warn(new Error('invalid remote URL param ' + param))
-    }
-  }
 }
 
 export default class {
@@ -201,22 +182,6 @@ export default class {
     if (remote === undefined) {
       throw noSuchObject(id, 'remote')
     }
-
-    const parsedUrl = parse(remote.url)
-    let fixed = false
-    for (const param of INVALID_URL_PARAMS) {
-      if (Object.hasOwn(parsedUrl, param)) {
-        // delete the value to trace its real origin when it's added back
-        // with `updateRemote()`
-        delete parsedUrl[param]
-        fixed = true
-      }
-    }
-    if (fixed) {
-      remote.url = format(parsedUrl)
-      this._remotes.update(remote).catch(warn)
-    }
-
     return remote
   }
 
@@ -237,7 +202,7 @@ export default class {
   }
 
   async createRemote({ name, options, proxy, url }) {
-    validateUrl(url)
+    validatePath(url)
 
     const params = {
       enabled: false,
@@ -254,10 +219,6 @@ export default class {
   }
 
   updateRemote(id, { enabled, name, options, proxy, url }) {
-    if (url !== undefined) {
-      validateUrl(url)
-    }
-
     const handlers = this._handlers
     const handler = handlers[id]
     if (handler !== undefined) {
@@ -277,7 +238,7 @@ export default class {
   @synchronized()
   async _updateRemote(id, { url, ...props }) {
     if (url !== undefined) {
-      validateUrl(url)
+      validatePath(url)
     }
 
     const remote = await this._getRemote(id)

packages/xo-server/src/xo-mixins/rest-api.mjs

@@ -253,10 +253,6 @@ export default class RestApi {
           const host = req.xapiObject
           res.json(await host.$xapi.listMissingPatches(host))
         },
-
-        async smt({ xapiObject }, res) {
-          res.json({ enabled: await xapiObject.$xapi.isHyperThreadingEnabled(xapiObject.$id) })
-        },
       }
 
       collections.pools.routes = {
@@ -301,6 +297,15 @@ export default class RestApi {
             auto_poweron: { type: 'boolean', optional: true },
             boot: { type: 'boolean', default: false },
             clone: { type: 'boolean', default: true },
+            cloud_init: {
+              type: 'object',
+              default: {},
+              properties: {
+                cloud_config: { type: 'string', optional: true },
+                destroy_after_boot: { type: 'boolean', default: false },
+                network_config: { type: 'string', optional: true },
+              },
+            },
             install: {
               type: 'object',
               optional: true,

packages/xo-web/src/common/form/index.js

@@ -138,7 +138,7 @@ export class Range extends Component {
 
 export Toggle from './toggle'
 
-const UNITS = ['kiB', 'MiB', 'GiB', 'TiB', 'PiB']
+const UNITS = ['kiB', 'MiB', 'GiB']
 const DEFAULT_UNIT = 'GiB'
 
 export class SizeInput extends BaseComponent {

packages/xo-web/src/common/iso-device.js

@@ -54,9 +54,13 @@ export default class IsoDevice extends Component {
     () => this.props.vm.$pool,
     () => this.props.vm.$container,
     (vmPool, vmContainer) => sr => {
+      const vmRunning = vmContainer !== vmPool
+      const sameHost = vmContainer === sr.$container
+      const samePool = vmPool === sr.$pool
+
       return (
-        vmPool === sr.$pool &&
-        (sr.shared || vmContainer === sr.$container) &&
+        samePool &&
+        (vmRunning ? sr.shared || sameHost : true) &&
         (sr.SR_type === 'iso' || (sr.SR_type === 'udev' && sr.size))
       )
     }

packages/xo-web/src/common/report-bug-button.js

@@ -75,7 +75,7 @@ export const reportOnSupportPanel = async ({ files = [], formatMessage = identit
     ADDITIONAL_FILES.map(({ fetch, name }) =>
       timeout.call(fetch(), ADDITIONAL_FILES_FETCH_TIMEOUT).then(
         file => formData.append('attachments', createBlobFromString(file), name),
-        error => logger.warn(`cannot get ${name}`, { error })
+        error => logger.warn(`cannot get ${name}`, error)
       )
     )
   )

packages/xo-web/src/xo-app/host/tab-general.js

@@ -3,6 +3,7 @@ import _ from 'intl'
 import Copiable from 'copiable'
 import decorate from 'apply-decorators'
 import Icon from 'icon'
+import map from 'lodash/map'
 import React from 'react'
 import store from 'store'
 import HomeTags from 'home-tags'
@@ -23,21 +24,10 @@ export default decorate([
   provideState({
     computed: {
       areHostsVersionsEqual: ({ areHostsVersionsEqualByPool }, { host }) => areHostsVersionsEqualByPool[host.$pool],
-      inMemoryVms: (_, { vms }) => {
-        const result = []
-        for (const key of Object.keys(vms)) {
-          const vm = vms[key]
-          const { power_state } = vm
-          if (power_state === 'Running' || power_state === 'Paused') {
-            result.push(vm)
-          }
-        }
-        return result
-      },
     },
   }),
   injectState,
-  ({ statsOverview, host, nVms, vmController, state: { areHostsVersionsEqual, inMemoryVms } }) => {
+  ({ statsOverview, host, nVms, vmController, vms, state: { areHostsVersionsEqual } }) => {
     const pool = getObject(store.getState(), host.$pool)
     const vmsFilter = encodeURIComponent(new CM.Property('$container', new CM.String(host.id)).toString())
     return (
@@ -130,7 +120,7 @@ export default decorate([
                 tooltip={`${host.productBrand} (${formatSize(vmController.memory.size)})`}
                 value={vmController.memory.size}
               />
-              {inMemoryVms.map(vm => (
+              {map(vms, vm => (
                 <UsageElement
                   tooltip={`${vm.name_label} (${formatSize(vm.memory.size)})`}
                   key={vm.id}

packages/xo-web/src/xo-app/settings/remotes/index.js

@@ -33,7 +33,7 @@ const formatError = error => (typeof error === 'string' ? error : JSON.stringify
 
 const _changeUrlElement = (value, { remote, element }) =>
   editRemote(remote, {
-    url: format({ ...parse(remote.url), [element]: value === null ? undefined : value }),
+    url: format({ ...remote, [element]: value === null ? undefined : value }),
   })
 const _showError = remote => alert(_('remoteConnectionFailed'), <pre>{formatError(remote.error)}</pre>)
 const _editRemoteName = (name, { remote }) => editRemote(remote, { name })