minimum MTU value for network creation

Related to 5712f29a5

.eslintrc.js

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

@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 (err) {
+        } catch (error) {
           // 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`, err)
+          warn(`can't use differential restore`, { error })
           disposableDescendants?.dispose()
         }
       }

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

@@ -143,8 +143,10 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
 
     let metadataContent = await this._isAlreadyTransferred(timestamp)
     if (metadataContent !== undefined) {
-      // @todo : should skip backup while being vigilant to not stuck the forked stream
+      // 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 }
     }
 
     const basename = formatFilenameDate(timestamp)

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

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

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

@@ -20,5 +20,7 @@ export function split(path) {
   return parts
 }
 
-export const relativeFromFile = (file, path) => relative(dirname(file), path)
+// 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 resolveFromFile = (file, path) => resolve('/', dirname(file), path).slice(1)

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

@@ -0,0 +1,17 @@
+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 (err) {
-    if (err.code !== 'EEXIST') {
+  } catch (error) {
+    if (error.code !== 'EEXIST') {
       // there can be a symbolic link in the tree
-      warn('handleExistingFile', err)
+      warn('handleExistingFile', { error })
     }
   }
 }
@@ -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/tsconfig.app.json

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

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

@@ -23,6 +23,7 @@ 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,6 +27,16 @@ 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,6 +45,16 @@ 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/package.json

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

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

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

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

@@ -11,6 +11,7 @@ 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,12 +21,23 @@ 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'),
-      device ?? (await this.call('VM.get_allowed_VIF_devices', VM))[0],
-      MTU ?? (await this.getField('network', network, 'MTU')),
+      MTU ?? this.getField('network', network, 'MTU'),
     ])
-    ;[device, MTU] = rest
+    ;[MTU] = rest
 
     const vifRef = await this.call('VIF.create', {
       currently_attached: powerState === 'Suspended' ? currently_attached : undefined,

CHANGELOG.md

@@ -1,5 +1,28 @@
 # ChangeLog
 
+## **5.91.2** (2024-02-09)
+
+<img id="latest" src="https://badgen.net/badge/channel/latest/yellow" alt="Channel: latest" />
+
+### Enhancements
+
+- [REST API] Add `/groups` collection [Forum#70500](https://xcp-ng.org/forum/post/70500)
+- [REST API] Add `/groups/:id/users` and `/users/:id/groups` collection [Forum#70500](https://xcp-ng.org/forum/post/70500)
+- [REST API] Expose messages associated to XAPI objects at `/:collection/:object/messages`
+
+### Bug fixes
+
+- [Import/VMWare] Fix `(Failure \"Expected string, got 'I(0)'\")` (PR [#7361](https://github.com/vatesfr/xen-orchestra/issues/7361))
+- [Plugin/load-balancer] Fixing `TypeError: Cannot read properties of undefined (reading 'high')` happening when trying to optimize a host with performance plan [#7359](https://github.com/vatesfr/xen-orchestra/issues/7359) (PR [#7362](https://github.com/vatesfr/xen-orchestra/pull/7362))
+- Changing the number of displayed items per page should send back to the first page [#7350](https://github.com/vatesfr/xen-orchestra/issues/7350)
+- [Plugin/load-balancer] Correctly create a _simple_ instead of a _density_ plan when it is selected (PR [#7358](https://github.com/vatesfr/xen-orchestra/pull/7358))
+
+### Released packages
+
+- xo-server 5.136.0
+- xo-server-load-balancer 0.8.1
+- xo-web 5.136.1
+
 ## **5.91.1** (2024-02-06)
 
 ### Bug fixes
@@ -18,8 +41,6 @@
 
 ## **5.91.0** (2024-01-31)
 
-<img id="latest" src="https://badgen.net/badge/channel/latest/yellow" alt="Channel: latest" />
-
 ### Highlights
 
 - [Import/VMWare] Speed up import and make all imports thin [#7323](https://github.com/vatesfr/xen-orchestra/issues/7323)

CHANGELOG.unreleased.md

@@ -7,13 +7,18 @@
 
 > 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
+- [Pool/Network] Ability to edit MTU [#7039](https://github.com/vatesfr/xen-orchestra/issues/7039) (PR [#7393](https://github.com/vatesfr/xen-orchestra/pull/7393))
+
 ### Bug fixes
 
 > Users must be able to say: “I had this issue, happy to know it's fixed”
 
-- [Import/VMWare] Fix `(Failure \"Expected string, got 'I(0)'\")` (PR [#7361](https://github.com/vatesfr/xen-orchestra/issues/7361))
-- [Plugin/load-balancer] Fixing `TypeError: Cannot read properties of undefined (reading 'high')` happening when trying to optimize a host with performance plan [#7359](https://github.com/vatesfr/xen-orchestra/issues/7359) (PR [#7362](https://github.com/vatesfr/xen-orchestra/pull/7362))
-- Changing the number of displayed items per page should send back to the first page [#7350](https://github.com/vatesfr/xen-orchestra/issues/7350)
+- [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
+- [Pool/Network] Don't allow MTU values that are too small to work (<68)
 
 ### Packages to release
 
@@ -31,8 +36,12 @@
 
 <!--packages-start-->
 
-- xo-server patch
-- xo-server-load-balancer patch
-- xo-web patch
+- @xen-orchestra/backups patch
+- @xen-orchestra/fs patch
+- @xen-orchestra/xapi patch
+- vhd-lib patch
+- xo-server minor
+- xo-server-audit patch
+- xo-web minor
 
 <!--packages-end-->

docs/load_balancing.md

@@ -34,9 +34,8 @@ But it's not the only way to see this: there is multiple possibilities to "optim
 
 - maybe you want to spread the VM load on the maximum number of server, to get the most of your hardware? (previous example)
 - maybe you want to reduce power consumption and migrate your VMs to the minimum number of hosts possible? (and shutdown useless hosts)
-- or maybe both, depending of your own schedule?
 
-Those ways can be also called modes: "performance" for 1, "density" for number 2 and "mixed" for the last.
+Those ways can be also called modes: "performance" for 1 and "density" for number 2.
 
 ## Configure a plan
 
@@ -47,7 +46,6 @@ A plan has:
 - a name
 - pool(s) where to apply the policy
 - a mode (see paragraph below)
-- a behavior (aggressive, normal, low)
 
 ### Plan modes
 
@@ -55,7 +53,7 @@ There are 3 modes possible:
 
 - performance
 - density
-- mixed
+- simple
 
 #### Performance
 
@@ -65,14 +63,9 @@ VMs are placed to use all possible resources. This means balance the load to giv
 
 This time, the objective is to use the least hosts possible, and to concentrate your VMs. In this mode, you can choose to shutdown unused (and compatible) hosts.
 
-#### Mixed
+#### Simple
 
-This mode allows you to use both performance and density, but alternatively, depending of a schedule. E.g:
-
-- **performance** from 6:00 AM to 7:00 PM
-- **density** from 7:01 PM to 5:59 AM
-
-In this case, you'll have the best of both when needed (energy saving during the night and performance during the day).
+This mode allows you to use VM anti-affinity without using any load balancing mechanism. (see paragraph below)
 
 ### Threshold
 
@@ -87,6 +80,10 @@ If the CPU threshold is set to 90%, the load balancer will be only triggered if
 
 For free memory, it will be triggered if there is **less** free RAM than the threshold.
 
+### Exclusion
+
+If you want to prevent load balancing from triggering migrations on a particular host or VM, it is possible to exclude it from load balancing. It can be configured via the "Excluded hosts" parameter in each plan, and in the "Ignored VM tags" parameter which is common to every plan.
+
 ### Timing
 
 The global situation (resource usage) is examined **every minute**.

docs/xoa.md

@@ -93,6 +93,21 @@ 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,4 +1,6 @@
 {
+  "name": "xen-orchestra",
+  "version": "0.0.0",
   "devDependencies": {
     "@babel/core": "^7.0.0",
     "@babel/eslint-parser": "^7.13.8",
@@ -94,7 +96,7 @@
   },
   "private": true,
   "scripts": {
-    "build": "turbo run build --scope xo-server --scope xo-server-'*' --scope xo-web",
+    "build": "TURBO_TELEMETRY_DISABLED=1 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/chain.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { dirname, relative } = require('path')
+const { relativeFromFile } = require('@xen-orchestra/fs/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 = relative(dirname(childPath), parentPath)
+      const parentName = relativeFromFile(childPath, parentPath)
       header.parentUuid = parentVhd.footer.uuid
       header.parentUnicodeName = parentName
       await childVhd.setUniqueParentLocator(parentName)

packages/xo-server-audit/src/index.js

@@ -72,6 +72,7 @@ const DEFAULT_BLOCKED_LIST = {
   'system.getServerTimezone': true,
   'system.getServerVersion': true,
   'system.getVersion': true,
+  'tag.getAllConfigured': true,
   'test.getPermissionsForUser': true,
   'user.getAll': true,
   'user.getAuthenticationTokens': true,

packages/xo-server-load-balancer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xo-server-load-balancer",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "license": "AGPL-3.0-or-later",
   "description": "Load balancer for XO-Server",
   "keywords": [

packages/xo-server-load-balancer/src/index.js

@@ -12,6 +12,8 @@ import { EXECUTION_DELAY, debug } from './utils'
 
 const PERFORMANCE_MODE = 0
 const DENSITY_MODE = 1
+const SIMPLE_MODE = 2
+const MODES = { 'Performance mode': PERFORMANCE_MODE, 'Density mode': DENSITY_MODE, 'Simple mode': SIMPLE_MODE }
 
 // ===================================================================
 
@@ -35,7 +37,7 @@ export const configurationSchema = {
           },
 
           mode: {
-            enum: ['Performance mode', 'Density mode', 'Simple mode'],
+            enum: Object.keys(MODES),
             title: 'Mode',
           },
 
@@ -147,7 +149,7 @@ class LoadBalancerPlugin {
 
     if (plans) {
       for (const plan of plans) {
-        this._addPlan(plan.mode === 'Performance mode' ? PERFORMANCE_MODE : DENSITY_MODE, plan)
+        this._addPlan(MODES[plan.mode], plan)
       }
     }
   }

packages/xo-server/config.toml

@@ -143,6 +143,7 @@ port = 80
 requestTimeout = 0
 
 [http.mounts]
+'/robots.txt' = './robots.txt'
 '/' = '../xo-web/dist/'
 '/v6' = '../../@xen-orchestra/web/dist/'
 

packages/xo-server/package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "xo-server",
-  "version": "5.135.1",
+  "version": "5.136.0",
   "license": "AGPL-3.0-or-later",
   "description": "Server part of Xen-Orchestra",
   "keywords": [

packages/xo-server/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

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

@@ -1,5 +1,7 @@
 import xapiObjectToXo from '../xapi-object-to-xo.mjs'
 
+const RFC_MINIMUM_MTU = 68 // see RFC 791
+
 export function getBondModes() {
   return ['balance-slb', 'active-backup', 'lacp']
 }
@@ -26,7 +28,7 @@ create.params = {
   nbd: { type: 'boolean', optional: true },
   description: { type: 'string', minLength: 0, optional: true },
   pif: { type: 'string', optional: true },
-  mtu: { type: 'integer', optional: true },
+  mtu: { type: 'integer', optional: true, minimum: RFC_MINIMUM_MTU },
   vlan: { type: 'integer', optional: true },
 }
 
@@ -56,7 +58,7 @@ createBonded.params = {
       type: 'string',
     },
   },
-  mtu: { type: 'integer', optional: true },
+  mtu: { type: 'integer', optional: true, minimum: RFC_MINIMUM_MTU },
   bondMode: { enum: getBondModes() },
 }
 
@@ -72,6 +74,7 @@ export async function set({
 
   automatic,
   defaultIsLocked,
+  mtu,
   name_description: nameDescription,
   name_label: nameLabel,
   nbd,
@@ -81,6 +84,7 @@ export async function set({
   await Promise.all([
     automatic !== undefined && network.update_other_config('automatic', automatic ? 'true' : null),
     defaultIsLocked !== undefined && network.set_default_locking_mode(defaultIsLocked ? 'disabled' : 'unlocked'),
+    mtu !== undefined && network.set_MTU(mtu),
     nameDescription !== undefined && network.set_name_description(nameDescription),
     nameLabel !== undefined && network.set_name_label(nameLabel),
     nbd !== undefined &&
@@ -103,6 +107,11 @@ set.params = {
   id: {
     type: 'string',
   },
+  mtu: {
+    type: 'integer',
+    minimum: RFC_MINIMUM_MTU,
+    optional: true,
+  },
   name_description: {
     type: 'string',
     minLength: 0,

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

@@ -45,7 +45,17 @@ const RRD_POINTS_PER_STEP = {
 // Utils
 // -------------------------------------------------------------------
 
-function convertNanToNull(value) {
+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
+  }
+
   return isNaN(value) ? null : value
 }
 
@@ -58,7 +68,7 @@ async function getServerTimestamp(xapi, hostRef) {
 // -------------------------------------------------------------------
 
 const computeValues = (dataRow, legendIndex, transformValue = identity) =>
-  map(dataRow, ({ values }) => transformValue(convertNanToNull(values[legendIndex])))
+  map(dataRow, ({ values }) => transformValue(parseNumber(values[legendIndex])))
 
 const combineStats = (stats, path, combineValues) => zipWith(...map(stats, path), (...values) => combineValues(values))
 
@@ -245,7 +255,15 @@ export default class XapiStats {
           start: timestamp,
         },
       })
-      .then(response => response.text().then(JSON5.parse))
+      .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)
+        }
+      })
       .catch(err => {
         delete this.#hostCache[hostUuid][step]
         throw err
@@ -299,7 +317,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 = json.meta.step
+    const actualStep = parseNumber(json.meta.step)
 
     if (actualStep !== step) {
       throw new FaultyGranularity(`Unable to get the true granularity: ${actualStep}`)
@@ -326,9 +344,10 @@ export default class XapiStats {
           return
         }
 
-        if (stepStats === undefined || stepStats.endTimestamp !== json.meta.end) {
+        const endTimestamp = parseNumber(json.meta.end)
+        if (stepStats === undefined || stepStats.endTimestamp !== endTimestamp) {
           stepStats = {
-            endTimestamp: json.meta.end,
+            endTimestamp,
             interval: actualStep,
             stats: {},
           }

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

@@ -1,5 +1,6 @@
 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,
@@ -17,17 +18,35 @@ 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
 }
 
-function validatePath(url) {
-  const { path } = parse(url)
+// 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
   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 {
@@ -182,6 +201,22 @@ 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
   }
 
@@ -202,7 +237,7 @@ export default class {
   }
 
   async createRemote({ name, options, proxy, url }) {
-    validatePath(url)
+    validateUrl(url)
 
     const params = {
       enabled: false,
@@ -219,6 +254,10 @@ 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) {
@@ -238,7 +277,7 @@ export default class {
   @synchronized()
   async _updateRemote(id, { url, ...props }) {
     if (url !== undefined) {
-      validatePath(url)
+      validateUrl(url)
     }
 
     const remote = await this._getRemote(id)

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

@@ -100,6 +100,17 @@ async function sendObjects(iterable, req, res, path = req.path) {
   return pipeline(makeObjectsStream(iterable, makeResult, json, res), res)
 }
 
+function handleArray(array, filter, limit) {
+  if (filter !== undefined) {
+    array = array.filter(filter)
+  }
+  if (limit < array.length) {
+    array.length = limit
+  }
+
+  return array
+}
+
 const handleOptionalUserFilter = filter => filter && CM.parse(filter).createPredicate()
 
 const subRouter = (app, path) => {
@@ -160,77 +171,7 @@ export default class RestApi {
       )
     })
 
-    const types = [
-      'host',
-      'network',
-      'pool',
-      'SR',
-      'VBD',
-      'VDI-snapshot',
-      'VDI',
-      'VIF',
-      'VM-snapshot',
-      'VM-template',
-      'VM',
-    ]
-    const collections = Object.fromEntries(
-      types.map(type => {
-        const id = type.toLocaleLowerCase() + 's'
-        return [id, { id, isCorrectType: _ => _.type === type, type }]
-      })
-    )
-
-    collections.backup = { id: 'backup' }
-    collections.restore = { id: 'restore' }
-    collections.tasks = { id: 'tasks' }
-    collections.users = { id: 'users' }
-
-    collections.hosts.routes = {
-      __proto__: null,
-
-      async 'audit.txt'(req, res) {
-        const host = req.xapiObject
-
-        res.setHeader('content-type', 'text/plain')
-        await pipeline(await host.$xapi.getResource('/audit_log', { host }), compressMaybe(req, res))
-      },
-
-      async 'logs.tar'(req, res) {
-        const host = req.xapiObject
-
-        res.setHeader('content-type', 'application/x-tar')
-        await pipeline(await host.$xapi.getResource('/host_logs_download', { host }), compressMaybe(req, res))
-      },
-
-      async missing_patches(req, res) {
-        await app.checkFeatureAuthorization('LIST_MISSING_PATCHES')
-
-        const host = req.xapiObject
-        res.json(await host.$xapi.listMissingPatches(host))
-      },
-    }
-
-    collections.pools.routes = {
-      __proto__: null,
-
-      async missing_patches(req, res) {
-        await app.checkFeatureAuthorization('LIST_MISSING_PATCHES')
-
-        const xapi = req.xapiObject.$xapi
-        const missingPatches = new Map()
-        await asyncEach(Object.values(xapi.objects.indexes.type.host ?? {}), async host => {
-          try {
-            for (const patch of await xapi.listMissingPatches(host)) {
-              const { uuid: key = `${patch.name}-${patch.version}-${patch.release}` } = patch
-              missingPatches.set(key, patch)
-            }
-          } catch (error) {
-            console.warn(host.uuid, error)
-          }
-        })
-        res.json(Array.from(missingPatches.values()))
-      },
-    }
+    const collections = { __proto__: null }
 
     const withParams = (fn, paramsSchema) => {
       fn.params = paramsSchema
@@ -238,68 +179,231 @@ export default class RestApi {
       return fn
     }
 
-    collections.pools.actions = {
-      __proto__: null,
+    {
+      const types = [
+        'host',
+        'message',
+        'network',
+        'pool',
+        'SR',
+        'VBD',
+        'VDI-snapshot',
+        'VDI',
+        'VIF',
+        'VM-snapshot',
+        'VM-template',
+        'VM',
+      ]
+      function getObject(id, req) {
+        const { type } = this
+        const object = app.getObject(id, type)
 
-      create_vm: withParams(
-        defer(async ($defer, { xapiObject: { $xapi } }, { affinity, boot, install, template, ...params }, req) => {
-          params.affinityHost = affinity
-          params.installRepository = install?.repository
+        // add also the XAPI version of the object
+        req.xapiObject = app.getXapiObject(object)
 
-          const vm = await $xapi.createVm(template, params, undefined, req.user.id)
-          $defer.onFailure.call($xapi, 'VM_destroy', vm.$ref)
+        return object
+      }
+      function getObjects(filter, limit) {
+        return app.getObjects({
+          filter: every(this.isCorrectType, filter),
+          limit,
+        })
+      }
+      async function messages(req, res) {
+        const {
+          object: { id },
+          query,
+        } = req
+        await sendObjects(
+          app.getObjects({
+            filter: every(_ => _.type === 'message' && _.$object === id, handleOptionalUserFilter(query.filter)),
+            limit: ifDef(query.limit, Number),
+          }),
+          req,
+          res,
+          '/messages'
+        )
+      }
+      for (const type of types) {
+        const id = type.toLocaleLowerCase() + 's'
 
-          if (boot) {
-            await $xapi.callAsync('VM.start', vm.$ref, false, false)
-          }
+        collections[id] = { getObject, getObjects, routes: { messages }, isCorrectType: _ => _.type === type, type }
+      }
 
-          return vm.uuid
-        }),
-        {
-          affinity: { type: 'string', optional: true },
-          auto_poweron: { type: 'boolean', optional: true },
-          boot: { type: 'boolean', default: false },
-          clone: { type: 'boolean', default: true },
-          install: {
-            type: 'object',
-            optional: true,
-            properties: {
-              method: { enum: ['cdrom', 'network'] },
-              repository: { type: 'string' },
+      collections.hosts.routes = {
+        ...collections.hosts.routes,
+
+        async 'audit.txt'(req, res) {
+          const host = req.xapiObject
+
+          res.setHeader('content-type', 'text/plain')
+          await pipeline(await host.$xapi.getResource('/audit_log', { host }), compressMaybe(req, res))
+        },
+
+        async 'logs.tar'(req, res) {
+          const host = req.xapiObject
+
+          res.setHeader('content-type', 'application/x-tar')
+          await pipeline(await host.$xapi.getResource('/host_logs_download', { host }), compressMaybe(req, res))
+        },
+
+        async missing_patches(req, res) {
+          await app.checkFeatureAuthorization('LIST_MISSING_PATCHES')
+
+          const host = req.xapiObject
+          res.json(await host.$xapi.listMissingPatches(host))
+        },
+      }
+
+      collections.pools.routes = {
+        ...collections.pools.routes,
+
+        async missing_patches(req, res) {
+          await app.checkFeatureAuthorization('LIST_MISSING_PATCHES')
+
+          const xapi = req.xapiObject.$xapi
+          const missingPatches = new Map()
+          await asyncEach(Object.values(xapi.objects.indexes.type.host ?? {}), async host => {
+            try {
+              for (const patch of await xapi.listMissingPatches(host)) {
+                const { uuid: key = `${patch.name}-${patch.version}-${patch.release}` } = patch
+                missingPatches.set(key, patch)
+              }
+            } catch (error) {
+              console.warn(host.uuid, error)
+            }
+          })
+          res.json(Array.from(missingPatches.values()))
+        },
+      }
+
+      collections.pools.actions = {
+        create_vm: withParams(
+          defer(async ($defer, { xapiObject: { $xapi } }, { affinity, boot, install, template, ...params }, req) => {
+            params.affinityHost = affinity
+            params.installRepository = install?.repository
+
+            const vm = await $xapi.createVm(template, params, undefined, req.user.id)
+            $defer.onFailure.call($xapi, 'VM_destroy', vm.$ref)
+
+            if (boot) {
+              await $xapi.callAsync('VM.start', vm.$ref, false, false)
+            }
+
+            return vm.uuid
+          }),
+          {
+            affinity: { type: 'string', optional: true },
+            auto_poweron: { type: 'boolean', optional: true },
+            boot: { type: 'boolean', default: false },
+            clone: { type: 'boolean', default: true },
+            install: {
+              type: 'object',
+              optional: true,
+              properties: {
+                method: { enum: ['cdrom', 'network'] },
+                repository: { type: 'string' },
+              },
             },
+            memory: { type: 'integer', optional: true },
+            name_description: { type: 'string', minLength: 0, optional: true },
+            name_label: { type: 'string' },
+            template: { type: 'string' },
+          }
+        ),
+        emergency_shutdown: async ({ xapiObject }) => {
+          await app.checkFeatureAuthorization('POOL_EMERGENCY_SHUTDOWN')
+
+          await xapiObject.$xapi.pool_emergencyShutdown()
+        },
+        rolling_update: async ({ object }) => {
+          await app.checkFeatureAuthorization('ROLLING_POOL_UPDATE')
+
+          await app.rollingPoolUpdate(object)
+        },
+      }
+      collections.vms.actions = {
+        clean_reboot: ({ xapiObject: vm }) => vm.$callAsync('clean_reboot').then(noop),
+        clean_shutdown: ({ xapiObject: vm }) => vm.$callAsync('clean_shutdown').then(noop),
+        hard_reboot: ({ xapiObject: vm }) => vm.$callAsync('hard_reboot').then(noop),
+        hard_shutdown: ({ xapiObject: vm }) => vm.$callAsync('hard_shutdown').then(noop),
+        snapshot: withParams(
+          async ({ xapiObject: vm }, { name_label }) => {
+            const ref = await vm.$snapshot({ name_label })
+            return vm.$xapi.getField('VM', ref, 'uuid')
           },
-          memory: { type: 'integer', optional: true },
-          name_description: { type: 'string', minLength: 0, optional: true },
-          name_label: { type: 'string' },
-          template: { type: 'string' },
-        }
-      ),
-      emergency_shutdown: async ({ xapiObject }) => {
-        await app.checkFeatureAuthorization('POOL_EMERGENCY_SHUTDOWN')
+          { name_label: { type: 'string', optional: true } }
+        ),
+        start: ({ xapiObject: vm }) => vm.$callAsync('start', false, false).then(noop),
+      }
+    }
 
-        await xapiObject.$xapi.pool_emergencyShutdown()
+    collections.backup = {}
+    collections.groups = {
+      getObject(id) {
+        return app.getGroup(id)
       },
-      rolling_update: async ({ xoObject }) => {
-        await app.checkFeatureAuthorization('ROLLING_POOL_UPDATE')
-
-        await app.rollingPoolUpdate(xoObject)
+      async getObjects(filter, limit) {
+        return handleArray(await app.getAllGroups(), filter, limit)
+      },
+      routes: {
+        async users(req, res) {
+          const { filter, limit } = req.query
+          await sendObjects(
+            handleArray(
+              await Promise.all(req.object.users.map(id => app.getUser(id).then(getUserPublicProperties))),
+              handleOptionalUserFilter(filter),
+              ifDef(limit, Number)
+            ),
+            req,
+            res,
+            '/users'
+          )
+        },
       },
     }
-    collections.vms.actions = {
-      __proto__: null,
-
-      clean_reboot: ({ xapiObject: vm }) => vm.$callAsync('clean_reboot').then(noop),
-      clean_shutdown: ({ xapiObject: vm }) => vm.$callAsync('clean_shutdown').then(noop),
-      hard_reboot: ({ xapiObject: vm }) => vm.$callAsync('hard_reboot').then(noop),
-      hard_shutdown: ({ xapiObject: vm }) => vm.$callAsync('hard_shutdown').then(noop),
-      snapshot: withParams(
-        async ({ xapiObject: vm }, { name_label }) => {
-          const ref = await vm.$snapshot({ name_label })
-          return vm.$xapi.getField('VM', ref, 'uuid')
+    collections.restore = {}
+    collections.tasks = {}
+    collections.users = {
+      getObject(id) {
+        return app.getUser(id).then(getUserPublicProperties)
+      },
+      async getObjects(filter, limit) {
+        return handleArray(await app.getAllUsers(), filter, limit)
+      },
+      routes: {
+        async groups(req, res) {
+          const { filter, limit } = req.query
+          await sendObjects(
+            handleArray(
+              await Promise.all(req.object.groups.map(id => app.getGroup(id))),
+              handleOptionalUserFilter(filter),
+              ifDef(limit, Number)
+            ),
+            req,
+            res,
+            '/groups'
+          )
         },
-        { name_label: { type: 'string', optional: true } }
-      ),
-      start: ({ xapiObject: vm }) => vm.$callAsync('start', false, false).then(noop),
+      },
+    }
+
+    // normalize collections
+    for (const id of Object.keys(collections)) {
+      const collection = collections[id]
+
+      // inject id into the collection
+      collection.id = id
+
+      // set null as prototypes to speed-up look-ups
+      Object.setPrototypeOf(collection, null)
+      const { actions, routes } = collection
+      if (actions !== undefined) {
+        Object.setPrototypeOf(actions, null)
+      }
+      if (routes !== undefined) {
+        Object.setPrototypeOf(routes, null)
+      }
     }
 
     api.param('collection', (req, res, next) => {
@@ -312,14 +416,14 @@ export default class RestApi {
         next()
       }
     })
-    api.param('object', (req, res, next) => {
+    api.param('object', async (req, res, next) => {
       const id = req.params.object
-      const { type } = req.collection
       try {
-        req.xapiObject = app.getXapiObject((req.xoObject = app.getObject(id, type)))
-        next()
+        // eslint-disable-next-line require-atomic-updates
+        req.object = await req.collection.getObject(id, req)
+        return next()
       } catch (error) {
-        if (noSuchObject.is(error, { id, type })) {
+        if (noSuchObject.is(error, { id })) {
           next('route')
         } else {
           next(error)
@@ -478,39 +582,12 @@ export default class RestApi {
         }, true)
       )
 
-    api
-      .get(
-        '/users',
-        wrap(async (req, res) => {
-          let users = await app.getAllUsers()
-
-          const { filter, limit } = req.query
-          if (filter !== undefined) {
-            users = users.filter(CM.parse(filter).createPredicate())
-          }
-          if (limit < users.length) {
-            users.length = limit
-          }
-
-          sendObjects(users.map(getUserPublicProperties), req, res)
-        })
-      )
-      .get(
-        '/users/:id',
-        wrap(async (req, res) => {
-          res.json(getUserPublicProperties(await app.getUser(req.params.id)))
-        })
-      )
-
     api.get(
       '/:collection',
       wrap(async (req, res) => {
         const { query } = req
         await sendObjects(
-          await app.getObjects({
-            filter: every(req.collection.isCorrectType, handleOptionalUserFilter(query.filter)),
-            limit: ifDef(query.limit, Number),
-          }),
+          await req.collection.getObjects(handleOptionalUserFilter(query.filter), ifDef(query.limit, Number)),
           req,
           res
         )
@@ -563,7 +640,7 @@ export default class RestApi {
     )
 
     api.get('/:collection/:object', (req, res) => {
-      let result = req.xoObject
+      let result = req.object
 
       // add locations of sub-routes for discoverability
       const { routes } = req.collection
@@ -618,7 +695,7 @@ export default class RestApi {
       '/:collection/:object/tasks',
       wrap(async (req, res) => {
         const { query } = req
-        const objectId = req.xoObject.id
+        const objectId = req.object.id
         const tasks = app.tasks.list({
           filter: every(
             _ => _.status === 'pending' && _.properties.objectId === objectId,
@@ -658,9 +735,9 @@ export default class RestApi {
         }
       }
 
-      const { xapiObject, xoObject } = req
-      const task = app.tasks.create({ name: `REST: ${action} ${req.collection.type}`, objectId: xoObject.id })
-      const pResult = task.run(() => fn({ xapiObject, xoObject }, params, req))
+      const { object, xapiObject } = req
+      const task = app.tasks.create({ name: `REST: ${action} ${req.collection.type}`, objectId: object.id })
+      const pResult = task.run(() => fn({ object, xapiObject }, params, req))
       if (Object.hasOwn(req.query, 'sync')) {
         pResult.then(result => res.json(result), next)
       } else {

packages/xo-web/package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "xo-web",
-  "version": "5.136.0",
+  "version": "5.136.1",
   "license": "AGPL-3.0-or-later",
   "description": "Web interface client for Xen-Orchestra",
   "keywords": [

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/common/select-objects.js

@@ -1099,7 +1099,9 @@ export const SelectXoCloudConfig = makeSubscriptionSelect(
   subscriber =>
     subscribeCloudXoConfigBackups(configs => {
       const xoObjects = groupBy(
-        map(configs, config => ({ ...config, type: 'xoConfig' })),
+        map(configs, config => ({ ...config, type: 'xoConfig' }))
+          // from newest to oldest
+          .sort((a, b) => b.createdAt - a.createdAt),
         'xoaId'
       )
       subscriber({

packages/xo-web/src/xo-app/pool/tab-network.js

@@ -84,6 +84,16 @@ class Description extends Component {
 
 // -----------------------------------------------------------------------------
 
+class Mtu extends Component {
+  _editMtu = value => editNetwork(this.props.network, { mtu: value })
+
+  render() {
+    const { network } = this.props
+
+    return <Number value={network.MTU} onChange={this._editMtu} />
+  }
+}
+
 @connectStore(() => ({
   defaultPif: _createGetDefaultPif(),
 }))
@@ -330,7 +340,7 @@ const NETWORKS_COLUMNS = [
   },
   {
     name: _('poolNetworkMTU'),
-    itemRenderer: network => network.MTU,
+    itemRenderer: network => <Mtu network={network} />,
   },
 
   {

packages/xo-web/src/xo-app/settings/config/xo-cloud-config/index.js

@@ -5,10 +5,9 @@ import decorate from 'apply-decorators'
 import Icon from 'icon'
 import React from 'react'
 import { confirm } from 'modal'
-import { getApiApplianceInfo, subscribeCloudXoConfig, subscribeCloudXoConfigBackups } from 'xo'
-import { groupBy, sortBy } from 'lodash'
 import { injectState, provideState } from 'reaclette'
 import { SelectXoCloudConfig } from 'select-objects'
+import { subscribeCloudXoConfig, subscribeCloudXoConfigBackups } from 'xo'
 
 import BackupXoConfigModal from './backup-xo-config-modal'
 import RestoreXoConfigModal from './restore-xo-config-modal'
@@ -88,15 +87,7 @@ const CloudConfig = decorate([
         },
     },
     computed: {
-      applianceId: async () => {
-        const { id } = await getApiApplianceInfo()
-        return id
-      },
-      groupedConfigs: ({ applianceId, sortedConfigs }) =>
-        sortBy(groupBy(sortedConfigs, 'xoaId'), config => (config[0].xoaId === applianceId ? -1 : 1)),
       isConfigDefined: ({ config }) => config != null,
-      sortedConfigs: (_, { cloudXoConfigBackups }) =>
-        cloudXoConfigBackups?.sort((config, nextConfig) => config.createdAt - nextConfig.createdAt),
     },
   }),
   injectState,

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({ ...remote, [element]: value === null ? undefined : value }),
+    url: format({ ...parse(remote.url), [element]: value === null ? undefined : value }),
   })
 const _showError = remote => alert(_('remoteConnectionFailed'), <pre>{formatError(remote.error)}</pre>)
 const _editRemoteName = (name, { remote }) => editRemote(remote, { name })