feat: use additionnal file for checksum instead of attributes

.prettierrc.js

@@ -1,11 +1,8 @@
-'use strict'
-
 module.exports = {
   arrowParens: 'avoid',
   jsxSingleQuote: true,
   semi: false,
   singleQuote: true,
-  trailingComma: 'es5',
 
   // 2020-11-24: Requested by nraynaud and approved by the rest of the team
   //

@vates/fuse-vhd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vates/fuse-vhd",
-  "version": "2.0.0",
+  "version": "1.0.0",
   "license": "ISC",
   "private": false,
   "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/fuse-vhd",

@vates/nbd-client/bench.mjs

@@ -1,32 +0,0 @@
-import NbdClient from "./client.mjs";
-
-
-
-async function bench(){
-    const client = new NbdClient({
-        address:'localhost',
-        port: 9000,
-        exportname: 'bench_export'
-    })
-    await client.connect()
-    console.log('connected', client.exportSize)
-
-    for(let chunk_size=16*1024; chunk_size < 16*1024*1024; chunk_size *=2){
-
-
-    let i=0
-    const start = + new Date()
-    for await(const block of client.readBlocks(chunk_size) ){
-        i++
-        if((i*chunk_size) % (16*1024*1024) ===0){
-                process.stdout.write('.')
-        }
-        if(i*chunk_size > 1024*1024*1024) break
-    }
-    console.log(chunk_size,Math.round( (i*chunk_size/1024/1024*1000)/ (new Date() - start)))
-
-    }
-    await client.disconnect()
-}
-
-bench()

@vates/nbd-client/constants.mjs

@@ -1,40 +1,12 @@
-// https://github.com/NetworkBlockDevice/nbd/blob/master/doc/proto.md
-
 export const INIT_PASSWD = Buffer.from('NBDMAGIC') // "NBDMAGIC" ensure we're connected to a nbd server
 export const OPTS_MAGIC = Buffer.from('IHAVEOPT') // "IHAVEOPT" start an option block
 export const NBD_OPT_REPLY_MAGIC = 1100100111001001n // magic received during negociation
-
 export const NBD_OPT_EXPORT_NAME = 1
 export const NBD_OPT_ABORT = 2
 export const NBD_OPT_LIST = 3
 export const NBD_OPT_STARTTLS = 5
 export const NBD_OPT_INFO = 6
 export const NBD_OPT_GO = 7
-export const NBD_OPT_STRUCTURED_REPLY = 8
-export const NBD_OPT_LIST_META_CONTEXT = 9
-export const NBD_OPT_SET_META_CONTEXT = 10
-export const NBD_OPT_EXTENDED_HEADERS = 11
-
-export const NBD_REP_ACK =1
-export const NBD_REP_SERVER = 2
-export const NBD_REP_INFO = 3
-export const NBD_REP_META_CONTEXT = 4 
-export const NBD_REP_ERR_UNSUP = 0x80000001 // 2^32+1
-export const NBD_REP_ERR_POLICY = 0x80000002
-export const NBD_REP_ERR_INVALID = 0x80000003
-export const NBD_REP_ERR_PLATFORM = 0x80000004
-export const NBD_REP_ERR_TLS_REQD = 0x80000005
-export const NBD_REP_ERR_UNKNOWN = 0x80000006
-export const NBD_REP_ERR_SHUTDOWN = 0x80000007
-export const NBD_REP_ERR_BLOCK_SIZE_REQD = 0x80000008
-export const NBD_REP_ERR_TOO_BIG = 0x80000009
-export const NBD_REP_ERR_EXT_HEADER_REQD = 0x8000000a
-
-export const NBD_INFO_EXPORT = 0
-export const NBD_INFO_NAME = 1
-export const NBD_INFO_DESCRIPTION = 2
-export const NBD_INFO_BLOCK_SIZE = 3
-
 
 export const NBD_FLAG_HAS_FLAGS = 1 << 0
 export const NBD_FLAG_READ_ONLY = 1 << 1
@@ -42,9 +14,6 @@ export const NBD_FLAG_SEND_FLUSH = 1 << 2
 export const NBD_FLAG_SEND_FUA = 1 << 3
 export const NBD_FLAG_ROTATIONAL = 1 << 4
 export const NBD_FLAG_SEND_TRIM = 1 << 5
-export const NBD_FLAG_SEND_WRITE_ZEROES = 1 << 6
-export const NBD_FLAG_SEND_DF = 1 << 7
-export const NBD_FLAG_CAN_MULTI_CONN = 1 << 8
 
 export const NBD_FLAG_FIXED_NEWSTYLE = 1 << 0
 
@@ -67,15 +36,6 @@ export const NBD_CMD_RESIZE = 8
 export const NBD_REQUEST_MAGIC = 0x25609513 // magic number to create a new NBD request to send to the server
 export const NBD_REPLY_MAGIC = 0x67446698 // magic number received from the server when reading response to a nbd request
 export const NBD_REPLY_ACK = 1
-export const NBD_SIMPLE_REPLY_MAGIC = 0x67446698
-export const NBD_STRUCTURED_REPLY_MAGIC = 0x668e33ef
-export const NBD_REPLY_TYPE_NONE = 0
-export const NBD_REPLY_TYPE_OFFSET_DATA = 1
-export const NBD_REPLY_TYPE_OFFSET_HOLE = 2
-export const NBD_REPLY_TYPE_BLOCK_STATUS = 5 
-export const NBD_REPLY_TYPE_ERROR = 1 << 15 +1
-export const NBD_REPLY_TYPE_ERROR_OFFSET = 1 << 15 +2
-
 
 export const NBD_DEFAULT_PORT = 10809
 export const NBD_DEFAULT_BLOCK_SIZE = 64 * 1024

@vates/nbd-client/index.mjs

@@ -74,7 +74,7 @@ export default class NbdClient {
       this.#serverSocket = connect({
         socket: this.#serverSocket,
         rejectUnauthorized: false,
-        cert: this.#serverCert
+        cert: this.#serverCert,
       })
       this.#serverSocket.once('error', reject)
       this.#serverSocket.once('secureConnect', () => {
@@ -88,11 +88,7 @@ export default class NbdClient {
   async #unsecureConnect() {
     this.#serverSocket = new Socket()
     return new Promise((resolve, reject) => {
-      this.#serverSocket.connect({
-        port:this.#serverPort, 
-        host: this.#serverAddress,
-        // @todo should test the onRead to limit buffer copy
-      })
+      this.#serverSocket.connect(this.#serverPort, this.#serverAddress)
       this.#serverSocket.once('error', reject)
       this.#serverSocket.once('connect', () => {
         this.#serverSocket.removeListener('error', reject)
@@ -236,20 +232,19 @@ export default class NbdClient {
     }
     try {
       this.#waitingForResponse = true
-      const buffer = await this.#read(4+4+8)
-      const magic = buffer.readUInt32BE()
+      const magic = await this.#readInt32()
 
       if (magic !== NBD_REPLY_MAGIC) {
         throw new Error(`magic number for block answer is wrong : ${magic} ${NBD_REPLY_MAGIC}`)
       }
 
-      const error = buffer.readUInt32BE(4)
+      const error = await this.#readInt32()
       if (error !== 0) {
         // @todo use error code from constants.mjs
         throw new Error(`GOT ERROR CODE  : ${error}`)
       }
 
-      const blockQueryId = buffer.readBigUInt64BE(8)
+      const blockQueryId = await this.#readInt64()
       const query = this.#commandQueryBacklog.get(blockQueryId)
       if (!query) {
         throw new Error(` no query associated with id ${blockQueryId}`)
@@ -312,11 +307,11 @@ export default class NbdClient {
     })
   }
 
-  async *readBlocks(indexGenerator = 2*1024*1024) {
+  async *readBlocks(indexGenerator) {
     // default : read all blocks
-    if (typeof indexGenerator === 'number') {
+    if (indexGenerator === undefined) {
       const exportSize = this.#exportSize
-      const chunkSize =  indexGenerator
+      const chunkSize = 2 * 1024 * 1024
       indexGenerator = function* () {
         const nbBlocks = Math.ceil(Number(exportSize / BigInt(chunkSize)))
         for (let index = 0; BigInt(index) < nbBlocks; index++) {
@@ -324,14 +319,12 @@ export default class NbdClient {
         }
       }
     }
-
     const readAhead = []
     const readAheadMaxLength = this.#readAhead
     const makeReadBlockPromise = (index, size) => {
       const promise = pRetry(() => this.readBlock(index, size), {
         tries: this.#readBlockRetries,
         onRetry: async err => {
-          console.error(err)
           warn('will retry reading block ', index, err)
           await this.reconnect()
         },
@@ -343,7 +336,6 @@ export default class NbdClient {
 
     // read all blocks, but try to keep readAheadMaxLength promise waiting ahead
     for (const { index, size } of indexGenerator()) {
-
       // stack readAheadMaxLength promises before starting to handle the results
       if (readAhead.length === readAheadMaxLength) {
         // any error will stop reading blocks
@@ -356,4 +348,4 @@ export default class NbdClient {
       yield readAhead.shift()
     }
   }
-}
+}

@vates/nbd-client/package.json

@@ -13,18 +13,18 @@
     "url": "https://vates.fr"
   },
   "license": "ISC",
-  "version": "2.0.0",
+  "version": "1.2.1",
   "engines": {
     "node": ">=14.0"
   },
   "main": "./index.mjs",
   "dependencies": {
     "@vates/async-each": "^1.0.0",
-    "@vates/read-chunk": "^1.2.0",
+    "@vates/read-chunk": "^1.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
     "@xen-orchestra/log": "^0.6.0",
     "promise-toolbox": "^0.21.0",
-    "xen-api": "^1.3.4"
+    "xen-api": "^1.3.3"
   },
   "devDependencies": {
     "tap": "^16.3.0",

@vates/nbd-client/server.mjs

@@ -1,292 +0,0 @@
-import assert, { deepEqual, strictEqual, notStrictEqual } from 'node:assert'
-import { createServer } from 'node:net'
-import { fromCallback } from 'promise-toolbox'
-import { readChunkStrict } from '@vates/read-chunk'
-import {
-  INIT_PASSWD,
-  NBD_CMD_READ,
-  NBD_DEFAULT_PORT,
-  NBD_FLAG_FIXED_NEWSTYLE,
-  NBD_FLAG_HAS_FLAGS,
-  NBD_OPT_EXPORT_NAME,
-  NBD_OPT_REPLY_MAGIC,
-  NBD_REPLY_ACK,
-  NBD_REQUEST_MAGIC,
-  OPTS_MAGIC,
-  NBD_CMD_DISC,
-  NBD_REP_ERR_UNSUP,
-  NBD_CMD_WRITE,
-  NBD_OPT_GO,
-  NBD_OPT_INFO,
-  NBD_INFO_EXPORT,
-  NBD_REP_INFO,
-  NBD_SIMPLE_REPLY_MAGIC,
-  NBD_REP_ERR_UNKNOWN,
-} from './constants.mjs'
-import { PassThrough } from 'node:stream'
-
-export default class NbdServer {
-  #server
-  #clients = new Map()
-  constructor(port = NBD_DEFAULT_PORT) {
-    this.#server = createServer()
-    this.#server.listen(port)
-    this.#server.on('connection', client => this.#handleNewConnection(client))
-  }
-
-  // will wait for a client to connect and upload the file to this server
-  downloadStream(key) {
-    strictEqual(this.#clients.has(key), false)
-    const stream = new PassThrough()
-    const offset = BigInt(0)
-    this.#clients.set(key, { length: BigInt(2 * 1024 * 1024 * 1024 * 1024), stream, offset, key })
-    return stream
-  }
-
-  // will wait for a client to connect and downlaod this stream
-  uploadStream(key, source, length) {
-    strictEqual(this.#clients.has(key), false)
-    notStrictEqual(length, undefined)
-    const offset = BigInt(0)
-    this.#clients.set(key, { length: BigInt(length), stream: source, offset, key })
-  }
-
-  #read(socket, length) {
-    return readChunkStrict(socket, length)
-  }
-  async #readInt32(socket) {
-    const buffer = await this.#read(socket, 4)
-    return buffer.readUInt32BE()
-  }
-
-  #write(socket, buffer) {
-    return fromCallback.call(socket, 'write', buffer)
-  }
-  async #writeInt16(socket, int16) {
-    const buffer = Buffer.alloc(2)
-    buffer.writeUInt16BE(int16)
-    return this.#write(socket, buffer)
-  }
-  async #writeInt32(socket, int32) {
-    const buffer = Buffer.alloc(4)
-    buffer.writeUInt32BE(int32)
-    return this.#write(socket, buffer)
-  }
-  async #writeInt64(socket, int64) {
-    const buffer = Buffer.alloc(8)
-    buffer.writeBigUInt64BE(int64)
-    return this.#write(socket, buffer)
-  }
-
-  async #openExport(key) {
-    if (!this.#clients.has(key)) {
-      // export does not exists
-      const err = new Error('Export not found ')
-      err.code = 'ENOTFOUND'
-      throw err
-    }
-    const { length } = this.#clients.get(key)
-    return length
-  }
-
-  async #sendOptionResponse(socket, option, response, data = Buffer.alloc(0)) {
-    await this.#writeInt64(socket, NBD_OPT_REPLY_MAGIC)
-    await this.#writeInt32(socket, option)
-    await this.#writeInt32(socket, response)
-    await this.#writeInt32(socket, data.length)
-    await this.#write(socket, data)
-  }
-
-  /**
-   *
-   * @param {Socket} socket
-   * @returns true if server is waiting for more options
-   */
-  async #readOption(socket) {
-    console.log('wait for option')
-    const magic = await this.#read(socket, 8)
-    console.log(magic.toString('ascii'), magic.length, OPTS_MAGIC.toString('ascii'))
-    deepEqual(magic, OPTS_MAGIC)
-    const option = await this.#readInt32(socket)
-    const length = await this.#readInt32(socket)
-    console.log({ option, length })
-    const data = length > 0 ? await this.#read(socket, length) : undefined
-    switch (option) {
-      case NBD_OPT_EXPORT_NAME: {
-        const exportNameLength = data.readInt32BE()
-        const key = data.slice(4, exportNameLength + 4).toString()
-        let exportSize
-        try {
-          exportSize = await this.#openExport(key)
-        } catch (err) {
-          if (err.code === 'ENOTFOUND') {
-            this.#sendOptionResponse(socket, option, NBD_REP_ERR_UNKNOWN)
-            return false
-          }
-          throw err
-        }
-        socket.key = key
-        await this.#writeInt64(socket, exportSize)
-        await this.#writeInt16(socket, NBD_FLAG_HAS_FLAGS /* transmission flag */)
-        await this.#write(socket, Buffer.alloc(124) /* padding */)
-
-        return false
-      }
-      /*
-            case NBD_OPT_STARTTLS:
-                console.log('starttls')
-                // @todo not working
-                return true 
-            */
-
-      case NBD_OPT_GO:
-      case NBD_OPT_INFO: {
-        const exportNameLength = data.readInt32BE()
-        const key = data.slice(4, exportNameLength + 4).toString()
-        let exportSize
-        try {
-          exportSize = await this.#openExport(key)
-        } catch (err) {
-          if (err.code === 'ENOTFOUND') {
-            this.#sendOptionResponse(socket, option, NBD_REP_ERR_UNKNOWN)
-            // @todo should disconnect
-            return false
-          }
-          throw err
-        }
-        socket.key = key
-        await this.#writeInt64(socket, NBD_OPT_REPLY_MAGIC)
-        await this.#writeInt32(socket, option)
-        await this.#writeInt32(socket, NBD_REP_INFO)
-        await this.#writeInt32(socket, 12)
-        // the export info
-        await this.#writeInt16(socket, NBD_INFO_EXPORT)
-        await this.#writeInt64(socket, exportSize)
-        await this.#writeInt16(socket, NBD_FLAG_HAS_FLAGS /* transmission flag */)
-
-        // an ACK at the end of the infos
-        await this.#sendOptionResponse(socket, option, NBD_REPLY_ACK) // no additionnal data
-        return option === NBD_OPT_INFO // we stays in option phase is option is INFO
-      }
-      default:
-        // not supported
-        console.log('not supported', option, length, data?.toString())
-        await this.#sendOptionResponse(socket, option, NBD_REP_ERR_UNSUP) // no additionnal data
-        // wait for next option
-        return true
-    }
-  }
-
-  async #readCommand(socket) {
-    const key = socket.key
-    // this socket has an export key
-    notStrictEqual(key, undefined)
-    // this export key is still valid
-    strictEqual(this.#clients.has(key), true)
-    const client = this.#clients.get(key)
-
-    const buffer = await this.#read(socket, 28)
-    const magic = buffer.readInt32BE(0)
-    strictEqual(magic, NBD_REQUEST_MAGIC)
-    /* const commandFlags = */ buffer.readInt16BE(4)
-    const command = buffer.readInt16BE(6)
-    const cookie = buffer.readBigUInt64BE(8)
-    const offset = buffer.readBigUInt64BE(16)
-    const length = buffer.readInt32BE(24)
-    switch (command) {
-      case NBD_CMD_DISC:
-        console.log('gotdisconnect', client.offset)
-        await client.stream?.destroy()
-        // @todo : disconnect
-        return false
-      case NBD_CMD_READ: {
-        /** simple replies  */
-
-        // read length byte from offset in export
-
-        // the client is writing in contiguous mode
-        assert.strictEqual(offset, client.offset)
-        client.offset += BigInt(length)
-        const data = await readChunkStrict(client.stream, length)
-        const reply = Buffer.alloc(16)
-        reply.writeInt32BE(NBD_SIMPLE_REPLY_MAGIC)
-        reply.writeInt32BE(0, 4) // no error
-        reply.writeBigInt64BE(cookie, 8)
-        await this.#write(socket, reply)
-        await this.#write(socket, data)
-        /*  if we implement non stream read, we can handle read in parallel
-                const reply = Buffer.alloc(16+length)
-                reply.writeInt32BE(NBD_SIMPLE_REPLY_MAGIC)
-                reply.writeInt32BE(0,4)// no error
-                reply.writeBigInt64BE(cookie,8)
-
-                // read length byte from offset in export directly in the given buffer
-                // may do multiple read in parallel on the same export
-                size += length
-                socket.fd.read(reply, 16, length, Number(offset))
-                    .then(()=>{
-                        return this.#write(socket, reply)
-                    })
-                    .catch(err => console.error('NBD_CMD_READ',err)) */
-        return true
-      }
-      case NBD_CMD_WRITE: {
-        // the client is writing in contiguous mode
-        assert.strictEqual(offset, client.offset)
-
-        const data = await this.#read(socket, length)
-        client.offset += BigInt(length)
-        await new Promise((resolve, reject) => {
-          if (!client.stream.write(data, 0, length, Number(offset))) {
-            client.stream.once('drain', err => (err ? reject(err) : resolve()))
-          } else {
-            process.nextTick(resolve)
-          }
-        })
-        const reply = Buffer.alloc(16)
-        reply.writeInt32BE(NBD_SIMPLE_REPLY_MAGIC)
-        reply.writeInt32BE(0, 4) // no error
-        reply.writeBigInt64BE(cookie, 8)
-        await this.#write(socket, reply)
-        return true
-      }
-      default:
-        console.log('GOT unsupported command ', command)
-        // fail to handle
-        return true
-    }
-  }
-
-  async #handleNewConnection(socket) {
-    const remoteAddress = socket.remoteAddress + ':' + socket.remotePort
-    console.log('new client connection from %s', remoteAddress)
-
-    socket.on('close', () => {
-      console.log('client ', remoteAddress, 'is done')
-    })
-    socket.on('error', error => {
-      throw error
-    })
-    // handshake
-    await this.#write(socket, INIT_PASSWD)
-    await this.#write(socket, OPTS_MAGIC)
-
-    // send flags , the bare minimum
-    await this.#writeInt16(socket, NBD_FLAG_FIXED_NEWSTYLE)
-    const clientFlag = await this.#readInt32(socket)
-    assert.strictEqual(clientFlag & NBD_FLAG_FIXED_NEWSTYLE, NBD_FLAG_FIXED_NEWSTYLE) // only FIXED_NEWSTYLE one is supported from the server options
-
-    // read client response flags
-    let waitingForOptions = true
-    while (waitingForOptions) {
-      waitingForOptions = await this.#readOption(socket)
-    }
-
-    let waitingForCommand = true
-    while (waitingForCommand) {
-      waitingForCommand = await this.#readCommand(socket)
-    }
-  }
-
-  #handleClientData(client, data) {}
-}

@vates/nbd-client/tests/nbdclient.integ.mjs

@@ -1,4 +1,4 @@
-import NbdClient from '../client.mjs'
+import NbdClient from '../index.mjs'
 import { spawn, exec } from 'node:child_process'
 import fs from 'node:fs/promises'
 import { test } from 'tap'

@vates/node-vsphere-soap/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vates/node-vsphere-soap",
-  "version": "2.0.0",
+  "version": "1.0.0",
   "description": "interface to vSphere SOAP/WSDL from node for interfacing with vCenter or ESXi, forked from node-vsphere-soap",
   "main": "lib/client.mjs",
   "author": "reedog117",

@vates/read-chunk/index.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const assert = require('assert')
-const isUtf8 = require('isutf8')
 
 /**
  * Read a chunk of data from a stream.
@@ -82,13 +81,6 @@ exports.readChunkStrict = async function readChunkStrict(stream, size) {
 
   if (size !== undefined && chunk.length !== size) {
     const error = new Error(`stream has ended with not enough data (actual: ${chunk.length}, expected: ${size})`)
-
-    // Buffer.isUtf8 is too recent for now
-    // @todo : replace external package by Buffer.isUtf8 when the supported version of node reach 18
-
-    if (chunk.length < 1024 && isUtf8(chunk)) {
-      error.text = chunk.toString('utf8')
-    }
     Object.defineProperties(error, {
       chunk: {
         value: chunk,

@vates/read-chunk/index.test.js

@@ -102,37 +102,12 @@ describe('readChunkStrict', function () {
     assert.strictEqual(error.chunk, undefined)
   })
 
-  it('throws if stream ends with not enough data, utf8', async () => {
+  it('throws if stream ends with not enough data', async () => {
     const error = await rejectionOf(readChunkStrict(makeStream(['foo', 'bar']), 10))
     assert(error instanceof Error)
     assert.strictEqual(error.message, 'stream has ended with not enough data (actual: 6, expected: 10)')
-    assert.strictEqual(error.text, 'foobar')
     assert.deepEqual(error.chunk, Buffer.from('foobar'))
   })
-
-  it('throws if stream ends with not enough data, non utf8 ', async () => {
-    const source = [Buffer.alloc(10, 128), Buffer.alloc(10, 128)]
-    const error = await rejectionOf(readChunkStrict(makeStream(source), 30))
-    assert(error instanceof Error)
-    assert.strictEqual(error.message, 'stream has ended with not enough data (actual: 20, expected: 30)')
-    assert.strictEqual(error.text, undefined)
-    assert.deepEqual(error.chunk, Buffer.concat(source))
-  })
-
-  it('throws if stream ends with not enough data,  utf8 , long data', async () => {
-    const source = Buffer.from('a'.repeat(1500))
-    const error = await rejectionOf(readChunkStrict(makeStream([source]), 2000))
-    assert(error instanceof Error)
-    assert.strictEqual(error.message, `stream has ended with not enough data (actual: 1500, expected: 2000)`)
-    assert.strictEqual(error.text, undefined)
-    assert.deepEqual(error.chunk, source)
-  })
-
-  it('succeed', async () => {
-    const source = Buffer.from('a'.repeat(20))
-    const chunk = await readChunkStrict(makeStream([source]), 10)
-    assert.deepEqual(source.subarray(10), chunk)
-  })
 })
 
 describe('skip', function () {
@@ -159,16 +134,6 @@ describe('skip', function () {
   it('returns less size if stream ends', async () => {
     assert.deepEqual(await skip(makeStream('foo bar'), 10), 7)
   })
-
-  it('put back if it read too much', async () => {
-    let source = makeStream(['foo', 'bar'])
-    await skip(source, 1) // read part of data chunk
-    const chunk = (await readChunkStrict(source, 2)).toString('utf-8')
-    assert.strictEqual(chunk, 'oo')
-
-    source = makeStream(['foo', 'bar'])
-    assert.strictEqual(await skip(source, 3), 3) // read aligned with data chunk
-  })
 })
 
 describe('skipStrict', function () {
@@ -179,9 +144,4 @@ describe('skipStrict', function () {
     assert.strictEqual(error.message, 'stream has ended with not enough data (actual: 7, expected: 10)')
     assert.deepEqual(error.bytesSkipped, 7)
   })
-  it('succeed', async () => {
-    const source = makeStream(['foo', 'bar', 'baz'])
-    const res = await skipStrict(source, 4)
-    assert.strictEqual(res, undefined)
-  })
 })

@vates/read-chunk/package.json

@@ -19,7 +19,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "1.2.0",
+  "version": "1.1.1",
   "engines": {
     "node": ">=8.10"
   },
@@ -33,8 +33,5 @@
   },
   "devDependencies": {
     "test": "^3.2.1"
-  },
-  "dependencies": {
-    "isutf8": "^4.0.0"
   }
 }

@xen-orchestra/backups-cli/package.json

@@ -7,9 +7,9 @@
   "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
   "dependencies": {
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/backups": "^0.40.0",
+    "@xen-orchestra/backups": "^0.39.0",
     "@xen-orchestra/fs": "^4.0.1",
-    "filenamify": "^6.0.0",
+    "filenamify": "^4.1.0",
     "getopts": "^2.2.5",
     "lodash": "^4.17.15",
     "promise-toolbox": "^0.21.0"
@@ -27,7 +27,7 @@
   "scripts": {
     "postversion": "npm publish --access public"
   },
-  "version": "1.0.10",
+  "version": "1.0.9",
   "license": "AGPL-3.0-or-later",
   "author": {
     "name": "Vates SAS",

@xen-orchestra/backups/RemoteAdapter.mjs

@@ -5,7 +5,7 @@ import { createLogger } from '@xen-orchestra/log'
 import { createVhdDirectoryFromStream, openVhd, VhdAbstract, VhdDirectory, VhdSynthetic } from 'vhd-lib'
 import { decorateMethodsWith } from '@vates/decorate-with'
 import { deduped } from '@vates/disposable/deduped.js'
-import { dirname, join, resolve } from 'node:path'
+import { dirname, join, normalize, resolve } from 'node:path'
 import { execFile } from 'child_process'
 import { mount } from '@vates/fuse-vhd'
 import { readdir, lstat } from 'node:fs/promises'
@@ -18,7 +18,6 @@ import fromEvent from 'promise-toolbox/fromEvent'
 import groupBy from 'lodash/groupBy.js'
 import pDefer from 'promise-toolbox/defer'
 import pickBy from 'lodash/pickBy.js'
-import tar from 'tar'
 import zlib from 'zlib'
 
 import { BACKUP_DIR } from './_getVmBackupDir.mjs'
@@ -42,23 +41,20 @@ const compareTimestamp = (a, b) => a.timestamp - b.timestamp
 const noop = Function.prototype
 
 const resolveRelativeFromFile = (file, path) => resolve('/', dirname(file), path).slice(1)
-const makeRelative = path => resolve('/', path).slice(1)
-const resolveSubpath = (root, path) => resolve(root, makeRelative(path))
 
-async function addZipEntries(zip, realBasePath, virtualBasePath, relativePaths) {
-  for (const relativePath of relativePaths) {
-    const realPath = join(realBasePath, relativePath)
-    const virtualPath = join(virtualBasePath, relativePath)
+const resolveSubpath = (root, path) => resolve(root, `.${resolve('/', path)}`)
 
-    const stats = await lstat(realPath)
-    const { mode, mtime } = stats
-    const opts = { mode, mtime }
-    if (stats.isDirectory()) {
-      zip.addEmptyDirectory(virtualPath, opts)
-      await addZipEntries(zip, realPath, virtualPath, await readdir(realPath))
-    } else if (stats.isFile()) {
-      zip.addFile(realPath, virtualPath, opts)
-    }
+async function addDirectory(files, realPath, metadataPath) {
+  const stats = await lstat(realPath)
+  if (stats.isDirectory()) {
+    await asyncMap(await readdir(realPath), file =>
+      addDirectory(files, realPath + '/' + file, metadataPath + '/' + file)
+    )
+  } else if (stats.isFile()) {
+    files.push({
+      realPath,
+      metadataPath,
+    })
   }
 }
 
@@ -186,6 +182,17 @@ export class RemoteAdapter {
     })
   }
 
+  async *_usePartitionFiles(diskId, partitionId, paths) {
+    const path = yield this.getPartition(diskId, partitionId)
+
+    const files = []
+    await asyncMap(paths, file =>
+      addDirectory(files, resolveSubpath(path, file), normalize('./' + file).replace(/\/+$/, ''))
+    )
+
+    return files
+  }
+
   // 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) {
@@ -202,24 +209,15 @@ export class RemoteAdapter {
     })
   }
 
-  fetchPartitionFiles(diskId, partitionId, paths, format) {
+  fetchPartitionFiles(diskId, partitionId, paths) {
     const { promise, reject, resolve } = pDefer()
     Disposable.use(
       async function* () {
-        const path = yield this.getPartition(diskId, partitionId)
-        let outputStream
-
-        if (format === 'tgz') {
-          outputStream = tar.c({ cwd: path, gzip: true }, paths.map(makeRelative))
-        } else if (format === 'zip') {
-          const zip = new ZipFile()
-          await addZipEntries(zip, path, '', paths.map(makeRelative))
-          zip.end()
-          ;({ outputStream } = zip)
-        } else {
-          throw new Error('unsupported format ' + format)
-        }
-
+        const files = yield this._usePartitionFiles(diskId, partitionId, paths)
+        const zip = new ZipFile()
+        files.forEach(({ realPath, metadataPath }) => zip.addFile(realPath, metadataPath))
+        zip.end()
+        const { outputStream } = zip
         resolve(outputStream)
         await fromEvent(outputStream, 'end')
       }.bind(this)
@@ -662,13 +660,14 @@ export class RemoteAdapter {
     return path
   }
 
-  async writeVhd(path, input, { checksum = true, validator = noop, writeBlockConcurrency } = {}) {
+  async writeVhd(path, input, { checksum = true, validator = noop, writeBlockConcurrency, dedup = false } = {}) {
     const handler = this._handler
     if (this.useVhdDirectory()) {
       const dataPath = `${dirname(path)}/data/${uuidv4()}.vhd`
       const size = await createVhdDirectoryFromStream(handler, dataPath, input, {
         concurrency: writeBlockConcurrency,
         compression: this.#getCompressionType(),
+        dedup,
         async validator() {
           await input.task
           return validator.apply(this, arguments)
@@ -826,6 +825,8 @@ decorateMethodsWith(RemoteAdapter, {
     debounceResourceFactory,
   ]),
 
+  _usePartitionFiles: Disposable.factory,
+
   getDisk: compose([Disposable.factory, [deduped, diskId => [diskId]], debounceResourceFactory]),
 
   getPartition: Disposable.factory,

@xen-orchestra/backups/_cleanVm.mjs

@@ -123,19 +123,19 @@ export async function checkAliases(
 ) {
   const aliasFound = []
   for (const alias of aliasPaths) {
-    const target = await resolveVhdAlias(handler, alias)
-
-    if (!isVhdFile(target)) {
-      logWarn('alias references non VHD target', { alias, target })
-      if (remove) {
-        logInfo('removing alias and non VHD target', { alias, target })
-        await handler.unlink(target)
-        await handler.unlink(alias)
-      }
-      continue
-    }
-
+    let target
     try {
+      target = await resolveVhdAlias(handler, alias)
+  
+      if (!isVhdFile(target)) {
+        logWarn('alias references non VHD target', { alias, target })
+        if (remove) {
+          logInfo('removing alias and non VHD target', { alias, target })
+          await handler.unlink(target)
+          await handler.unlink(alias)
+        }
+        continue
+      }
       const { dispose } = await openVhd(handler, target)
       try {
         await dispose()

@xen-orchestra/backups/_incrementalVm.mjs

@@ -16,8 +16,6 @@ export const TAG_BASE_DELTA = 'xo:base_delta'
 
 export const TAG_COPY_SRC = 'xo:copy_of'
 
-const TAG_BACKUP_SR = 'xo:backup:sr'
-
 const ensureArray = value => (value === undefined ? [] : Array.isArray(value) ? value : [value])
 const resolveUuid = async (xapi, cache, uuid, type) => {
   if (uuid == null) {
@@ -159,10 +157,7 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
   if (detectBase) {
     const remoteBaseVmUuid = vmRecord.other_config[TAG_BASE_DELTA]
     if (remoteBaseVmUuid) {
-      baseVm = find(
-        xapi.objects.all,
-        obj => (obj = obj.other_config) && obj[TAG_COPY_SRC] === remoteBaseVmUuid && obj[TAG_BACKUP_SR] === sr.$id
-      )
+      baseVm = find(xapi.objects.all, obj => (obj = obj.other_config) && obj[TAG_COPY_SRC] === remoteBaseVmUuid)
 
       if (!baseVm) {
         throw new Error(`could not find the base VM (copy of ${remoteBaseVmUuid})`)

@xen-orchestra/backups/_runners/VmsXapi.mjs

@@ -17,6 +17,7 @@ const DEFAULT_XAPI_VM_SETTINGS = {
   concurrency: 2,
   copyRetention: 0,
   deleteFirst: false,
+  dedup: false,
   diskPerVmConcurrency: 0, // not limited by default
   exportRetention: 0,
   fullInterval: 0,

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

@@ -160,6 +160,7 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
     )
 
     metadataContent = {
+      dedup: settings.dedup,
       jobId,
       mode: job.mode,
       scheduleId,
@@ -208,6 +209,7 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
             // no checksum for VHDs, because they will be invalidated by
             // merges and chainings
             checksum: false,
+            dedup: settings.dedup,
             validator: tmpPath => checkVhd(handler, tmpPath),
             writeBlockConcurrency: this._config.writeBlockConcurrency,
           })

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

@@ -18,7 +18,7 @@ export const MixinXapiWriter = (BaseClass = Object) =>
       const vdiRefs = await xapi.VM_getDisks(baseVm.$ref)
       for (const vdiRef of vdiRefs) {
         const vdi = xapi.getObject(vdiRef)
-        if (vdi.$SR.uuid !== this._healthCheckSr.uuid) {
+        if (vdi.$SR.uuid !== this._heathCheckSr.uuid) {
           return false
         }
       }

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

@@ -45,6 +45,34 @@ When `useVhdDirectory` is enabled on the remote, the directory containing the VH
     └─ <uuid>.vhd
 ```
 
+#### vhd directory with deduplication
+
+the difference with non dedup mode is that a hash is computed of each vhd block. The hash is splited in 4 chars token and the data are stored  in xo-block-store/{token1}/.../{token7}/{token8}.source.
+Then a hard link is made from this source to the destination folder in <vdis>/<job UUID>/<VDI UUID>/blocks/{number}/{number}
+
+
+```
+<remote>
+└─ xo-block-store
+  └─ {4 char}
+    └─  ...
+        └─ {char.source} 
+└─ xo-vm-backups
+  ├─ index.json // TODO
+  └─ <VM UUID>
+     ├─ cache.json.gz
+     ├─ vdis
+     │  └─ <job UUID>
+     │     └─ <VDI UUID>
+     │        ├─ index.json // TODO
+     │        ├─ <YYYYMMDD>T<HHmmss>.alias.vhd // contains the relative path to a VHD directory
+     |        └─ data
+     |          ├─ <uuid>.vhd // VHD directory format is described in vhd-lib/Vhd/VhdDirectory.js
+     ├─ <YYYYMMDD>T<HHmmss>.json // backup metadata
+     ├─ <YYYYMMDD>T<HHmmss>.xva
+     └─ <YYYYMMDD>T<HHmmss>.xva.checksum
+```
+
 ## Cache for a VM
 
 In a VM directory, if the file `cache.json.gz` exists, it contains the metadata for all the backups for this VM.

@xen-orchestra/backups/docs/dedup.md

@@ -0,0 +1,23 @@
+# Deduplication
+
+- This this use a additionnal inode (or equivalent on the FS), for each different block in the xo-block-store`sub folder`
+- This will not work well with immutabilty/object lock
+- only dedup blocks of vhd directory
+- prerequisite are : the fs must support hard link and extended attributes
+- a key (full backup) does not take more space on te remote than a delta. It will take more inodes , and more time since we'll have to read all the blocks. T
+
+When a new block is written to the remote, a hash is computed. If a file with this hash doesn't exists in xo-block-store` create it, then add the has as an extended attributes.
+A link hard link, sharing data and extended attributes is then create to the destination
+
+When deleting a block which has a hash extended attributes, a check is done on the xo-block-store. If there are no other link, then the block is deleted . The directory containing it stays
+
+When merging block : the unlink method is called before overwriting an existing block
+
+### troubleshooting
+
+Since all the blocks are hard linked, you can convert a deduplicated remote to a non deduplicated one by deleting the xo-block-store directory
+
+two new method has been added to the local fs handler :
+
+- deduplicationGarbageCollector(), which should be called from the root of the FS : it will clean any block without other links, and any empty directory
+- deduplicationStats() that will compute the number of blocks in store and how many times they are used

@xen-orchestra/backups/formatVmBackups.mjs

@@ -16,6 +16,7 @@ function formatVmBackup(backup) {
           }),
 
     id: backup.id,
+    dedup: backup.dedup,
     jobId: backup.jobId,
     mode: backup.mode,
     scheduleId: backup.scheduleId,

@xen-orchestra/backups/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.40.0",
+  "version": "0.39.0",
   "engines": {
     "node": ">=14.18"
   },
@@ -23,15 +23,15 @@
     "@vates/compose": "^2.1.0",
     "@vates/decorate-with": "^2.0.0",
     "@vates/disposable": "^0.1.4",
-    "@vates/fuse-vhd": "^2.0.0",
-    "@vates/nbd-client": "^2.0.0",
+    "@vates/fuse-vhd": "^1.0.0",
+    "@vates/nbd-client": "^1.2.1",
     "@vates/parse-duration": "^0.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
     "@xen-orchestra/fs": "^4.0.1",
     "@xen-orchestra/log": "^0.6.0",
     "@xen-orchestra/template": "^0.1.0",
-    "compare-versions": "^6.0.0",
-    "d3-time-format": "^4.1.0",
+    "compare-versions": "^5.0.1",
+    "d3-time-format": "^3.0.0",
     "decorator-synchronized": "^0.6.0",
     "golike-defer": "^0.5.1",
     "limit-concurrency-decorator": "^0.5.0",
@@ -40,10 +40,9 @@
     "parse-pairs": "^2.0.0",
     "promise-toolbox": "^0.21.0",
     "proper-lockfile": "^4.1.2",
-    "tar": "^6.1.15",
     "uuid": "^9.0.0",
     "vhd-lib": "^4.5.0",
-    "xen-api": "^1.3.4",
+    "xen-api": "^1.3.3",
     "yazl": "^2.5.1"
   },
   "devDependencies": {
@@ -54,7 +53,7 @@
     "tmp": "^0.2.1"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^3.0.0"
+    "@xen-orchestra/xapi": "^2.2.1"
   },
   "license": "AGPL-3.0-or-later",
   "author": {

@xen-orchestra/cr-seed-cli/package.json

@@ -18,7 +18,7 @@
   "preferGlobal": true,
   "dependencies": {
     "golike-defer": "^0.5.1",
-    "xen-api": "^1.3.4"
+    "xen-api": "^1.3.3"
   },
   "scripts": {
     "postversion": "npm publish"

@xen-orchestra/fs/package.json

@@ -29,11 +29,12 @@
     "@vates/async-each": "^1.0.0",
     "@vates/coalesce-calls": "^0.1.0",
     "@vates/decorate-with": "^2.0.0",
-    "@vates/read-chunk": "^1.2.0",
+    "@vates/read-chunk": "^1.1.1",
     "@xen-orchestra/log": "^0.6.0",
     "bind-property-descriptor": "^2.0.0",
     "decorator-synchronized": "^0.6.0",
     "execa": "^5.0.0",
+    "fs-extended-attributes": "^1.0.1",
     "fs-extra": "^11.1.0",
     "get-stream": "^6.0.0",
     "limit-concurrency-decorator": "^0.5.0",

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

@@ -268,9 +268,9 @@ export default class RemoteHandlerAbstract {
     await this._mktree(normalizePath(dir), { mode })
   }
 
-  async outputFile(file, data, { dirMode, flags = 'wx' } = {}) {
+  async outputFile(file, data, { dedup = false, dirMode, flags = 'wx' } = {}) {
     const encryptedData = this.#encryptor.encryptData(data)
-    await this._outputFile(normalizePath(file), encryptedData, { dirMode, flags })
+    await this._outputFile(normalizePath(file), encryptedData, { dedup, dirMode, flags })
   }
 
   async read(file, buffer, position) {
@@ -319,8 +319,8 @@ export default class RemoteHandlerAbstract {
     await timeout.call(this._rmdir(normalizePath(dir)).catch(ignoreEnoent), this._timeout)
   }
 
-  async rmtree(dir) {
-    await this._rmtree(normalizePath(dir))
+  async rmtree(dir, { dedup } = {}) {
+    await this._rmtree(normalizePath(dir), { dedup })
   }
 
   // Asks the handler to sync the state of the effective remote with its'
@@ -397,6 +397,10 @@ export default class RemoteHandlerAbstract {
     }
   }
 
+  async checkSupport() {
+    return {}
+  }
+
   async test() {
     const SIZE = 1024 * 1024 * 10
     const testFileName = normalizePath(`${Date.now()}.test`)
@@ -437,14 +441,14 @@ export default class RemoteHandlerAbstract {
     await this._truncate(file, len)
   }
 
-  async __unlink(file, { checksum = true } = {}) {
+  async __unlink(file, { checksum = true, dedup = false } = {}) {
     file = normalizePath(file)
 
     if (checksum) {
       ignoreErrors.call(this._unlink(checksumFile(file)))
     }
 
-    await this._unlink(file).catch(ignoreEnoent)
+    await this._unlink(file, { dedup }).catch(ignoreEnoent)
   }
 
   async write(file, buffer, position) {
@@ -560,17 +564,16 @@ export default class RemoteHandlerAbstract {
     throw new Error('Not implemented')
   }
 
-  async _outputFile(file, data, { dirMode, flags }) {
+  async _outputFile(file, data, { dirMode, flags, dedup = false }) {
     try {
-      return await this._writeFile(file, data, { flags })
+      return await this._writeFile(file, data, { dedup, flags })
     } catch (error) {
       if (error.code !== 'ENOENT') {
         throw error
       }
     }
-
     await this._mktree(dirname(file), { mode: dirMode })
-    return this._outputFile(file, data, { flags })
+    return this._outputFile(file, data, { dedup, flags })
   }
 
   async _outputStream(path, input, { dirMode, validator }) {
@@ -613,7 +616,7 @@ export default class RemoteHandlerAbstract {
     throw new Error('Not implemented')
   }
 
-  async _rmtree(dir) {
+  async _rmtree(dir, { dedup } = {}) {
     try {
       return await this._rmdir(dir)
     } catch (error) {
@@ -624,7 +627,7 @@ export default class RemoteHandlerAbstract {
 
     const files = await this._list(dir)
     await asyncEach(files, file =>
-      this._unlink(`${dir}/${file}`).catch(error => {
+      this._unlink(`${dir}/${file}`, { dedup }).catch(error => {
         // Unlink dir behavior is not consistent across platforms
         // https://github.com/nodejs/node-v0.x-archive/issues/5791
         if (error.code === 'EISDIR' || error.code === 'EPERM') {
@@ -639,7 +642,7 @@ export default class RemoteHandlerAbstract {
   // called to initialize the remote
   async _sync() {}
 
-  async _unlink(file) {
+  async _unlink(file, opts) {
     throw new Error('Not implemented')
   }
 

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

@@ -209,7 +209,7 @@ describe('encryption', () => {
     // encrypt with a non default algorithm
     const encryptor = _getEncryptor('aes-256-cbc', '73c1838d7d8a6088ca2317fb5f29cd91')
 
-    await fs.writeFile(`${dir}/encryption.json`, `{"algorithm": "aes-256-gcm"}`)
+    await fs.writeFile(`${dir}/encryption.json`, `{"algorithm": "aes-256-gmc"}`)
     await fs.writeFile(`${dir}/metadata.json`, encryptor.encryptData(`{"random": "NOTSORANDOM"}`))
 
     // remote is now non empty : can't modify key anymore

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

@@ -19,7 +19,8 @@ try {
 } catch (_) {}
 
 export const getHandler = (remote, ...rest) => {
-  const Handler = HANDLERS[parse(remote.url).type]
+  const { type  }  = parse(remote.url)
+  const Handler = HANDLERS[type]
   if (!Handler) {
     throw new Error('Unhandled remote type')
   }

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

@@ -1,10 +1,17 @@
 import df from '@sindresorhus/df'
 import fs from 'fs-extra'
+// import fsx from 'fs-extended-attributes'
 import lockfile from 'proper-lockfile'
 import { createLogger } from '@xen-orchestra/log'
-import { fromEvent, retry } from 'promise-toolbox'
+import { asyncEach } from '@vates/async-each'
+import { fromEvent, fromCallback, ignoreErrors, retry } from 'promise-toolbox'
+import { synchronized } from 'decorator-synchronized'
 
 import RemoteHandlerAbstract from './abstract'
+import { normalize as normalizePath } from './path'
+
+import assert from 'node:assert'
+import { createHash, randomBytes } from 'node:crypto'
 
 const { info, warn } = createLogger('xo:fs:local')
 
@@ -37,6 +44,10 @@ export default class LocalHandler extends RemoteHandlerAbstract {
   #addSyncStackTrace
   #retriesOnEagain
 
+  #supportDedup
+  #dedupDirectory = '/xo-block-store'
+  #hashMethod = 'sha256'
+  #attributeKey = `user.hash.${this.#hashMethod}`
   constructor(remote, opts = {}) {
     super(remote)
 
@@ -194,16 +205,267 @@ export default class LocalHandler extends RemoteHandlerAbstract {
     return this.#addSyncStackTrace(fs.truncate, this.getFilePath(file), len)
   }
 
-  async _unlink(file) {
-    const filePath = this.getFilePath(file)
+  async #localUnlink(filePath) {
     return await this.#addSyncStackTrace(retry, () => fs.unlink(filePath), this.#retriesOnEagain)
   }
+  async _unlink(file, { dedup } = {}) {
+    const filePath = this.getFilePath(file)
+    let hash
+    // only try to read dedup source if we try to delete something deduplicated
+    if (dedup === true) {
+      try {
+        // get hash before deleting the file
+        hash = await this.#getExtendedAttribute(file, this.#attributeKey)
+      } catch (err) {
+        // whatever : fall back to normal delete
+      }
+    }
+
+    // delete file in place
+    await this.#localUnlink(filePath)
+
+    // implies we are on a deduplicated file
+    if (hash !== undefined) {
+      const dedupPath = this.getFilePath(this.#computeDeduplicationPath(hash))
+      await this.#removeExtendedAttribute(file, this.#attributeKey)
+      try {
+        const { nlink } = await fs.stat(dedupPath)
+        // get the number of copy still using these data
+        // delete source if it's alone
+        if (nlink === 1) {
+          await this.#localUnlink(dedupPath)
+        }
+      } catch (error) {
+        // no problem if another process deleted the source or if we unlink directly the source file
+        if (error.code !== 'ENOENT') {
+          throw error
+        }
+      }
+    }
+  }
 
   _writeFd(file, buffer, position) {
     return this.#addSyncStackTrace(fs.write, file.fd, buffer, 0, buffer.length, position)
   }
 
-  _writeFile(file, data, { flags }) {
+  #localWriteFile(file, data, { flags }) {
     return this.#addSyncStackTrace(fs.writeFile, this.getFilePath(file), data, { flag: flags })
   }
+
+  async _writeFile(file, data, { flags, dedup }) {
+    if (dedup === true) {
+      // only compute support once , and only if needed
+      if (this.#supportDedup === undefined) {
+        const supported = await this.checkSupport()
+        this.#supportDedup = supported.hardLink === true && supported.extendedAttributes === true
+      }
+      if (this.#supportDedup) {
+        const hash = this.#hash(data)
+        // create the file (if not already present) in the store
+        const dedupPath = await this.#writeDeduplicationSource(hash, data)
+        // hard link to the target place
+        // this linked file will have the same extended attributes
+        // (used for unlink)
+        return this.#link(dedupPath, file)
+      }
+    }
+    // fallback
+    return this.#localWriteFile(file, data, { flags })
+  }
+
+  #hash(data) {
+    return createHash(this.#hashMethod).update(data).digest('hex')
+  }
+  async #getExtendedAttribute(file, attributeName) {
+    try{
+      return this._readFile(file+attributeName)
+    }catch(err){
+      if(err.code === 'ENOENT'){
+        return 
+      }
+      throw err
+    }
+  }
+  async #setExtendedAttribute(file, attributeName, value) {
+    return  this._writeFile(file+attributeName, value)
+  }
+
+  async #removeExtendedAttribute(file, attributeName){
+    return  this._unlink(file+attributeName)
+  }
+/*
+  async #getExtendedAttribute(file, attributeName) {
+    return new Promise((resolve, reject) => {
+      fsx.get(this.getFilePath(file), attributeName, (err, res) => {
+        if (err) {
+          reject(err)
+        } else {
+          // res is a buffer
+          // it is null if the file doesn't have this attribute
+          if (res !== null) {
+            resolve(res.toString('utf-8'))
+          }
+          resolve(undefined)
+        }
+      })
+    })
+  }
+  async #setExtendedAttribute(file, attributeName, value) {
+    return new Promise((resolve, reject) => {
+      fsx.set(this.getFilePath(file), attributeName, value, (err, res) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(res)
+        }
+      })
+    })
+  }
+
+  async #removeExtendedAttribute(file, attributeName){
+    
+  }
+  */
+
+  // create a hard link between to files
+  #link(source, dest) {
+    return fs.link(this.getFilePath(source), this.getFilePath(dest))
+  }
+
+  // split path to keep a sane number of file per directory
+  #computeDeduplicationPath(hash) {
+    assert.strictEqual(hash.length % 4, 0)
+    let path = this.#dedupDirectory
+    for (let i = 0; i < hash.length; i++) {
+      if (i % 4 === 0) {
+        path += '/'
+      }
+      path += hash[i]
+    }
+    path += '.source'
+    return path
+  }
+
+  async #writeDeduplicationSource(hash, data) {
+    const path = this.#computeDeduplicationPath(hash)
+    try {
+      // flags ensures it fails if it already exists
+      // _outputfile will create the directory tree
+      await this._outputFile(path, data, { flags: 'wx' })
+    } catch (error) {
+      // if it is alread present : not a problem
+      if (error.code === 'EEXIST') {
+        // it should already have the extended attributes, nothing more to do
+        return path
+      }
+      throw error
+    }
+
+    try {
+      await this.#setExtendedAttribute(path, this.#attributeKey, hash)
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        throw error
+      }
+      // if a concurrent process deleted the dedup : recreate it
+      return this.#writeDeduplicationSource(path, hash)
+    }
+    return path
+  }
+
+  /**
+   * delete empty dirs
+   * delete file source thath don't have any more links
+   *
+   * @returns Promise
+   */
+
+  async deduplicationGarbageCollector(dir = this.#dedupDirectory, alreadyVisited = false) {
+    try {
+      await this._rmdir(dir)
+      return
+    } catch (error) {
+      if (error.code !== 'ENOTEMPTY') {
+        throw error
+      }
+    }
+    // the directory may not be empty after a first visit
+    if (alreadyVisited) {
+      return
+    }
+
+    const files = await this._list(dir)
+    await asyncEach(
+      files,
+      async file => {
+        const stat = await fs.stat(this.getFilePath(`${dir}/${file}`))
+        // have to check the stat to ensure we don't try to delete
+        // the directories : they don't have links
+        if (stat.isDirectory()) {
+          return this.deduplicationGarbageCollector(`${dir}/${file}`)
+        }
+        if (stat.nlink === 1) {
+          return fs.unlink(this.getFilePath(`${dir}/${file}`))
+        }
+      },
+      { concurrency: 2 }
+    ) // since we do a recursive traveral with a deep tree)
+    return this.deduplicationGarbageCollector(dir, true)
+  }
+
+  async deduplicationStats(dir = this.#dedupDirectory) {
+    let nbSourceBlocks = 0
+    let nbBlocks = 0
+    try {
+      const files = await this._list(dir)
+      await asyncEach(
+        files,
+        async file => {
+          const stat = await fs.stat(this.getFilePath(`${dir}/${file}`))
+          if (stat.isDirectory()) {
+            const { nbSourceBlocks: nbSourceInChild, nbBlocks: nbBlockInChild } = await this.deduplicationStats(
+              `${dir}/${file}`
+            )
+            nbSourceBlocks += nbSourceInChild
+            nbBlocks += nbBlockInChild
+          } else {
+            nbSourceBlocks++
+            nbBlocks += stat.nlink - 1 // ignore current
+          }
+        },
+        { concurrency: 2 }
+      )
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw err
+      }
+    }
+    return { nbSourceBlocks, nbBlocks }
+  }
+
+  @synchronized()
+  async checkSupport() {
+    const supported = await super.checkSupport()
+    const sourceFileName = normalizePath(`${Date.now()}.sourcededup`)
+    const destFileName = normalizePath(`${Date.now()}.destdedup`)
+    try {
+      const SIZE = 1024 * 1024
+      const data = await fromCallback(randomBytes, SIZE)
+      const hash = this.#hash(data)
+      await this._outputFile(sourceFileName, data, { flags: 'wx', dedup: false })
+      await this.#setExtendedAttribute(sourceFileName, this.#attributeKey, hash)
+      await this.#link(sourceFileName, destFileName)
+      const linkedData = await this._readFile(destFileName)
+      const { nlink } = await fs.stat(this.getFilePath(destFileName))
+      // contains the right data and the link counter
+      supported.hardLink = nlink === 2 && linkedData.equals(data)
+      supported.extendedAttributes = hash === (await this.#getExtendedAttribute(sourceFileName, this.#attributeKey))
+    } catch (error) {
+      warn(`error while testing the dedup`, { error })
+    } finally {
+      ignoreErrors.call(this._unlink(sourceFileName))
+      ignoreErrors.call(this._unlink(destFileName))
+    }
+    return supported
+  }
 }

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

@@ -0,0 +1,107 @@
+import { after, beforeEach, describe, it } from 'node:test'
+import assert from 'node:assert'
+import fs from 'node:fs/promises'
+import { getSyncedHandler } from './index.js'
+import { Disposable, pFromCallback } from 'promise-toolbox'
+import tmp from 'tmp'
+import execa from 'execa'
+import { rimraf } from 'rimraf'
+import { randomBytes } from 'node:crypto'
+
+// https://xkcd.com/221/
+const data =
+  'H2GbLa0F2J4LHFLRwLP9zN4dGWJpdx1T6eGWra8BRlV9fBpRGtWIOSKXjU8y7fnxAWVGWpbYPYCwRigvxRSTcuaQsCtwvDNKMmFwYpsGMS14akgBD3EpOMPpKIRRySOsOeknpr48oopO1n9eq0PxGbOcY4Q9aojRu9rn1SMNyjq7YGzwVQEm6twA3etKGSYGvPJVTs2riXm7u6BhBh9VZtQDxQEy5ttkHiZUpgLi6QshSpMjL7dHco8k6gzGcxfpoyS5IzaQeXqDOeRjE6HNn27oUXpze5xRYolQhxA7IqdfzcYwWTqlaZb7UBUZoFCiFs5Y6vPlQVZ2Aw5YganLV1ZcIz78j6TAtXJAfXrDhksm9UteQul8RYT0Ur8AJRYgiGXOsXrWWBKm3CzZci6paLZ2jBmGfgVuBJHlvgFIjOHiVozjulGD4SwKQ2MNqUOylv89NTP1BsJuZ7MC6YCm5yix7FswoE7Y2NhDFqzEQvseRQFyz52AsfuqRY7NruKHlO7LOSI932che2WzxBAwy78Sk1eRHQLsZ37dLB4UkFFIq6TvyjJKznTMAcx9HDOSrFeke6KfsDB1A4W3BAxJk40oAcFMeM72Lg97sJExMJRz1m1nGQJEiGCcnll9G6PqEfHjoOhdDLgN2xewUyvbuRuKEXXxD1H6Tz1iWReyRGSagQNLXvqkKoHoxu3bvSi8nWrbtEY6K2eHLeF5bYubYGXc5VsfiCQNPEzQV4ECzaPdolRtbpRFMcB5aWK70Oew3HJkEcN7IkcXI9vlJKnFvFMqGOHKujd4Tyjhvru2UFh0dAkEwojNzz7W0XlASiXRneea9FgiJNLcrXNtBkvIgw6kRrgbXI6DPJdWDpm3fmWS8EpOICH3aTiXRLQUDZsReAaOsfau1FNtP4JKTQpG3b9rKkO5G7vZEWqTi69mtPGWmyOU47WL1ifJtlzGiFbZ30pcHMc0u4uopHwEQq6ZwM5S6NHvioxihhHQHO8JU2xvcjg5OcTEsXtMwIapD3re'
+const hash = '09a3cd9e135114cb870a0b5cf0dfd3f4be994662d0c715b65bcfc5e3b635dd40'
+const dataPath = 'xo-block-store/09a3/cd9e/1351/14cb/870a/0b5c/f0df/d3f4/be99/4662/d0c7/15b6/5bcf/c5e3/b635/dd40.source'
+
+let dir
+describe('dedup tests', () => {
+  beforeEach(async () => {
+    dir = await pFromCallback(cb => tmp.dir(cb))
+  })
+  after(async () => {
+    await rimraf(dir)
+  })
+
+  it('works in general case ', async () => {
+    await Disposable.use(getSyncedHandler({ url: `file://${dir}` }, { dedup: true }), async handler => {
+      await handler.outputFile('in/a/sub/folder/file', data, { dedup: true })
+      assert.doesNotReject(handler.list('xo-block-store'))
+      assert.strictEqual((await handler.list('xo-block-store')).length, 1)
+      assert.strictEqual((await handler.list('in/a/sub/folder')).length, 1)
+      assert.strictEqual((await handler.readFile('in/a/sub/folder/file')).toString('utf-8'), data)
+      const value = (await execa('getfattr', ['-n', 'user.hash.sha256', '--only-value', dir + '/in/a/sub/folder/file']))
+        .stdout
+      assert.strictEqual(value, hash)
+      // the source file is created
+      assert.strictEqual((await handler.readFile(dataPath)).toString('utf-8'), data)
+
+      await handler.outputFile('in/anotherfolder/file', data, { dedup: true })
+      assert.strictEqual((await handler.list('in/anotherfolder')).length, 1)
+      assert.strictEqual((await handler.readFile('in/anotherfolder/file')).toString('utf-8'), data)
+
+      await handler.unlink('in/a/sub/folder/file', { dedup: true })
+      // source is still here
+      assert.strictEqual((await handler.readFile(dataPath)).toString('utf-8'), data)
+      assert.strictEqual((await handler.readFile('in/anotherfolder/file')).toString('utf-8'), data)
+
+      await handler.unlink('in/anotherfolder/file', { dedup: true })
+      // source should have been deleted
+      assert.strictEqual(
+        (
+          await handler.list(
+            'xo-block-store/09a3/cd9e/1351/14cb/870a/0b5c/f0df/d3f4/be99/4662/d0c7/15b6/5bcf/c5e3/b635'
+          )
+        ).length,
+        0
+      )
+      assert.strictEqual((await handler.list('in/anotherfolder')).length, 0)
+    })
+  })
+
+  it('garbage collector an stats ', async () => {
+    await Disposable.use(getSyncedHandler({ url: `file://${dir}` }, { dedup: true }), async handler => {
+      await handler.outputFile('in/anotherfolder/file', data, { dedup: true })
+      await handler.outputFile('in/anotherfolder/same', data, { dedup: true })
+      await handler.outputFile('in/a/sub/folder/file', randomBytes(1024), { dedup: true })
+
+      let stats = await handler.deduplicationStats()
+      assert.strictEqual(stats.nbBlocks, 3)
+      assert.strictEqual(stats.nbSourceBlocks, 2)
+
+      await fs.unlink(`${dir}/in/a/sub/folder/file`, { dedup: true })
+      assert.strictEqual((await handler.list('xo-block-store')).length, 2)
+
+      await handler.deduplicationGarbageCollector()
+      stats = await handler.deduplicationStats()
+      assert.strictEqual(stats.nbBlocks, 2)
+      assert.strictEqual(stats.nbSourceBlocks, 1)
+
+      assert.strictEqual((await handler.list('xo-block-store')).length, 1)
+    })
+  })
+
+  it('compute support', async () => {
+    await Disposable.use(getSyncedHandler({ url: `file://${dir}` }, { dedup: true }), async handler => {
+      const supported = await handler.checkSupport()
+      assert.strictEqual(supported.hardLink, true, 'support hard link is not present in local fs')
+      assert.strictEqual(supported.extendedAttributes, true, 'support extended attributes is not present in local fs')
+    })
+  })
+
+  it('handles edge cases : source deleted', async () => {
+    await Disposable.use(getSyncedHandler({ url: `file://${dir}` }, { dedup: true }), async handler => {
+      await handler.outputFile('in/a/sub/folder/edge', data, { dedup: true })
+      await handler.unlink(dataPath, { dedup: true })
+      // no error if source si already deleted
+      await assert.doesNotReject(() => handler.unlink('in/a/sub/folder/edge', { dedup: true }))
+    })
+  })
+  it('handles edge cases : non deduplicated file ', async () => {
+    await Disposable.use(getSyncedHandler({ url: `file://${dir}` }, { dedup: true }), async handler => {
+      await handler.outputFile('in/a/sub/folder/edge', data, { dedup: false })
+      // no error if deleting a non dedup file with dedup flags
+      await assert.doesNotReject(() => handler.unlink('in/a/sub/folder/edge', { dedup: true }))
+    })
+  })
+})

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

@@ -228,6 +228,11 @@ export default class S3Handler extends RemoteHandlerAbstract {
     },
   })
   async _writeFile(file, data, options) {
+    if (options?.dedup ?? false) {
+      throw new Error(
+        "S3 remotes don't support deduplication from XO, please use the deduplication of your S3 provider if any"
+      )
+    }
     return this.#s3.send(
       new PutObjectCommand({
         ...this.#createParams(file),

@xen-orchestra/lite/.prettierrc.cjs

@@ -1,4 +1,2 @@
 // Keeping this file to prevent applying the global monorepo config for now
-module.exports = {
-  trailingComma: "es5",
-};
+module.exports = {};

@xen-orchestra/lite/CHANGELOG.md

@@ -2,11 +2,8 @@
 
 ## **next**
 
-## **0.1.2** (2023-07-28)
-
 - Ability to export selected VMs as CSV file (PR [#6915](https://github.com/vatesfr/xen-orchestra/pull/6915))
 - [Pool/VMs] Ability to export selected VMs as JSON file (PR [#6911](https://github.com/vatesfr/xen-orchestra/pull/6911))
-- Add Tasks to Pool Dashboard (PR [#6713](https://github.com/vatesfr/xen-orchestra/pull/6713))
 
 ## **0.1.1** (2023-07-03)
 

@xen-orchestra/lite/docs/xen-api-record-stores.md

@@ -40,7 +40,7 @@ export const useConsoleStore = defineStore("console", () =>
 
 To extend the base Subscription, you'll need to override the `subscribe` method.
 
-For that, you can use the `createSubscribe<RawObjectType, Extensions>((options) => { /* ... */})` helper.
+For that, you can use the `createSubscribe<XenApiRecord, Extensions>((options) => { /* ... */})` helper.
 
 ### Define the extensions
 
@@ -82,7 +82,7 @@ type Extensions = [
 export const useConsoleStore = defineStore("console", () => {
   const consoleCollection = useXapiCollectionStore().get("console");
 
-  const subscribe = createSubscribe<"console", Extensions>((options) => {
+  const subscribe = createSubscribe<XenApiConsole, Extensions>((options) => {
     const originalSubscription = consoleCollection.subscribe(options);
 
     const extendedSubscription = {

@xen-orchestra/lite/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <link rel="icon" href="/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>XO Lite</title>
+    <title>Vite App</title>
   </head>
   <body>
     <div id="root"></div>

@xen-orchestra/lite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xen-orchestra/lite",
-  "version": "0.1.2",
+  "version": "0.1.1",
   "scripts": {
     "dev": "GIT_HEAD=$(git rev-parse HEAD) vite",
     "build": "run-p type-check build-only",
@@ -22,7 +22,7 @@
     "@types/marked": "^4.0.8",
     "@vueuse/core": "^10.1.2",
     "@vueuse/math": "^10.1.2",
-    "complex-matcher": "^0.7.1",
+    "complex-matcher": "^0.7.0",
     "d3-time-format": "^4.1.0",
     "decorator-synchronized": "^0.6.0",
     "echarts": "^5.3.3",
@@ -49,7 +49,7 @@
     "@rushstack/eslint-patch": "^1.1.0",
     "@types/node": "^16.11.41",
     "@vitejs/plugin-vue": "^4.2.3",
-    "@vue/eslint-config-prettier": "^8.0.0",
+    "@vue/eslint-config-prettier": "^7.0.0",
     "@vue/eslint-config-typescript": "^11.0.0",
     "@vue/tsconfig": "^0.1.3",
     "eslint-plugin-vue": "^9.0.0",

@xen-orchestra/lite/src/App.vue

@@ -4,10 +4,10 @@
     <AppLogin />
   </div>
   <div v-else>
-    <AppHeader v-if="uiStore.hasUi" />
+    <AppHeader />
     <div style="display: flex">
-      <AppNavigation v-if="uiStore.hasUi" />
-      <main class="main" :class="{ 'no-ui': !uiStore.hasUi }">
+      <AppNavigation />
+      <main class="main">
         <RouterView />
       </main>
     </div>
@@ -41,6 +41,8 @@ if (link == null) {
 }
 link.href = favicon;
 
+document.title = "XO Lite";
+
 const xenApiStore = useXenApiStore();
 const { pool } = usePoolStore().subscribe();
 useChartTheme();
@@ -90,9 +92,5 @@ whenever(
   flex: 1;
   height: calc(100vh - 8rem);
   background-color: var(--background-color-secondary);
-
-  &.no-ui {
-    height: 100vh;
-  }
 }
 </style>

@xen-orchestra/lite/src/components/AppLogin.vue

@@ -24,7 +24,6 @@
 </template>
 
 <script lang="ts" setup>
-import { usePageTitleStore } from "@/stores/page-title.store";
 import { storeToRefs } from "pinia";
 import { onMounted, ref, watch } from "vue";
 import { useI18n } from "vue-i18n";
@@ -34,7 +33,6 @@ import UiButton from "@/components/ui/UiButton.vue";
 import { useXenApiStore } from "@/stores/xen-api.store";
 
 const { t } = useI18n();
-usePageTitleStore().setTitle(t("login"));
 const xenApiStore = useXenApiStore();
 const { isConnecting } = storeToRefs(xenApiStore);
 const login = ref("root");
@@ -64,7 +62,7 @@ async function handleSubmit() {
       isInvalidPassword.value = true;
       error.value = t("password-invalid");
     } else {
-      error.value = t("error-occurred");
+      error.value = t("error-occured");
       console.error(err);
     }
   }

@xen-orchestra/lite/src/components/ObjectNotFoundWrapper.vue

@@ -7,12 +7,12 @@
 </template>
 
 <script
-  generic="T extends XenApiRecord<RawObjectType>, I extends T['uuid']"
+  generic="T extends XenApiRecord<string>, I extends T['uuid']"
   lang="ts"
   setup
 >
 import UiSpinner from "@/components/ui/UiSpinner.vue";
-import type { RawObjectType, XenApiRecord } from "@/libs/xen-api";
+import type { XenApiRecord } from "@/libs/xen-api";
 import ObjectNotFoundView from "@/views/ObjectNotFoundView.vue";
 import { computed } from "vue";
 import { useRouter } from "vue-router";

@xen-orchestra/lite/src/components/RemoteConsole.vue

@@ -3,11 +3,11 @@
 </template>
 
 <script lang="ts" setup>
-import { useXenApiStore } from "@/stores/xen-api.store";
-import VncClient from "@novnc/novnc/core/rfb";
-import { promiseTimeout } from "@vueuse/shared";
 import { fibonacci } from "iterable-backoff";
 import { computed, onBeforeUnmount, ref, watchEffect } from "vue";
+import VncClient from "@novnc/novnc/core/rfb";
+import { useXenApiStore } from "@/stores/xen-api.store";
+import { promiseTimeout } from "@vueuse/shared";
 
 const N_TOTAL_TRIES = 8;
 const FIBONACCI_MS_ARRAY: number[] = Array.from(

@xen-orchestra/lite/src/components/component-story/ComponentStory.vue

@@ -33,7 +33,7 @@
     </AppMenu>
   </UiTabBar>
 
-  <div :class="{ 'full-width': fullWidthComponent }" class="tabs">
+  <div class="tabs">
     <UiCard v-if="selectedTab === TAB.NONE" class="tab-content">
       <i>No configuration defined</i>
     </UiCard>
@@ -102,11 +102,11 @@ import StorySettingParams from "@/components/component-story/StorySettingParams.
 import StorySlotParams from "@/components/component-story/StorySlotParams.vue";
 import AppMenu from "@/components/menu/AppMenu.vue";
 import MenuItem from "@/components/menu/MenuItem.vue";
-import UiIcon from "@/components/ui/icon/UiIcon.vue";
 import UiButton from "@/components/ui/UiButton.vue";
 import UiCard from "@/components/ui/UiCard.vue";
 import UiCardTitle from "@/components/ui/UiCardTitle.vue";
 import UiCounter from "@/components/ui/UiCounter.vue";
+import UiIcon from "@/components/ui/icon/UiIcon.vue";
 import UiTab from "@/components/ui/UiTab.vue";
 import UiTabBar from "@/components/ui/UiTabBar.vue";
 import {
@@ -140,7 +140,6 @@ const props = defineProps<{
       settings?: Record<string, any>;
     }
   >;
-  fullWidthComponent?: boolean;
 }>();
 
 enum TAB {
@@ -330,10 +329,6 @@ const applyPreset = (preset: {
   padding: 1rem;
   gap: 1rem;
 
-  &.full-width {
-    flex-direction: column;
-  }
-
   .tab-content {
     flex: 1;
     height: auto;

@xen-orchestra/lite/src/components/pool/dashboard/PoolDashboardStatus.vue

@@ -34,6 +34,7 @@ const {
   isReady: isVmReady,
   records: vms,
   hasError: hasVmError,
+  runningVms,
 } = useVmStore().subscribe();
 
 const {
@@ -54,7 +55,5 @@ const activeHostsCount = computed(
 
 const totalVmsCount = computed(() => vms.value.length);
 
-const activeVmsCount = computed(
-  () => vms.value.filter((vm) => vm.power_state === "Running").length
-);
+const activeVmsCount = computed(() => runningVms.value.length);
 </script>

@xen-orchestra/lite/src/components/pool/dashboard/PoolDashboardTasks.vue

@@ -1,17 +0,0 @@
-<template>
-  <UiCard>
-    <UiCardTitle :count="pendingTasks.length">{{ $t("tasks") }}</UiCardTitle>
-    <TasksTable :pending-tasks="pendingTasks" />
-  </UiCard>
-</template>
-
-<script lang="ts" setup>
-import TasksTable from "@/components/tasks/TasksTable.vue";
-import UiCard from "@/components/ui/UiCard.vue";
-import UiCardTitle from "@/components/ui/UiCardTitle.vue";
-import { useTaskStore } from "@/stores/task.store";
-
-const { pendingTasks } = useTaskStore().subscribe();
-</script>
-
-<style lang="postcss" scoped></style>

@xen-orchestra/lite/src/components/tasks/TasksTable.vue

@@ -1,5 +1,5 @@
 <template>
-  <UiTable :color="hasError ? 'error' : undefined" class="tasks-table">
+  <UiTable class="tasks-table" :color="hasError ? 'error' : undefined">
     <thead>
       <tr>
         <th>{{ $t("name") }}</th>
@@ -20,9 +20,6 @@
           <UiSpinner class="loader" />
         </td>
       </tr>
-      <tr v-else-if="!hasTasks">
-        <td class="no-tasks" colspan="5">{{ $t("no-tasks") }}</td>
-      </tr>
       <template v-else>
         <TaskRow
           v-for="task in pendingTasks"
@@ -38,35 +35,20 @@
 
 <script lang="ts" setup>
 import TaskRow from "@/components/tasks/TaskRow.vue";
-import UiSpinner from "@/components/ui/UiSpinner.vue";
 import UiTable from "@/components/ui/UiTable.vue";
-import type { XenApiTask } from "@/libs/xen-api";
+import UiSpinner from "@/components/ui/UiSpinner.vue";
 import { useTaskStore } from "@/stores/task.store";
-import { computed } from "vue";
+import type { XenApiTask } from "@/libs/xen-api";
 
-const props = defineProps<{
+defineProps<{
   pendingTasks: XenApiTask[];
-  finishedTasks?: XenApiTask[];
+  finishedTasks: XenApiTask[];
 }>();
 
 const { hasError, isFetching } = useTaskStore().subscribe();
-
-const hasTasks = computed(
-  () => props.pendingTasks.length > 0 || (props.finishedTasks?.length ?? 0) > 0
-);
 </script>
 
 <style lang="postcss" scoped>
-.tasks-table {
-  width: 100%;
-}
-
-.no-tasks {
-  text-align: center;
-  color: var(--color-blue-scale-300);
-  font-style: italic;
-}
-
 td[colspan="5"] {
   text-align: center;
 }

@xen-orchestra/lite/src/components/ui/UiCardTitle.vue

@@ -6,7 +6,6 @@
       class="left"
     >
       <slot>{{ left }}</slot>
-      <UiCounter class="count" v-if="count > 0" :value="count" color="info" />
     </component>
     <component
       :is="subtitle ? 'h6' : 'h5'"
@@ -19,17 +18,11 @@
 </template>
 
 <script lang="ts" setup>
-import UiCounter from "@/components/ui/UiCounter.vue";
-
-withDefaults(
-  defineProps<{
-    subtitle?: boolean;
-    left?: string;
-    right?: string;
-    count?: number;
-  }>(),
-  { count: 0 }
-);
+defineProps<{
+  subtitle?: boolean;
+  left?: string;
+  right?: string;
+}>();
 </script>
 
 <style lang="postcss" scoped>
@@ -62,9 +55,6 @@ withDefaults(
   font-size: var(--section-title-left-size);
   font-weight: var(--section-title-left-weight);
   color: var(--section-title-left-color);
-  display: flex;
-  align-items: center;
-  gap: 2rem;
 }
 
 .right {
@@ -72,8 +62,4 @@ withDefaults(
   font-weight: var(--section-title-right-weight);
   color: var(--section-title-right-color);
 }
-
-.count {
-  font-size: 1.6rem;
-}
 </style>

@xen-orchestra/lite/src/components/ui/resources/UiResource.vue

@@ -1,50 +0,0 @@
-<template>
-  <li class="ui-resource">
-    <UiIcon :icon="icon" class="icon" />
-    <div class="separator" />
-    <div class="label">{{ label }}</div>
-    <div class="count">{{ count }}</div>
-  </li>
-</template>
-
-<script lang="ts" setup>
-import UiIcon from "@/components/ui/icon/UiIcon.vue";
-import type { IconDefinition } from "@fortawesome/fontawesome-common-types";
-
-defineProps<{
-  icon: IconDefinition;
-  label: string;
-  count: string | number;
-}>();
-</script>
-
-<style lang="postcss" scoped>
-.ui-resource {
-  display: flex;
-  align-items: center;
-}
-
-.icon {
-  color: var(--color-extra-blue-base);
-  font-size: 3.2rem;
-}
-
-.separator {
-  height: 4.5rem;
-  width: 0;
-  border-left: 0.1rem solid var(--color-extra-blue-base);
-  background-color: var(--color-extra-blue-base);
-  margin: 0 1.5rem;
-}
-
-.label {
-  font-size: 1.6rem;
-  font-weight: 700;
-}
-
-.count {
-  font-size: 1.4rem;
-  font-weight: 400;
-  margin-left: 2rem;
-}
-</style>

@xen-orchestra/lite/src/components/ui/resources/UiResources.vue

@@ -1,13 +0,0 @@
-<template>
-  <ul class="ui-resources">
-    <slot />
-  </ul>
-</template>
-
-<style lang="postcss" scoped>
-.ui-resources {
-  display: flex;
-  gap: 1rem 5.4rem;
-  flex-wrap: wrap;
-}
-</style>

@xen-orchestra/lite/src/libs/utils.ts

@@ -1,10 +1,10 @@
 import type {
   RawXenApiRecord,
   XenApiHost,
+  XenApiHostMetrics,
   XenApiRecord,
   XenApiVm,
   VM_OPERATION,
-  RawObjectType,
 } from "@/libs/xen-api";
 import type { Filter } from "@/types/filter";
 import type { Subscription } from "@/types/xapi-collection";
@@ -116,14 +116,14 @@ export function getStatsLength(stats?: object | any[]) {
 
 export function isHostRunning(
   host: XenApiHost,
-  hostMetricsSubscription: Subscription<"host_metrics", object>
+  hostMetricsSubscription: Subscription<XenApiHostMetrics, object>
 ) {
   return hostMetricsSubscription.getByOpaqueRef(host.metrics)?.live === true;
 }
 
 export function getHostMemory(
   host: XenApiHost,
-  hostMetricsSubscription: Subscription<"host_metrics", object>
+  hostMetricsSubscription: Subscription<XenApiHostMetrics, object>
 ) {
   const hostMetrics = hostMetricsSubscription.getByOpaqueRef(host.metrics);
 
@@ -136,7 +136,7 @@ export function getHostMemory(
   }
 }
 
-export const buildXoObject = <T extends XenApiRecord<RawObjectType>>(
+export const buildXoObject = <T extends XenApiRecord<string>>(
   record: RawXenApiRecord<T>,
   params: { opaqueRef: T["$ref"] }
 ) => {

@xen-orchestra/lite/src/libs/xen-api.ts

@@ -1,5 +1,4 @@
 import { buildXoObject, parseDateTime } from "@/libs/utils";
-import type { RawTypeToRecord } from "@/types/xapi-collection";
 import { JSONRPCClient } from "json-rpc-2.0";
 import { castArray } from "lodash-es";
 
@@ -91,17 +90,14 @@ export enum VM_OPERATION {
 
 declare const __brand: unique symbol;
 
-export interface XenApiRecord<Name extends RawObjectType> {
+export interface XenApiRecord<Name extends string> {
   $ref: string & { [__brand]: `${Name}Ref` };
   uuid: string & { [__brand]: `${Name}Uuid` };
 }
 
-export type RawXenApiRecord<T extends XenApiRecord<RawObjectType>> = Omit<
-  T,
-  "$ref"
->;
+export type RawXenApiRecord<T extends XenApiRecord<string>> = Omit<T, "$ref">;
 
-export interface XenApiPool extends XenApiRecord<"pool"> {
+export interface XenApiPool extends XenApiRecord<"Pool"> {
   cpu_info: {
     cpu_count: string;
   };
@@ -109,7 +105,7 @@ export interface XenApiPool extends XenApiRecord<"pool"> {
   name_label: string;
 }
 
-export interface XenApiHost extends XenApiRecord<"host"> {
+export interface XenApiHost extends XenApiRecord<"Host"> {
   address: string;
   name_label: string;
   metrics: XenApiHostMetrics["$ref"];
@@ -118,13 +114,13 @@ export interface XenApiHost extends XenApiRecord<"host"> {
   software_version: { product_version: string };
 }
 
-export interface XenApiSr extends XenApiRecord<"SR"> {
+export interface XenApiSr extends XenApiRecord<"Sr"> {
   name_label: string;
   physical_size: number;
   physical_utilisation: number;
 }
 
-export interface XenApiVm extends XenApiRecord<"VM"> {
+export interface XenApiVm extends XenApiRecord<"Vm"> {
   current_operations: Record<string, VM_OPERATION>;
   guest_metrics: string;
   metrics: XenApiVmMetrics["$ref"];
@@ -139,24 +135,24 @@ export interface XenApiVm extends XenApiRecord<"VM"> {
   VCPUs_at_startup: number;
 }
 
-export interface XenApiConsole extends XenApiRecord<"console"> {
+export interface XenApiConsole extends XenApiRecord<"Console"> {
   protocol: string;
   location: string;
 }
 
-export interface XenApiHostMetrics extends XenApiRecord<"host_metrics"> {
+export interface XenApiHostMetrics extends XenApiRecord<"HostMetrics"> {
   live: boolean;
   memory_free: number;
   memory_total: number;
 }
 
-export interface XenApiVmMetrics extends XenApiRecord<"VM_metrics"> {
+export interface XenApiVmMetrics extends XenApiRecord<"VmMetrics"> {
   VCPUs_number: number;
 }
 
-export type XenApiVmGuestMetrics = XenApiRecord<"VM_guest_metrics">;
+export type XenApiVmGuestMetrics = XenApiRecord<"VmGuestMetrics">;
 
-export interface XenApiTask extends XenApiRecord<"task"> {
+export interface XenApiTask extends XenApiRecord<"Task"> {
   name_label: string;
   resident_on: XenApiHost["$ref"];
   created: string;
@@ -165,22 +161,17 @@ export interface XenApiTask extends XenApiRecord<"task"> {
   progress: number;
 }
 
-export interface XenApiMessage<T extends RawObjectType = RawObjectType>
-  extends XenApiRecord<"message"> {
-  body: string;
-  cls: T;
+export interface XenApiMessage extends XenApiRecord<"Message"> {
   name: string;
-  obj_uuid: RawTypeToRecord<T>["uuid"];
-  priority: number;
-  timestamp: string;
+  cls: RawObjectType;
 }
 
 type WatchCallbackResult = {
   id: string;
   class: ObjectType;
   operation: "add" | "mod" | "del";
-  ref: XenApiRecord<RawObjectType>["$ref"];
-  snapshot: RawXenApiRecord<XenApiRecord<RawObjectType>>;
+  ref: XenApiRecord<string>["$ref"];
+  snapshot: RawXenApiRecord<XenApiRecord<string>>;
 };
 
 type WatchCallback = (results: WatchCallbackResult[]) => void;
@@ -293,17 +284,16 @@ export default class XenApi {
     return fetch(url, { signal: abortSignal });
   }
 
-  async loadRecords<
-    T extends RawObjectType,
-    R extends RawTypeToRecord<T> = RawTypeToRecord<T>
-  >(type: T): Promise<R[]> {
-    const result = await this.#call<{ [key: string]: R }>(
+  async loadRecords<T extends XenApiRecord<string>>(
+    type: RawObjectType
+  ): Promise<T[]> {
+    const result = await this.#call<{ [key: string]: RawXenApiRecord<T> }>(
       `${type}.get_all_records`,
       [this.sessionId]
     );
 
     return Object.entries(result).map(([opaqueRef, record]) =>
-      buildXoObject(record, { opaqueRef: opaqueRef as R["$ref"] })
+      buildXoObject(record, { opaqueRef: opaqueRef as T["$ref"] })
     );
   }
 

@xen-orchestra/lite/src/locales/en.json

@@ -18,7 +18,6 @@
   "community": "Community",
   "community-name": "{name} community",
   "console": "Console",
-  "console-unavailable": "Console unavailable",
   "copy": "Copy",
   "cpu-provisioning": "CPU provisioning",
   "cpu-usage": "CPU usage",
@@ -33,7 +32,7 @@
   "do-you-have-needs": "You have needs and/or expectations? Let us know",
   "edit-config": "Edit config",
   "error-no-data": "Error, can't collect data.",
-  "error-occurred": "An error has occurred",
+  "error-occured": "An error has occurred",
   "export": "Export",
   "export-table-to": "Export table to {type}",
   "export-vms": "Export VMs",
@@ -78,11 +77,8 @@
   "news": "News",
   "news-name": "{name} news",
   "new-features-are-coming": "New features are coming soon!",
-  "no-tasks": "No tasks",
-  "not-found": "Not found",
   "object": "Object",
   "object-not-found": "Object {id} can't be found…",
-  "open-in-new-window": "Open in new window",
   "or": "Or",
   "page-not-found": "This page is not to be found…",
   "password": "Password",
@@ -91,7 +87,6 @@
   "please-confirm": "Please confirm",
   "pool-cpu-usage": "Pool CPU Usage",
   "pool-ram-usage": "Pool RAM Usage",
-  "power-on-for-console": "Power on your VM to access its console",
   "power-state": "Power state",
   "property": "Property",
   "ram-usage": "RAM usage",
@@ -115,6 +110,7 @@
   "settings": "Settings",
   "shutdown": "Shutdown",
   "snapshot": "Snapshot",
+  "selected-vms-in-execution": "Some selected VMs are running",
   "sort-by": "Sort by",
   "stacked-cpu-usage": "Stacked CPU usage",
   "stacked-ram-usage": "Stacked RAM usage",
@@ -131,6 +127,7 @@
   "system": "System",
   "task": {
     "estimated-end": "Estimated end",
+    "page-title": "Tasks | (1) Tasks | ({n}) Tasks",
     "progress": "Progress",
     "started": "Started"
   },

@xen-orchestra/lite/src/locales/fr.json

@@ -18,7 +18,6 @@
   "community": "Communauté",
   "community-name": "Communauté {name}",
   "console": "Console",
-  "console-unavailable": "Console indisponible",
   "copy": "Copier",
   "cpu-provisioning": "Provisionnement CPU",
   "cpu-usage": "Utilisation CPU",
@@ -33,7 +32,7 @@
   "do-you-have-needs": "Vous avez des besoins et/ou des attentes ? Faites le nous savoir",
   "edit-config": "Modifier config",
   "error-no-data": "Erreur, impossible de collecter les données.",
-  "error-occurred": "Une erreur est survenue",
+  "error-occured": "Une erreur est survenue",
   "export": "Exporter",
   "export-table-to": "Exporter le tableau en {type}",
   "export-vms": "Exporter les VMs",
@@ -78,11 +77,8 @@
   "news": "Actualités",
   "news-name": "Actualités {name}",
   "new-features-are-coming": "De nouvelles fonctionnalités arrivent bientôt !",
-  "no-tasks": "Aucune tâche",
-  "not-found": "Non trouvé",
   "object": "Objet",
   "object-not-found": "L'objet {id} est introuvable…",
-  "open-in-new-window": "Ouvrir dans une nouvelle fenêtre",
   "or": "Ou",
   "page-not-found": "Cette page est introuvable…",
   "password": "Mot de passe",
@@ -91,7 +87,6 @@
   "please-confirm": "Veuillez confirmer",
   "pool-cpu-usage": "Utilisation CPU du Pool",
   "pool-ram-usage": "Utilisation RAM du Pool",
-  "power-on-for-console": "Allumez votre VM pour accéder à sa console",
   "power-state": "État d'alimentation",
   "property": "Propriété",
   "ram-usage": "Utilisation de la RAM",
@@ -115,6 +110,7 @@
   "settings": "Paramètres",
   "shutdown": "Arrêter",
   "snapshot": "Instantané",
+  "selected-vms-in-execution": "Certaines VMs sélectionnées sont en cours d'exécution",
   "sort-by": "Trier par",
   "stacked-cpu-usage": "Utilisation CPU empilée",
   "stacked-ram-usage": "Utilisation RAM empilée",
@@ -131,6 +127,7 @@
   "system": "Système",
   "task": {
     "estimated-end": "Fin estimée",
+    "page-title": "Tâches | (1) Tâches | ({n}) Tâches",
     "progress": "Progression",
     "started": "Démarré"
   },

@xen-orchestra/lite/src/router/index.ts

@@ -33,7 +33,7 @@ const router = createRouter({
     },
     {
       path: "/:pathMatch(.*)*",
-      name: "not-found",
+      name: "notFound",
       component: () => import("@/views/PageNotFoundView.vue"),
     },
   ],

@xen-orchestra/lite/src/stores/alarm.store.ts

@@ -1,3 +1,4 @@
+import type { XenApiMessage } from "@/libs/xen-api";
 import { useXapiCollectionStore } from "@/stores/xapi-collection.store";
 import { createSubscribe } from "@/types/xapi-collection";
 import { defineStore } from "pinia";
@@ -6,7 +7,7 @@ import { computed } from "vue";
 export const useAlarmStore = defineStore("alarm", () => {
   const messageCollection = useXapiCollectionStore().get("message");
 
-  const subscribe = createSubscribe<"message", []>((options) => {
+  const subscribe = createSubscribe<XenApiMessage, []>((options) => {
     const originalSubscription = messageCollection.subscribe(options);
 
     const extendedSubscription = {

@xen-orchestra/lite/src/stores/host.store.ts

@@ -4,7 +4,7 @@ import type {
   HostStats,
   XapiStatsResponse,
 } from "@/libs/xapi-stats";
-import type { XenApiHost } from "@/libs/xen-api";
+import type { XenApiHost, XenApiHostMetrics } from "@/libs/xen-api";
 import { useXapiCollectionStore } from "@/stores/xapi-collection.store";
 import { useXenApiStore } from "@/stores/xen-api.store";
 import type { Subscription } from "@/types/xapi-collection";
@@ -25,7 +25,7 @@ type GetStatsExtension = {
 
 type RunningHostsExtension = [
   { runningHosts: ComputedRef<XenApiHost[]> },
-  { hostMetricsSubscription: Subscription<"host_metrics", any> }
+  { hostMetricsSubscription: Subscription<XenApiHostMetrics, any> }
 ];
 
 type Extensions = [GetStatsExtension, RunningHostsExtension];
@@ -36,7 +36,7 @@ export const useHostStore = defineStore("host", () => {
 
   hostCollection.setSort(sortRecordsByNameLabel);
 
-  const subscribe = createSubscribe<"host", Extensions>((options) => {
+  const subscribe = createSubscribe<XenApiHost, Extensions>((options) => {
     const originalSubscription = hostCollection.subscribe(options);
 
     const getStats: GetStats = (

@xen-orchestra/lite/src/stores/page-title.store.ts

@@ -1,92 +0,0 @@
-import { useTitle } from "@vueuse/core";
-import { defineStore } from "pinia";
-import {
-  computed,
-  type MaybeRefOrGetter,
-  onBeforeUnmount,
-  reactive,
-  toRef,
-  watch,
-} from "vue";
-
-const PAGE_TITLE_SUFFIX = "XO Lite";
-
-interface PageTitleConfig {
-  object: { name_label: string } | undefined;
-  title: string | undefined;
-  count: number | undefined;
-}
-
-export const usePageTitleStore = defineStore("page-title", () => {
-  const pageTitleConfig = reactive<PageTitleConfig>({
-    count: undefined,
-    title: undefined,
-    object: undefined,
-  });
-
-  const generatedPageTitle = computed(() => {
-    const { object, title, count } = pageTitleConfig;
-    const parts = [];
-
-    if (count !== undefined && count > 0) {
-      parts.push(`(${count})`);
-    }
-
-    if (title !== undefined && object !== undefined) {
-      parts.push(`${title} - ${object.name_label}`);
-    } else if (title !== undefined) {
-      parts.push(title);
-    } else if (object !== undefined) {
-      parts.push(object.name_label);
-    }
-
-    if (parts.length === 0) {
-      return undefined;
-    }
-
-    return parts.join(" ");
-  });
-
-  useTitle(generatedPageTitle, {
-    titleTemplate: computed(() =>
-      generatedPageTitle.value === undefined
-        ? PAGE_TITLE_SUFFIX
-        : `%s - ${PAGE_TITLE_SUFFIX}`
-    ),
-  });
-
-  const setPageTitleConfig = <T extends keyof PageTitleConfig>(
-    configKey: T,
-    value: MaybeRefOrGetter<PageTitleConfig[T]>
-  ) => {
-    const stop = watch(
-      toRef(value),
-      (newValue) =>
-        (pageTitleConfig[configKey] = newValue as PageTitleConfig[T]),
-      {
-        immediate: true,
-      }
-    );
-
-    onBeforeUnmount(() => {
-      stop();
-      pageTitleConfig[configKey] = undefined;
-    });
-  };
-
-  const setObject = (
-    object: MaybeRefOrGetter<{ name_label: string } | undefined>
-  ) => setPageTitleConfig("object", object);
-
-  const setTitle = (title: MaybeRefOrGetter<string | undefined>) =>
-    setPageTitleConfig("title", title);
-
-  const setCount = (count: MaybeRefOrGetter<number | undefined>) =>
-    setPageTitleConfig("count", count);
-
-  return {
-    setObject,
-    setTitle,
-    setCount,
-  };
-});

@xen-orchestra/lite/src/stores/pool.store.ts

@@ -14,7 +14,7 @@ type Extensions = [PoolExtension];
 export const usePoolStore = defineStore("pool", () => {
   const poolCollection = useXapiCollectionStore().get("pool");
 
-  const subscribe = createSubscribe<"pool", Extensions>((options) => {
+  const subscribe = createSubscribe<XenApiPool, Extensions>((options) => {
     const originalSubscription = poolCollection.subscribe(options);
 
     const extendedSubscription = {

@xen-orchestra/lite/src/stores/task.store.ts

@@ -1,64 +1,6 @@
-import useArrayRemovedItemsHistory from "@/composables/array-removed-items-history.composable";
-import useCollectionFilter from "@/composables/collection-filter.composable";
-import useCollectionSorter from "@/composables/collection-sorter.composable";
-import useFilteredCollection from "@/composables/filtered-collection.composable";
-import useSortedCollection from "@/composables/sorted-collection.composable";
-import type { XenApiTask } from "@/libs/xen-api";
 import { useXapiCollectionStore } from "@/stores/xapi-collection.store";
-import { createSubscribe } from "@/types/xapi-collection";
 import { defineStore } from "pinia";
-import type { ComputedRef, Ref } from "vue";
 
-type PendingTasksExtension = {
-  pendingTasks: ComputedRef<XenApiTask[]>;
-};
-
-type FinishedTasksExtension = {
-  finishedTasks: Ref<XenApiTask[]>;
-};
-
-type Extensions = [PendingTasksExtension, FinishedTasksExtension];
-
-export const useTaskStore = defineStore("task", () => {
-  const tasksCollection = useXapiCollectionStore().get("task");
-
-  const subscribe = createSubscribe<"task", Extensions>(() => {
-    const subscription = tasksCollection.subscribe();
-
-    const { compareFn } = useCollectionSorter<XenApiTask>({
-      initialSorts: ["-created"],
-    });
-
-    const sortedTasks = useSortedCollection(subscription.records, compareFn);
-
-    const { predicate } = useCollectionFilter({
-      initialFilters: [
-        "!name_label:|(SR.scan host.call_plugin)",
-        "status:pending",
-      ],
-    });
-
-    const extendedSubscription = {
-      pendingTasks: useFilteredCollection<XenApiTask>(sortedTasks, predicate),
-      finishedTasks: useArrayRemovedItemsHistory(
-        sortedTasks,
-        (task) => task.uuid,
-        {
-          limit: 50,
-          onRemove: (tasks) =>
-            tasks.map((task) => ({
-              ...task,
-              finished: new Date().toISOString(),
-            })),
-        }
-      ),
-    };
-
-    return {
-      ...subscription,
-      ...extendedSubscription,
-    };
-  });
-
-  return { ...tasksCollection, subscribe };
-});
+export const useTaskStore = defineStore("task", () =>
+  useXapiCollectionStore().get("task")
+);

@xen-orchestra/lite/src/stores/ui.store.ts

@@ -1,7 +1,6 @@
 import { useBreakpoints, useColorMode } from "@vueuse/core";
 import { defineStore } from "pinia";
 import { computed, ref } from "vue";
-import { useRoute } from "vue-router";
 
 export const useUiStore = defineStore("ui", () => {
   const currentHostOpaqueRef = ref();
@@ -14,14 +13,10 @@ export const useUiStore = defineStore("ui", () => {
 
   const isMobile = computed(() => !isDesktop.value);
 
-  const route = useRoute();
-  const hasUi = computed(() => route.query.ui !== "0");
-
   return {
     colorMode,
     currentHostOpaqueRef,
     isDesktop,
     isMobile,
-    hasUi,
   };
 });

@xen-orchestra/lite/src/stores/vm.store.ts

@@ -27,7 +27,7 @@ type GetStatsExtension = [
   {
     getStats: GetStats;
   },
-  { hostSubscription: Subscription<"host", object> }
+  { hostSubscription: Subscription<XenApiHost, object> }
 ];
 
 type Extensions = [DefaultExtension, GetStatsExtension];
@@ -41,7 +41,7 @@ export const useVmStore = defineStore("vm", () => {
 
   vmCollection.setSort(sortRecordsByNameLabel);
 
-  const subscribe = createSubscribe<"VM", Extensions>((options) => {
+  const subscribe = createSubscribe<XenApiVm, Extensions>((options) => {
     const originalSubscription = vmCollection.subscribe(options);
 
     const extendedSubscription = {

@xen-orchestra/lite/src/stores/xapi-collection.store.ts

@@ -1,7 +1,7 @@
-import type { RawObjectType } from "@/libs/xen-api";
+import type { RawObjectType, XenApiRecord } from "@/libs/xen-api";
 import { useXenApiStore } from "@/stores/xen-api.store";
 import type {
-  RawTypeToRecord,
+  RawTypeToObject,
   SubscribeOptions,
   Subscription,
 } from "@/types/xapi-collection";
@@ -10,13 +10,16 @@ import { defineStore } from "pinia";
 import { computed, readonly, ref } from "vue";
 
 export const useXapiCollectionStore = defineStore("xapiCollection", () => {
-  const collections = ref(new Map());
+  const collections = ref(
+    new Map<RawObjectType, ReturnType<typeof createXapiCollection<any>>>()
+  );
 
-  function get<T extends RawObjectType>(
-    type: T
-  ): ReturnType<typeof createXapiCollection<T, RawTypeToRecord<T>>> {
+  function get<
+    T extends RawObjectType,
+    S extends XenApiRecord<string> = RawTypeToObject[T]
+  >(type: T): ReturnType<typeof createXapiCollection<S>> {
     if (!collections.value.has(type)) {
-      collections.value.set(type, createXapiCollection(type));
+      collections.value.set(type, createXapiCollection<S>(type));
     }
 
     return collections.value.get(type)!;
@@ -25,11 +28,8 @@ export const useXapiCollectionStore = defineStore("xapiCollection", () => {
   return { get };
 });
 
-const createXapiCollection = <
-  T extends RawObjectType,
-  R extends RawTypeToRecord<T>
->(
-  type: T
+const createXapiCollection = <T extends XenApiRecord<string>>(
+  type: RawObjectType
 ) => {
   const isReady = ref(false);
   const isFetching = ref(false);
@@ -37,31 +37,31 @@ const createXapiCollection = <
   const lastError = ref<string>();
   const hasError = computed(() => lastError.value !== undefined);
   const subscriptions = ref(new Set<symbol>());
-  const recordsByOpaqueRef = ref(new Map<R["$ref"], R>());
-  const recordsByUuid = ref(new Map<R["uuid"], R>());
-  const filter = ref<(record: R) => boolean>();
-  const sort = ref<(record1: R, record2: R) => 1 | 0 | -1>();
+  const recordsByOpaqueRef = ref(new Map<T["$ref"], T>());
+  const recordsByUuid = ref(new Map<T["uuid"], T>());
+  const filter = ref<(record: T) => boolean>();
+  const sort = ref<(record1: T, record2: T) => 1 | 0 | -1>();
   const xenApiStore = useXenApiStore();
 
-  const setFilter = (newFilter: (record: R) => boolean) =>
+  const setFilter = (newFilter: (record: T) => boolean) =>
     (filter.value = newFilter);
 
-  const setSort = (newSort: (record1: R, record2: R) => 1 | 0 | -1) =>
+  const setSort = (newSort: (record1: T, record2: T) => 1 | 0 | -1) =>
     (sort.value = newSort);
 
-  const records = computed<R[]>(() => {
+  const records = computed<T[]>(() => {
     const records = Array.from(recordsByOpaqueRef.value.values()).sort(
       sort.value
     );
     return filter.value !== undefined ? records.filter(filter.value) : records;
   });
 
-  const getByOpaqueRef = (opaqueRef: R["$ref"]) =>
+  const getByOpaqueRef = (opaqueRef: T["$ref"]) =>
     recordsByOpaqueRef.value.get(opaqueRef);
 
-  const getByUuid = (uuid: R["uuid"]) => recordsByUuid.value.get(uuid);
+  const getByUuid = (uuid: T["uuid"]) => recordsByUuid.value.get(uuid);
 
-  const hasUuid = (uuid: R["uuid"]) => recordsByUuid.value.has(uuid);
+  const hasUuid = (uuid: T["uuid"]) => recordsByUuid.value.has(uuid);
 
   const hasSubscriptions = computed(() => subscriptions.value.size > 0);
 
@@ -69,7 +69,7 @@ const createXapiCollection = <
     try {
       isFetching.value = true;
       lastError.value = undefined;
-      const records = await xenApiStore.getXapi().loadRecords<T, R>(type);
+      const records = await xenApiStore.getXapi().loadRecords<T>(type);
       recordsByOpaqueRef.value.clear();
       recordsByUuid.value.clear();
       records.forEach(add);
@@ -81,17 +81,17 @@ const createXapiCollection = <
     }
   };
 
-  const add = (record: R) => {
+  const add = (record: T) => {
     recordsByOpaqueRef.value.set(record.$ref, record);
     recordsByUuid.value.set(record.uuid, record);
   };
 
-  const update = (record: R) => {
+  const update = (record: T) => {
     recordsByOpaqueRef.value.set(record.$ref, record);
     recordsByUuid.value.set(record.uuid, record);
   };
 
-  const remove = (opaqueRef: R["$ref"]) => {
+  const remove = (opaqueRef: T["$ref"]) => {
     if (!recordsByOpaqueRef.value.has(opaqueRef)) {
       return;
     }

@xen-orchestra/lite/src/stories/ui-resource.story.vue

@@ -1,70 +0,0 @@
-<template>
-  <ComponentStory
-    v-slot="{ properties }"
-    :params="[
-      iconProp().preset(faRocket),
-      prop('label').required().str().widget().preset('Rockets'),
-      prop('count')
-        .required()
-        .type('string | number')
-        .widget(text())
-        .preset('175'),
-    ]"
-    :presets="presets"
-  >
-    <UiResource v-bind="properties" />
-  </ComponentStory>
-</template>
-
-<script lang="ts" setup>
-import ComponentStory from "@/components/component-story/ComponentStory.vue";
-import UiResource from "@/components/ui/resources/UiResource.vue";
-import { iconProp, prop } from "@/libs/story/story-param";
-import { text } from "@/libs/story/story-widget";
-import {
-  faDatabase,
-  faDisplay,
-  faMemory,
-  faMicrochip,
-  faNetworkWired,
-  faRocket,
-} from "@fortawesome/free-solid-svg-icons";
-
-const presets = {
-  VMs: {
-    props: {
-      icon: faDisplay,
-      count: 1,
-      label: "VMs",
-    },
-  },
-  vCPUs: {
-    props: {
-      icon: faMicrochip,
-      count: 4,
-      label: "vCPUs",
-    },
-  },
-  RAM: {
-    props: {
-      icon: faMemory,
-      count: 2,
-      label: "RAM",
-    },
-  },
-  SR: {
-    props: {
-      icon: faDatabase,
-      count: 1,
-      label: "SR",
-    },
-  },
-  Interfaces: {
-    props: {
-      icon: faNetworkWired,
-      count: 2,
-      label: "Interfaces",
-    },
-  },
-};
-</script>

@xen-orchestra/lite/src/stories/ui-resources.story.md

@@ -1,11 +0,0 @@
-# Example
-
-```vue-template
-<UiResources>
-  <UiResource :icon="faDisplay" count="1" label="VMs" />
-  <UiResource :icon="faMicrochip" count="4" label="vCPUs" />
-  <UiResource :icon="faMemory" count="2" label="RAM" />
-  <UiResource :icon="faDatabase" count="1" label="SR" />
-  <UiResource :icon="faNetworkWired" count="2" label="Interfaces" />
-</UiResources>
-```

@xen-orchestra/lite/src/stories/ui-resources.story.vue

@@ -1,28 +0,0 @@
-<template>
-  <ComponentStory
-    :params="[slot().help('One or multiple `UiResource`')]"
-    full-width-component
-  >
-    <UiResources>
-      <UiResource :icon="faDisplay" count="1" label="VMs" />
-      <UiResource :icon="faMicrochip" count="4" label="vCPUs" />
-      <UiResource :icon="faMemory" count="2" label="RAM" />
-      <UiResource :icon="faDatabase" count="1" label="SR" />
-      <UiResource :icon="faNetworkWired" count="2" label="Interfaces" />
-    </UiResources>
-  </ComponentStory>
-</template>
-
-<script lang="ts" setup>
-import ComponentStory from "@/components/component-story/ComponentStory.vue";
-import UiResource from "@/components/ui/resources/UiResource.vue";
-import UiResources from "@/components/ui/resources/UiResources.vue";
-import { slot } from "@/libs/story/story-param";
-import {
-  faDatabase,
-  faDisplay,
-  faMemory,
-  faMicrochip,
-  faNetworkWired,
-} from "@fortawesome/free-solid-svg-icons";
-</script>

@xen-orchestra/lite/src/types/xapi-collection.ts

@@ -1,10 +1,10 @@
 import type {
-  RawObjectType,
   XenApiConsole,
   XenApiHost,
   XenApiHostMetrics,
   XenApiMessage,
   XenApiPool,
+  XenApiRecord,
   XenApiSr,
   XenApiTask,
   XenApiVm,
@@ -13,14 +13,11 @@ import type {
 } from "@/libs/xen-api";
 import type { ComputedRef, Ref } from "vue";
 
-type DefaultExtension<
-  T extends RawObjectType,
-  R extends RawTypeToRecord<T> = RawTypeToRecord<T>
-> = {
-  records: ComputedRef<R[]>;
-  getByOpaqueRef: (opaqueRef: R["$ref"]) => R | undefined;
-  getByUuid: (uuid: R["uuid"]) => R | undefined;
-  hasUuid: (uuid: R["uuid"]) => boolean;
+type DefaultExtension<T extends XenApiRecord<string>> = {
+  records: ComputedRef<T[]>;
+  getByOpaqueRef: (opaqueRef: T["$ref"]) => T | undefined;
+  getByUuid: (uuid: T["uuid"]) => T | undefined;
+  hasUuid: (uuid: T["uuid"]) => boolean;
   isReady: Readonly<Ref<boolean>>;
   isFetching: Readonly<Ref<boolean>>;
   isReloading: ComputedRef<boolean>;
@@ -36,7 +33,7 @@ type DeferExtension = [
   { immediate: false }
 ];
 
-type DefaultExtensions<T extends RawObjectType> = [
+type DefaultExtensions<T extends XenApiRecord<string>> = [
   DefaultExtension<T>,
   DeferExtension
 ];
@@ -67,14 +64,14 @@ type GenerateSubscription<
   : object;
 
 export type Subscription<
-  T extends RawObjectType,
+  T extends XenApiRecord<string>,
   Options extends object,
   Extensions extends any[] = []
 > = GenerateSubscription<Options, Extensions> &
   GenerateSubscription<Options, DefaultExtensions<T>>;
 
 export function createSubscribe<
-  T extends RawObjectType,
+  T extends XenApiRecord<string>,
   Extensions extends any[],
   Options extends object = SubscribeOptions<Extensions>
 >(builder: (options?: Options) => Subscription<T, Options, Extensions>) {
@@ -85,24 +82,59 @@ export function createSubscribe<
   };
 }
 
-export type RawTypeToRecord<T extends RawObjectType> = T extends "SR"
-  ? XenApiSr
-  : T extends "VM"
-  ? XenApiVm
-  : T extends "VM_guest_metrics"
-  ? XenApiVmGuestMetrics
-  : T extends "VM_metrics"
-  ? XenApiVmMetrics
-  : T extends "console"
-  ? XenApiConsole
-  : T extends "host"
-  ? XenApiHost
-  : T extends "host_metrics"
-  ? XenApiHostMetrics
-  : T extends "message"
-  ? XenApiMessage
-  : T extends "pool"
-  ? XenApiPool
-  : T extends "task"
-  ? XenApiTask
-  : never;
+export type RawTypeToObject = {
+  Bond: never;
+  Certificate: never;
+  Cluster: never;
+  Cluster_host: never;
+  DR_task: never;
+  Feature: never;
+  GPU_group: never;
+  PBD: never;
+  PCI: never;
+  PGPU: never;
+  PIF: never;
+  PIF_metrics: never;
+  PUSB: never;
+  PVS_cache_storage: never;
+  PVS_proxy: never;
+  PVS_server: never;
+  PVS_site: never;
+  SDN_controller: never;
+  SM: never;
+  SR: XenApiSr;
+  USB_group: never;
+  VBD: never;
+  VBD_metrics: never;
+  VDI: never;
+  VGPU: never;
+  VGPU_type: never;
+  VIF: never;
+  VIF_metrics: never;
+  VLAN: never;
+  VM: XenApiVm;
+  VMPP: never;
+  VMSS: never;
+  VM_guest_metrics: XenApiVmGuestMetrics;
+  VM_metrics: XenApiVmMetrics;
+  VUSB: never;
+  blob: never;
+  console: XenApiConsole;
+  crashdump: never;
+  host: XenApiHost;
+  host_cpu: never;
+  host_crashdump: never;
+  host_metrics: XenApiHostMetrics;
+  host_patch: never;
+  message: XenApiMessage;
+  network: never;
+  network_sriov: never;
+  pool: XenApiPool;
+  pool_patch: never;
+  pool_update: never;
+  role: never;
+  secret: never;
+  subject: never;
+  task: XenApiTask;
+  tunnel: never;
+};

@xen-orchestra/lite/src/views/ObjectNotFoundView.vue

@@ -9,8 +9,6 @@
 </template>
 
 <script setup lang="ts">
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
 import { useRouter } from "vue-router";
 import UiButton from "@/components/ui/UiButton.vue";
 
@@ -18,8 +16,6 @@ defineProps<{
   id: string;
 }>();
 
-usePageTitleStore().setTitle(useI18n().t("not-found"));
-
 const router = useRouter();
 </script>
 

@xen-orchestra/lite/src/views/PageNotFoundView.vue

@@ -10,13 +10,10 @@
 </template>
 
 <script setup lang="ts">
-import UiButton from "@/components/ui/UiButton.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
 import { useRouter } from "vue-router";
+import UiButton from "@/components/ui/UiButton.vue";
 
 const router = useRouter();
-usePageTitleStore().setTitle(useI18n().t("not-found"));
 </script>
 
 <style lang="postcss" scoped>

@xen-orchestra/lite/src/views/StoryView.vue

@@ -6,7 +6,6 @@
 </template>
 
 <script lang="ts" setup>
-import { usePageTitleStore } from "@/stores/page-title.store";
 import { computed } from "vue";
 import { useRouter } from "vue-router";
 import { faBook } from "@fortawesome/free-solid-svg-icons";
@@ -21,8 +20,6 @@ const title = computed(() => {
 
   return `${currentRoute.value.meta.storyTitle} Story`;
 });
-
-usePageTitleStore().setTitle(title);
 </script>
 
 <style lang="postcss" scoped></style>

@xen-orchestra/lite/src/views/host/HostDashboardView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("dashboard"));
 </script>

@xen-orchestra/lite/src/views/host/HostRootView.vue

@@ -8,22 +8,17 @@
 import ObjectNotFoundWrapper from "@/components/ObjectNotFoundWrapper.vue";
 import type { XenApiHost } from "@/libs/xen-api";
 import { useHostStore } from "@/stores/host.store";
-import { usePageTitleStore } from "@/stores/page-title.store";
 import { useUiStore } from "@/stores/ui.store";
-import { computed, watchEffect } from "vue";
+import { watchEffect } from "vue";
 import { useRoute } from "vue-router";
 
 const { hasUuid, isReady, getByUuid } = useHostStore().subscribe();
 const route = useRoute();
 const uiStore = useUiStore();
 
-const currentHost = computed(() =>
-  getByUuid(route.params.uuid as XenApiHost["uuid"])
-);
-
 watchEffect(() => {
-  uiStore.currentHostOpaqueRef = currentHost.value?.$ref;
+  uiStore.currentHostOpaqueRef = getByUuid(
+    route.params.uuid as XenApiHost["uuid"]
+  )?.$ref;
 });
-
-usePageTitleStore().setObject(currentHost);
 </script>

@xen-orchestra/lite/src/views/pool/PoolAlarmsView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("alarms"));
 </script>

@xen-orchestra/lite/src/views/pool/PoolDashboardView.vue

@@ -21,7 +21,7 @@
       </UiCardGroup>
     </UiCardGroup>
     <UiCardGroup>
-      <PoolDashboardTasks class="tasks" />
+      <UiCardComingSoon class="tasks" title="Tasks" />
     </UiCardGroup>
   </div>
 </template>
@@ -31,24 +31,8 @@ export const N_ITEMS = 5;
 </script>
 
 <script lang="ts" setup>
-import PoolDashboardTasks from "@/components/pool/dashboard/PoolDashboardTasks.vue";
-import PoolCpuUsageChart from "@/components/pool/dashboard/cpuUsage/PoolCpuUsageChart.vue";
-import PoolDashboardCpuProvisioning from "@/components/pool/dashboard/PoolDashboardCpuProvisioning.vue";
-import PoolDashboardCpuUsage from "@/components/pool/dashboard/PoolDashboardCpuUsage.vue";
-import PoolDashboardNetworkChart from "@/components/pool/dashboard/PoolDashboardNetworkChart.vue";
-import PoolDashboardRamUsage from "@/components/pool/dashboard/PoolDashboardRamUsage.vue";
-import PoolDashboardStatus from "@/components/pool/dashboard/PoolDashboardStatus.vue";
-import PoolDashboardStorageUsage from "@/components/pool/dashboard/PoolDashboardStorageUsage.vue";
-import PoolDashboardRamUsageChart from "@/components/pool/dashboard/ramUsage/PoolRamUsage.vue";
-import UiCardComingSoon from "@/components/ui/UiCardComingSoon.vue";
 import UiCardGroup from "@/components/ui/UiCardGroup.vue";
-import useFetchStats from "@/composables/fetch-stats.composable";
-import { GRANULARITY, type HostStats, type VmStats } from "@/libs/xapi-stats";
-import type { XenApiHost, XenApiVm } from "@/libs/xen-api";
 import { useHostMetricsStore } from "@/stores/host-metrics.store";
-import { useHostStore } from "@/stores/host.store";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useVmStore } from "@/stores/vm.store";
 import {
   IK_HOST_LAST_WEEK_STATS,
   IK_HOST_STATS,
@@ -56,9 +40,20 @@ import {
 } from "@/types/injection-keys";
 import { differenceBy } from "lodash-es";
 import { provide, watch } from "vue";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("dashboard"));
+import UiCardComingSoon from "@/components/ui/UiCardComingSoon.vue";
+import PoolCpuUsageChart from "@/components/pool/dashboard/cpuUsage/PoolCpuUsageChart.vue";
+import PoolDashboardCpuUsage from "@/components/pool/dashboard/PoolDashboardCpuUsage.vue";
+import PoolDashboardNetworkChart from "@/components/pool/dashboard/PoolDashboardNetworkChart.vue";
+import PoolDashboardCpuProvisioning from "@/components/pool/dashboard/PoolDashboardCpuProvisioning.vue";
+import PoolDashboardRamUsage from "@/components/pool/dashboard/PoolDashboardRamUsage.vue";
+import PoolDashboardRamUsageChart from "@/components/pool/dashboard/ramUsage/PoolRamUsage.vue";
+import PoolDashboardStatus from "@/components/pool/dashboard/PoolDashboardStatus.vue";
+import PoolDashboardStorageUsage from "@/components/pool/dashboard/PoolDashboardStorageUsage.vue";
+import useFetchStats from "@/composables/fetch-stats.composable";
+import { GRANULARITY, type HostStats, type VmStats } from "@/libs/xapi-stats";
+import type { XenApiHost, XenApiVm } from "@/libs/xen-api";
+import { useHostStore } from "@/stores/host.store";
+import { useVmStore } from "@/stores/vm.store";
 
 const hostMetricsSubscription = useHostMetricsStore().subscribe();
 
@@ -129,18 +124,6 @@ runningVms.value.forEach((vm) => vmRegister(vm));
   padding: 1rem;
 }
 
-@media (min-width: 768px) {
-  .pool-dashboard-view {
-    column-count: 2;
-  }
-}
-
-@media (min-width: 1500px) {
-  .pool-dashboard-view {
-    column-count: 3;
-  }
-}
-
 .alarms,
 .tasks {
   flex: 1;

@xen-orchestra/lite/src/views/pool/PoolHostsView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("hosts"));
 </script>

@xen-orchestra/lite/src/views/pool/PoolNetworkView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("network"));
 </script>

@xen-orchestra/lite/src/views/pool/PoolRootView.vue

@@ -10,11 +10,6 @@
 <script lang="ts" setup>
 import PoolHeader from "@/components/pool/PoolHeader.vue";
 import PoolTabBar from "@/components/pool/PoolTabBar.vue";
-import { usePoolStore } from "@/stores/pool.store";
-import { usePageTitleStore } from "@/stores/page-title.store";
-
-const { pool } = usePoolStore().subscribe();
-usePageTitleStore().setObject(pool);
 </script>
 
 <style lang="postcss" scoped></style>

@xen-orchestra/lite/src/views/pool/PoolStatsView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("stats"));
 </script>

@xen-orchestra/lite/src/views/pool/PoolStorageView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("storage"));
 </script>

@xen-orchestra/lite/src/views/pool/PoolSystemView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("system"));
 </script>

@xen-orchestra/lite/src/views/pool/PoolTasksView.vue

@@ -4,28 +4,58 @@
       {{ $t("tasks") }}
       <UiCounter :value="pendingTasks.length" color="info" />
     </UiTitle>
+
     <TasksTable :finished-tasks="finishedTasks" :pending-tasks="pendingTasks" />
-    <UiCardSpinner v-if="!isReady" />
   </UiCard>
 </template>
 
 <script lang="ts" setup>
 import TasksTable from "@/components/tasks/TasksTable.vue";
 import UiCard from "@/components/ui/UiCard.vue";
-import UiCardSpinner from "@/components/ui/UiCardSpinner.vue";
 import UiCounter from "@/components/ui/UiCounter.vue";
 import UiTitle from "@/components/ui/UiTitle.vue";
+import useArrayRemovedItemsHistory from "@/composables/array-removed-items-history.composable";
+import useCollectionFilter from "@/composables/collection-filter.composable";
+import useCollectionSorter from "@/composables/collection-sorter.composable";
+import useFilteredCollection from "@/composables/filtered-collection.composable";
+import useSortedCollection from "@/composables/sorted-collection.composable";
+import type { XenApiTask } from "@/libs/xen-api";
 import { useTaskStore } from "@/stores/task.store";
-import { usePageTitleStore } from "@/stores/page-title.store";
+import { useTitle } from "@vueuse/core";
+import { computed } from "vue";
 import { useI18n } from "vue-i18n";
 
-const { pendingTasks, finishedTasks, isReady, hasError } =
-  useTaskStore().subscribe();
+const { records, hasError } = useTaskStore().subscribe();
 const { t } = useI18n();
 
-const titleStore = usePageTitleStore();
-titleStore.setTitle(t("tasks"));
-titleStore.setCount(() => pendingTasks.value.length);
+const { compareFn } = useCollectionSorter<XenApiTask>({
+  initialSorts: ["-created"],
+});
+
+const allTasks = useSortedCollection(records, compareFn);
+
+const { predicate } = useCollectionFilter({
+  initialFilters: ["!name_label:|(SR.scan host.call_plugin)", "status:pending"],
+});
+
+const pendingTasks = useFilteredCollection<XenApiTask>(allTasks, predicate);
+
+const finishedTasks = useArrayRemovedItemsHistory(
+  allTasks,
+  (task) => task.uuid,
+  {
+    limit: 50,
+    onRemove: (tasks) =>
+      tasks.map((task) => ({
+        ...task,
+        finished: new Date().toISOString(),
+      })),
+  }
+);
+
+useTitle(
+  computed(() => t("task.page-title", { n: pendingTasks.value.length }))
+);
 </script>
 
 <style lang="postcss" scoped>

@xen-orchestra/lite/src/views/pool/PoolVmsView.vue

@@ -38,7 +38,6 @@ import UiCard from "@/components/ui/UiCard.vue";
 import UiCardTitle from "@/components/ui/UiCardTitle.vue";
 import VmsActionsBar from "@/components/vm/VmsActionsBar.vue";
 import { POWER_STATE } from "@/libs/xen-api";
-import { usePageTitleStore } from "@/stores/page-title.store";
 import { useUiStore } from "@/stores/ui.store";
 import { useVmStore } from "@/stores/vm.store";
 import type { Filters } from "@/types/filter";
@@ -47,13 +46,9 @@ import { storeToRefs } from "pinia";
 import { ref } from "vue";
 import { useI18n } from "vue-i18n";
 
-const { t } = useI18n();
-
-const titleStore = usePageTitleStore();
-titleStore.setTitle(t("vms"));
-
 const { records: vms } = useVmStore().subscribe();
 const { isMobile, isDesktop } = storeToRefs(useUiStore());
+const { t } = useI18n();
 
 const filters: Filters = {
   name_label: { label: t("name"), type: "string" },
@@ -67,8 +62,6 @@ const filters: Filters = {
 };
 
 const selectedVmsRefs = ref([]);
-
-titleStore.setCount(() => selectedVmsRefs.value.length);
 </script>
 
 <style lang="postcss" scoped>

@xen-orchestra/lite/src/views/settings/SettingsView.vue

@@ -157,7 +157,6 @@
 </template>
 
 <script lang="ts" setup>
-import { usePageTitleStore } from "@/stores/page-title.store";
 import { computed } from "vue";
 import UiCardTitle from "@/components/ui/UiCardTitle.vue";
 import UiIcon from "@/components/ui/icon/UiIcon.vue";
@@ -182,9 +181,7 @@ import UiKeyValueRow from "@/components/ui/UiKeyValueRow.vue";
 
 const xoLiteVersion = XO_LITE_VERSION;
 const xoLiteGitHead = XO_LITE_GIT_HEAD;
-const { t, locale } = useI18n();
-
-usePageTitleStore().setTitle(() => t("settings"));
+const { locale } = useI18n();
 
 const { pool } = usePoolStore().subscribe();
 const { getByOpaqueRef: getHost } = useHostStore().subscribe();

@xen-orchestra/lite/src/views/vm/VmAlarmsView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("alarms"));
 </script>

@xen-orchestra/lite/src/views/vm/VmConsoleView.vue

@@ -1,46 +1,21 @@
 <template>
-  <div :class="{ 'no-ui': !uiStore.hasUi }" class="vm-console-view">
-    <div v-if="hasError">{{ $t("error-occurred") }}</div>
-    <UiSpinner v-else-if="!isReady" class="spinner" />
-    <div v-else-if="!isVmRunning" class="not-running">
-      <div><img alt="" src="@/assets/monitor.svg" /></div>
-      {{ $t("power-on-for-console") }}
-    </div>
-    <template v-else-if="vm && vmConsole">
-      <RemoteConsole
-        :is-console-available="isConsoleAvailable"
-        :location="vmConsole.location"
-        class="remote-console"
-      />
-      <div class="open-in-new-window">
-        <RouterLink
-          v-if="uiStore.hasUi"
-          :to="{ query: { ui: '0' } }"
-          class="link"
-          target="_blank"
-        >
-          <UiIcon :icon="faArrowUpRightFromSquare" />
-          {{ $t("open-in-new-window") }}
-        </RouterLink>
-      </div>
-    </template>
-  </div>
+  <div v-if="!isReady">Loading...</div>
+  <div v-else-if="!isVmRunning">Console is only available for running VMs.</div>
+  <RemoteConsole
+    v-else-if="vm && vmConsole"
+    :location="vmConsole.location"
+    :is-console-available="!isOperationsPending(vm, STOP_OPERATIONS)"
+  />
 </template>
 
 <script lang="ts" setup>
-import RemoteConsole from "@/components/RemoteConsole.vue";
-import UiIcon from "@/components/ui/icon/UiIcon.vue";
-import UiSpinner from "@/components/ui/UiSpinner.vue";
-import { isOperationsPending } from "@/libs/utils";
 import { POWER_STATE, VM_OPERATION, type XenApiVm } from "@/libs/xen-api";
-import { useConsoleStore } from "@/stores/console.store";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useUiStore } from "@/stores/ui.store";
-import { useVmStore } from "@/stores/vm.store";
-import { faArrowUpRightFromSquare } from "@fortawesome/free-solid-svg-icons";
 import { computed } from "vue";
-import { useI18n } from "vue-i18n";
 import { useRoute } from "vue-router";
+import RemoteConsole from "@/components/RemoteConsole.vue";
+import { useConsoleStore } from "@/stores/console.store";
+import { useVmStore } from "@/stores/vm.store";
+import { isOperationsPending } from "@/libs/utils";
 
 const STOP_OPERATIONS = [
   VM_OPERATION.SHUTDOWN,
@@ -52,27 +27,15 @@ const STOP_OPERATIONS = [
   VM_OPERATION.SUSPEND,
 ];
 
-usePageTitleStore().setTitle(useI18n().t("console"));
-
 const route = useRoute();
-const uiStore = useUiStore();
 
-const {
-  isReady: isVmReady,
-  getByUuid: getVmByUuid,
-  hasError: hasVmError,
-} = useVmStore().subscribe();
+const { isReady: isVmReady, getByUuid: getVmByUuid } = useVmStore().subscribe();
 
-const {
-  isReady: isConsoleReady,
-  getByOpaqueRef: getConsoleByOpaqueRef,
-  hasError: hasConsoleError,
-} = useConsoleStore().subscribe();
+const { isReady: isConsoleReady, getByOpaqueRef: getConsoleByOpaqueRef } =
+  useConsoleStore().subscribe();
 
 const isReady = computed(() => isVmReady.value && isConsoleReady.value);
 
-const hasError = computed(() => hasVmError.value || hasConsoleError.value);
-
 const vm = computed(() => getVmByUuid(route.params.uuid as XenApiVm["uuid"]));
 
 const isVmRunning = computed(
@@ -88,74 +51,4 @@ const vmConsole = computed(() => {
 
   return getConsoleByOpaqueRef(consoleOpaqueRef);
 });
-
-const isConsoleAvailable = computed(
-  () =>
-    vm.value !== undefined && !isOperationsPending(vm.value, STOP_OPERATIONS)
-);
 </script>
-
-<style lang="postcss" scoped>
-.vm-console-view {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  height: calc(100% - 14.5rem);
-
-  &.no-ui {
-    height: 100%;
-  }
-}
-
-.spinner {
-  color: var(--color-extra-blue-base);
-  display: flex;
-  margin: auto;
-  width: 10rem;
-  height: 10rem;
-}
-
-.remote-console {
-  flex: 1;
-  max-width: 100%;
-  height: 100%;
-}
-
-.not-running,
-.not-available {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  flex-direction: column;
-  text-align: center;
-  gap: 4rem;
-  color: var(--color-extra-blue-base);
-  font-size: 3.6rem;
-}
-
-.open-in-new-window {
-  position: absolute;
-  top: 0;
-  right: 0;
-  overflow: hidden;
-
-  & > .link {
-    display: flex;
-    align-items: center;
-    gap: 1rem;
-    background-color: var(--color-extra-blue-base);
-    color: var(--color-blue-scale-500);
-    text-decoration: none;
-    padding: 1.5rem;
-    font-size: 1.6rem;
-    border-radius: 0 0 0 0.8rem;
-    white-space: nowrap;
-    transform: translateX(calc(100% - 4.5rem));
-    transition: transform 0.2s ease-in-out;
-
-    &:hover {
-      transform: translateX(0);
-    }
-  }
-}
-</style>

@xen-orchestra/lite/src/views/vm/VmDashboardView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("dashboard"));
 </script>

@xen-orchestra/lite/src/views/vm/VmNetworkView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("network"));
 </script>

@xen-orchestra/lite/src/views/vm/VmRootView.vue

@@ -1,9 +1,7 @@
 <template>
   <ObjectNotFoundWrapper :is-ready="isReady" :uuid-checker="hasUuid">
-    <template v-if="uiStore.hasUi">
-      <VmHeader />
-      <VmTabBar :uuid="vm!.uuid" />
-    </template>
+    <VmHeader />
+    <VmTabBar :uuid="vm!.uuid" />
     <RouterView />
   </ObjectNotFoundWrapper>
 </template>
@@ -13,7 +11,6 @@ import ObjectNotFoundWrapper from "@/components/ObjectNotFoundWrapper.vue";
 import VmHeader from "@/components/vm/VmHeader.vue";
 import VmTabBar from "@/components/vm/VmTabBar.vue";
 import type { XenApiVm } from "@/libs/xen-api";
-import { usePageTitleStore } from "@/stores/page-title.store";
 import { useUiStore } from "@/stores/ui.store";
 import { useVmStore } from "@/stores/vm.store";
 import { whenever } from "@vueuse/core";
@@ -25,5 +22,4 @@ const { getByUuid, hasUuid, isReady } = useVmStore().subscribe();
 const uiStore = useUiStore();
 const vm = computed(() => getByUuid(route.params.uuid as XenApiVm["uuid"]));
 whenever(vm, (vm) => (uiStore.currentHostOpaqueRef = vm.resident_on));
-usePageTitleStore().setObject(vm);
 </script>

@xen-orchestra/lite/src/views/vm/VmStatsView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("stats"));
 </script>

@xen-orchestra/lite/src/views/vm/VmStorageView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("storage"));
 </script>

@xen-orchestra/lite/src/views/vm/VmSystemView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("system"));
 </script>

@xen-orchestra/lite/src/views/vm/VmTasksView.vue

@@ -4,8 +4,4 @@
 
 <script lang="ts" setup>
 import PageUnderConstruction from "@/components/PageUnderConstruction.vue";
-import { usePageTitleStore } from "@/stores/page-title.store";
-import { useI18n } from "vue-i18n";
-
-usePageTitleStore().setTitle(useI18n().t("tasks"));
 </script>

@xen-orchestra/mixins/Hooks.mjs

@@ -11,18 +11,10 @@ const runHook = async (emitter, hook, onResult = noop) => {
   const listeners = emitter.listeners(hook)
   await Promise.all(
     listeners.map(async listener => {
-      const handle = setInterval(() => {
-        warn(
-          `${hook} ${listener.name || 'anonymous'} listener is still running`,
-          listener.name ? undefined : { source: listener.toString() }
-        )
-      }, 5e3)
       try {
         onResult(await listener.call(emitter))
       } catch (error) {
         warn(`${hook} failure`, { error })
-      } finally {
-        clearInterval(handle)
       }
     })
   )

@xen-orchestra/mixins/package.json

@@ -14,7 +14,7 @@
     "url": "https://vates.fr"
   },
   "license": "AGPL-3.0-or-later",
-  "version": "0.11.0",
+  "version": "0.10.2",
   "engines": {
     "node": ">=15.6"
   },

@xen-orchestra/openflow/package.json

@@ -30,7 +30,7 @@
     "rimraf": "^5.0.1"
   },
   "dependencies": {
-    "@vates/read-chunk": "^1.2.0"
+    "@vates/read-chunk": "^1.1.1"
   },
   "author": {
     "name": "Vates SAS",

@xen-orchestra/proxy-cli/package.json

@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@iarna/toml": "^2.2.0",
-    "@vates/read-chunk": "^1.2.0",
+    "@vates/read-chunk": "^1.1.1",
     "ansi-colors": "^4.1.1",
     "app-conf": "^2.3.0",
     "content-type": "^1.0.4",

@xen-orchestra/proxy/app/mixins/api.mjs

@@ -58,7 +58,7 @@ const ndJsonStream = asyncIteratorToStream(async function* (responseId, iterable
 
 export default class Api {
   constructor(app, { appVersion, httpServer }) {
-    this._ajv = new Ajv({ allErrors: true, useDefaults: true })
+    this._ajv = new Ajv({ allErrors: true })
     this._methods = { __proto__: null }
     const PREFIX = '/api/v1'
     const router = new Router({ prefix: PREFIX }).post('/', async ctx => {

@xen-orchestra/proxy/app/mixins/backups.mjs

@@ -174,15 +174,12 @@ export default class Backups {
           },
         ],
         fetchPartitionFiles: [
-          ({ disk: diskId, format, remote, partition: partitionId, paths }) =>
-            Disposable.use(this.getAdapter(remote), adapter =>
-              adapter.fetchPartitionFiles(diskId, partitionId, paths, format)
-            ),
+          ({ disk: diskId, remote, partition: partitionId, paths }) =>
+            Disposable.use(this.getAdapter(remote), adapter => adapter.fetchPartitionFiles(diskId, partitionId, paths)),
           {
             description: 'fetch files from partition',
             params: {
               disk: { type: 'string' },
-              format: { type: 'string', default: 'zip' },
               partition: { type: 'string', optional: true },
               paths: { type: 'array', items: { type: 'string' } },
               remote: { type: 'object' },

@xen-orchestra/proxy/package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "@xen-orchestra/proxy",
-  "version": "0.26.30",
+  "version": "0.26.29",
   "license": "AGPL-3.0-or-later",
   "description": "XO Proxy used to remotely execute backup jobs",
   "keywords": [
@@ -32,18 +32,18 @@
     "@vates/decorate-with": "^2.0.0",
     "@vates/disposable": "^0.1.4",
     "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/backups": "^0.40.0",
+    "@xen-orchestra/backups": "^0.39.0",
     "@xen-orchestra/fs": "^4.0.1",
     "@xen-orchestra/log": "^0.6.0",
     "@xen-orchestra/mixin": "^0.1.0",
-    "@xen-orchestra/mixins": "^0.11.0",
+    "@xen-orchestra/mixins": "^0.10.2",
     "@xen-orchestra/self-signed": "^0.1.3",
-    "@xen-orchestra/xapi": "^3.0.0",
+    "@xen-orchestra/xapi": "^2.2.1",
     "ajv": "^8.0.3",
     "app-conf": "^2.3.0",
     "async-iterator-to-stream": "^1.1.0",
     "fs-extra": "^11.1.0",
-    "get-stream": "^7.0.1",
+    "get-stream": "^6.0.0",
     "getopts": "^2.2.3",
     "golike-defer": "^0.5.1",
     "http-server-plus": "^1.0.0",
@@ -60,7 +60,7 @@
     "source-map-support": "^0.5.16",
     "stoppable": "^1.0.6",
     "xdg-basedir": "^5.1.0",
-    "xen-api": "^1.3.4",
+    "xen-api": "^1.3.3",
     "xo-common": "^0.8.0"
   },
   "devDependencies": {

@xen-orchestra/vmware-explorer/VhdEsxiCowd.mjs

@@ -48,7 +48,7 @@ export default class VhdEsxiCowd extends VhdAbstract {
 
     // depending on the paramters we also look into the parent data
     return (
-      this.#grainDirectory.readUInt32LE(blockId * 4) !== 0 ||
+      this.#grainDirectory.readInt32LE(blockId * 4) !== 0 ||
       (this.#lookMissingBlockInParent && this.#parentVhd.containsBlock(blockId))
     )
   }
@@ -61,14 +61,14 @@ export default class VhdEsxiCowd extends VhdAbstract {
     const buffer = await this.#read(0, 2048)
 
     strictEqual(buffer.slice(0, 4).toString('ascii'), 'COWD')
-    strictEqual(buffer.readUInt32LE(4), 1) // version
-    strictEqual(buffer.readUInt32LE(8), 3) // flags
-    const numSectors = buffer.readUInt32LE(12)
-    const grainSize = buffer.readUInt32LE(16)
+    strictEqual(buffer.readInt32LE(4), 1) // version
+    strictEqual(buffer.readInt32LE(8), 3) // flags
+    const numSectors = buffer.readInt32LE(12)
+    const grainSize = buffer.readInt32LE(16)
     strictEqual(grainSize, 1) // 1 grain should be 1 sector long
-    strictEqual(buffer.readUInt32LE(20), 4) // grain directory position in sectors
+    strictEqual(buffer.readInt32LE(20), 4) // grain directory position in sectors
 
-    const nbGrainDirectoryEntries = buffer.readUInt32LE(24)
+    const nbGrainDirectoryEntries = buffer.readInt32LE(24)
     strictEqual(nbGrainDirectoryEntries, Math.ceil(numSectors / 4096))
     const size = numSectors * 512
     // a grain directory entry contains the address of a grain table
@@ -90,7 +90,7 @@ export default class VhdEsxiCowd extends VhdAbstract {
   // we're lucky : a grain address can address exacty a full block
   async readBlock(blockId) {
     notEqual(this.#grainDirectory, undefined, 'grainDirectory is not loaded')
-    const sectorOffset = this.#grainDirectory.readUInt32LE(blockId * 4)
+    const sectorOffset = this.#grainDirectory.readInt32LE(blockId * 4)
 
     const buffer = (await this.#parentVhd.readBlock(blockId)).buffer
 
@@ -137,7 +137,7 @@ export default class VhdEsxiCowd extends VhdAbstract {
     }
 
     for (let i = 0; i < graintable.length / 4; i++) {
-      const grainOffset = graintable.readUInt32LE(i * 4)
+      const grainOffset = graintable.readInt32LE(i * 4)
       if (grainOffset === 0) {
         // the content from parent : it is already in buffer
         await changeRange()

@xen-orchestra/vmware-explorer/VhdEsxiRaw.mjs

@@ -1,7 +1,7 @@
 import _computeGeometryForSize from 'vhd-lib/_computeGeometryForSize.js'
 import { createFooter, createHeader } from 'vhd-lib/_createFooterHeader.js'
 import { DISK_TYPES, FOOTER_SIZE } from 'vhd-lib/_constants.js'
-import { readChunkStrict, skipStrict } from '@vates/read-chunk'
+import { readChunk } from '@vates/read-chunk'
 import { Task } from '@vates/task'
 import { unpackFooter, unpackHeader } from 'vhd-lib/Vhd/_utils.js'
 import { VhdAbstract } from 'vhd-lib'
@@ -21,10 +21,6 @@ export default class VhdEsxiRaw extends VhdAbstract {
   #header
   #footer
 
-  #streamOffset = 0
-  #stream
-  #reading = false
-
   static async open(esxi, datastore, path, opts) {
     const vhd = new VhdEsxiRaw(esxi, datastore, path, opts)
     await vhd.readHeaderAndFooter()
@@ -53,10 +49,10 @@ export default class VhdEsxiRaw extends VhdAbstract {
 
     this.#header = unpackHeader(createHeader(length / VHD_BLOCK_LENGTH))
     const geometry = _computeGeometryForSize(length)
+    const actualSize = geometry.actualSize
 
     this.#footer = unpackFooter(
-      // length can be smaller than disk capacity due to alignment to head/cylinder/sector
-      createFooter(length, Math.floor(Date.now() / 1000), geometry, FOOTER_SIZE, DISK_TYPES.DYNAMIC)
+      createFooter(actualSize, Math.floor(Date.now() / 1000), geometry, FOOTER_SIZE, DISK_TYPES.DYNAMIC)
     )
   }
 
@@ -68,65 +64,12 @@ export default class VhdEsxiRaw extends VhdAbstract {
     return this.#bat.has(blockId)
   }
 
-  async #readChunk(start, length) {
-    if (this.#reading) {
-      throw new Error('reading must be done sequentially')
-    }
-    try {
-      this.#reading = true
-      if (this.#stream !== undefined) {
-        // stream is too far ahead or to far behind
-        if (this.#streamOffset > start || this.#streamOffset + VHD_BLOCK_LENGTH < start) {
-          this.#stream.destroy()
-          this.#stream = undefined
-          this.#streamOffset = 0
-        }
-      }
-      // no stream
-      if (this.#stream === undefined) {
-        const end = this.footer.currentSize - 1
-        const res = await this.#esxi.download(this.#datastore, this.#path, `${start}-${end}`)
-        this.#stream = res.body
-        this.#streamOffset = start
-      }
-
-      // stream a little behind
-      if (this.#streamOffset < start) {
-        await skipStrict(this.#stream, start - this.#streamOffset)
-        this.#streamOffset = start
-      }
-
-      // really read data
-      this.#streamOffset += length
-      const data = await readChunkStrict(this.#stream, length)
-      return data
-    } catch (error) {
-      error.start = start
-      error.length = length
-      error.streamLength = this.footer.currentSize
-      this.#stream?.destroy()
-      this.#stream = undefined
-      this.#streamOffset = 0
-      throw error
-    } finally {
-      this.#reading = false
-    }
-  }
-
-  async #readBlock(blockId) {
+  async readBlock(blockId) {
     const start = blockId * VHD_BLOCK_LENGTH
-    let length = VHD_BLOCK_LENGTH
-    let partial = false
-    if (start + length > this.footer.currentSize) {
-      length = this.footer.currentSize - start
-      partial = true
-    }
+    const end = (blockId + 1) * VHD_BLOCK_LENGTH - 1
 
-    let data = await this.#readChunk(start, length)
+    const data = await (await this.#esxi.download(this.#datastore, this.#path, `${start}-${end}`)).buffer()
 
-    if (partial) {
-      data = Buffer.concat([data, Buffer.alloc(VHD_BLOCK_LENGTH - data.length)])
-    }
     const bitmap = Buffer.alloc(512, 255)
     return {
       id: blockId,
@@ -136,44 +79,28 @@ export default class VhdEsxiRaw extends VhdAbstract {
     }
   }
 
-  async readBlock(blockId) {
-    let tries = 5
-    let lastError
-    while (tries > 0) {
-      try {
-        const res = await this.#readBlock(blockId)
-        return res
-      } catch (error) {
-        lastError = error
-        lastError.blockId = blockId
-        console.warn('got error , will retry in 2seconds', lastError)
-      }
-      await new Promise(resolve => setTimeout(() => resolve(), 2000))
-      tries--
-    }
-
-    throw lastError
-  }
-
   // this will read all the disk once to check which block contains data, it can take a long time to execute depending on the network speed
   async readBlockAllocationTable() {
     if (!this.#thin) {
       // fast path : is we do not use thin mode, the BAT is full
       return
     }
+    const res = await this.#esxi.download(this.#datastore, this.#path)
+    const length = res.headers.get('content-length')
+    const stream = res.body
     const empty = Buffer.alloc(VHD_BLOCK_LENGTH, 0)
     let pos = 0
     this.#bat = new Set()
-    let nextChunkLength = Math.min(VHD_BLOCK_LENGTH, this.footer.currentSize)
-    Task.set('total', this.footer.currentSize / VHD_BLOCK_LENGTH)
+    let nextChunkLength = Math.min(VHD_BLOCK_LENGTH, length)
+    Task.set('total', length / VHD_BLOCK_LENGTH)
     const progress = setInterval(() => {
-      Task.set('progress', Math.round((pos * 100) / this.footer.currentSize))
-      console.log('reading blocks', pos / VHD_BLOCK_LENGTH, '/', this.footer.currentSize / VHD_BLOCK_LENGTH)
+      Task.set('progress', Math.round((pos * 100) / length))
+      console.log('reading blocks', pos / VHD_BLOCK_LENGTH, '/', length / VHD_BLOCK_LENGTH)
     }, 30 * 1000)
 
     while (nextChunkLength > 0) {
       try {
-        const chunk = await this.#readChunk(pos, nextChunkLength)
+        const chunk = await readChunk(stream, nextChunkLength)
         let isEmpty
         if (nextChunkLength === VHD_BLOCK_LENGTH) {
           isEmpty = empty.equals(chunk)
@@ -185,28 +112,15 @@ export default class VhdEsxiRaw extends VhdAbstract {
           this.#bat.add(pos / VHD_BLOCK_LENGTH)
         }
         pos += VHD_BLOCK_LENGTH
-        nextChunkLength = Math.min(VHD_BLOCK_LENGTH, this.footer.currentSize - pos)
+        nextChunkLength = Math.min(VHD_BLOCK_LENGTH, length - pos)
       } catch (error) {
         clearInterval(progress)
         throw error
       }
     }
-    console.log(
-      'BAT reading done, remaining  ',
-      this.#bat.size,
-      '/',
-      Math.ceil(this.footer.currentSize / VHD_BLOCK_LENGTH)
-    )
+    console.log('BAT reading done, remaining  ', this.#bat.size, '/', Math.ceil(length / VHD_BLOCK_LENGTH))
     clearInterval(progress)
   }
-
-  rawContent() {
-    return this.#esxi.download(this.#datastore, this.#path).then(res => {
-      const stream = res.body
-      stream.length = this.footer.currentSize
-      return stream
-    })
-  }
 }
 
 /* eslint-enable no-console */

@xen-orchestra/vmware-explorer/VhdEsxiSeSparse.mjs

@@ -1,54 +1,18 @@
 import _computeGeometryForSize from 'vhd-lib/_computeGeometryForSize.js'
 import { createFooter, createHeader } from 'vhd-lib/_createFooterHeader.js'
-import { DISK_TYPES, FOOTER_SIZE } from 'vhd-lib/_constants.js'
+import { FOOTER_SIZE } from 'vhd-lib/_constants.js'
 import { notEqual, strictEqual } from 'node:assert'
 import { unpackFooter, unpackHeader } from 'vhd-lib/Vhd/_utils.js'
 import { VhdAbstract } from 'vhd-lib'
 
-// one big difference with the other versions of VMDK is that the grain tables are actually sparse, they are pre-allocated but not used in grain order,
-// so we have to read the grain directory to know where to find the grain tables
+// from https://github.com/qemu/qemu/commit/98eb9733f4cf2eeab6d12db7e758665d2fd5367b#
 
-const SE_SPARSE_DIR_NON_ALLOCATED = 0
-const SE_SPARSE_DIR_ALLOCATED = 1
-
-const SE_SPARSE_GRAIN_NON_ALLOCATED = 0 // check in parent
-const SE_SPARSE_GRAIN_UNMAPPED = 1 // grain has been unmapped, but index of previous grain still readable for reclamation
-const SE_SPARSE_GRAIN_ZERO = 2
-const SE_SPARSE_GRAIN_ALLOCATED = 3
-
-const VHD_BLOCK_SIZE_BYTES = 2 * 1024 * 1024
-const GRAIN_SIZE_BYTES = 4 * 1024
-const GRAIN_TABLE_COUNT = 4 * 1024
-
-const ones = n => (1n << BigInt(n)) - 1n
-
-function asNumber(n) {
-  if (n > Number.MAX_SAFE_INTEGER)
+function readInt64(buffer, index) {
+  const n = buffer.readBigInt64LE(index * 8 /* size of an int64 in bytes */)
+  if (n > Number.MAX_SAFE_INTEGER) {
     throw new Error(`can't handle ${n} ${Number.MAX_SAFE_INTEGER} ${n & 0x00000000ffffffffn}`)
-  return Number(n)
-}
-
-const readInt64 = (buffer, index) => asNumber(buffer.readBigInt64LE(index * 8))
-
-/**
- * @returns {{topNibble: number, low60: bigint}} topNibble is the first 4 bits of the 64 bits entry, indexPart is the remaining 60 bits
- */
-function readTaggedEntry(buffer, index) {
-  const entry = buffer.readBigInt64LE(index * 8)
-  return { topNibble: Number(entry >> 60n), low60: entry & ones(60) }
-}
-
-function readSeSparseDir(buffer, index) {
-  const { topNibble, low60 } = readTaggedEntry(buffer, index)
-  return { type: topNibble, tableIndex: asNumber(low60) }
-}
-
-function readSeSparseTable(buffer, index) {
-  const { topNibble, low60 } = readTaggedEntry(buffer, index)
-  // https://lists.gnu.org/archive/html/qemu-block/2019-06/msg00934.html
-  const topIndexPart = low60 >> 48n // bring the top 12 bits down
-  const bottomIndexPart = (low60 & ones(48)) << 12n // bring the bottom 48 bits up
-  return { type: topNibble, grainIndex: asNumber(bottomIndexPart | topIndexPart) }
+  }
+  return +n
 }
 
 export default class VhdEsxiSeSparse extends VhdAbstract {
@@ -61,22 +25,27 @@ export default class VhdEsxiSeSparse extends VhdAbstract {
   #header
   #footer
 
-  #grainIndex // Map blockId => []
+  #grainDirectory
+  // as we will read all grain with data with load everything in memory
+  // in theory , that can be 512MB of data for a 2TB fully allocated
+  // but our use case is to transfer a relatively small diff
+  // and random access is expensive in HTTP, and migration is a one time cors
+  // so let's go with naive approach, and future me will have to handle a more
+  // clever approach if necessary
+  // grain at zero won't be stored
 
-  #grainDirOffsetBytes
-  #grainDirSizeBytes
-  #grainTableOffsetBytes
-  #grainOffsetBytes
+  #grainMap = new Map()
+
+  #grainSize
+  #grainTableSize
+  #grainTableOffset
+  #grainOffset
 
   static async open(esxi, datastore, path, parentVhd, opts) {
     const vhd = new VhdEsxiSeSparse(esxi, datastore, path, parentVhd, opts)
     await vhd.readHeaderAndFooter()
     return vhd
   }
-
-  get path() {
-    return this.#path
-  }
   constructor(esxi, datastore, path, parentVhd, { lookMissingBlockInParent = true } = {}) {
     super()
     this.#esxi = esxi
@@ -94,149 +63,156 @@ export default class VhdEsxiSeSparse extends VhdAbstract {
     return this.#footer
   }
 
+  async #readGrain(start, length = 4 * 1024) {
+    return (await this.#esxi.download(this.#datastore, this.#path, `${start}-${start + length - 1}`)).buffer()
+  }
+
   containsBlock(blockId) {
-    notEqual(this.#grainIndex, undefined, "bat must be loaded to use contain blocks'")
+    notEqual(this.#grainDirectory, undefined, "bat must be loaded to use contain blocks'")
+
+    // a grain table is 4096 entries of 4KB
+    // a grain table cover 8 vhd blocks
+    // grain table always exists in sespars
+
+    // depending on the paramters we also look into the parent data
     return (
-      this.#grainIndex.get(blockId) !== undefined ||
+      this.#grainDirectory.readInt32LE(blockId * 4) !== 0 ||
       (this.#lookMissingBlockInParent && this.#parentVhd.containsBlock(blockId))
     )
   }
 
-  async #read(start, length) {
-    const buffer = await (
-      await this.#esxi.download(this.#datastore, this.#path, `${start}-${start + length - 1}`)
-    ).buffer()
-    strictEqual(buffer.length, length)
-    return buffer
+  async #read(start, end) {
+    return (await this.#esxi.download(this.#datastore, this.#path, `${start}-${end}`)).buffer()
   }
 
   async readHeaderAndFooter() {
-    const vmdkHeaderBuffer = await this.#read(0, 2048)
+    const buffer = await this.#read(0, 2048)
+    strictEqual(buffer.readBigInt64LE(0), 0xcafebaben)
 
-    strictEqual(vmdkHeaderBuffer.readBigInt64LE(0), 0xcafebaben)
-    strictEqual(readInt64(vmdkHeaderBuffer, 1), 0x200000001) // version 2.1
+    strictEqual(readInt64(buffer, 1), 0x200000001) // version 2.1
 
-    this.#grainDirOffsetBytes = readInt64(vmdkHeaderBuffer, 16) * 512
-    // console.log('grainDirOffsetBytes', this.#grainDirOffsetBytes)
-    this.#grainDirSizeBytes = readInt64(vmdkHeaderBuffer, 17) * 512
-    // console.log('grainDirSizeBytes', this.#grainDirSizeBytes)
+    const capacity = readInt64(buffer, 2)
+    const grain_size = readInt64(buffer, 3)
 
-    const grainSizeSectors = readInt64(vmdkHeaderBuffer, 3)
-    const grainSizeBytes = grainSizeSectors * 512 // 8 sectors = 4KB default
-    strictEqual(grainSizeBytes, GRAIN_SIZE_BYTES) // we only support default grain size
+    const grain_tables_offset = readInt64(buffer, 18)
+    const grain_tables_size = readInt64(buffer, 19)
+    this.#grainOffset = readInt64(buffer, 24)
 
-    this.#grainTableOffsetBytes = readInt64(vmdkHeaderBuffer, 18) * 512
-    // console.log('grainTableOffsetBytes', this.#grainTableOffsetBytes)
+    this.#grainSize = grain_size * 512 // 8 sectors / 4KB default
+    this.#grainTableOffset = grain_tables_offset * 512
+    this.#grainTableSize = grain_tables_size * 512
 
-    const grainTableCount = (readInt64(vmdkHeaderBuffer, 4) * 512) / 8 // count is the number of 64b entries in each tables
-    // console.log('grainTableCount', grainTableCount)
-    strictEqual(grainTableCount, GRAIN_TABLE_COUNT) // we only support tables of 4096 entries (default)
-
-    this.#grainOffsetBytes = readInt64(vmdkHeaderBuffer, 24) * 512
-    // console.log('grainOffsetBytes', this.#grainOffsetBytes)
-
-    const sizeBytes = readInt64(vmdkHeaderBuffer, 2) * 512
-    // console.log('sizeBytes', sizeBytes)
-
-    const nbBlocks = Math.ceil(sizeBytes / VHD_BLOCK_SIZE_BYTES)
-    this.#header = unpackHeader(createHeader(nbBlocks))
-    const geometry = _computeGeometryForSize(sizeBytes)
+    const size = capacity * grain_size * 512
+    this.#header = unpackHeader(createHeader(Math.ceil(size / (4096 * 512))))
+    const geometry = _computeGeometryForSize(size)
+    const actualSize = geometry.actualSize
     this.#footer = unpackFooter(
-      createFooter(sizeBytes, Math.floor(Date.now() / 1000), geometry, FOOTER_SIZE, DISK_TYPES.DYNAMIC)
+      createFooter(actualSize, Math.floor(Date.now() / 1000), geometry, FOOTER_SIZE, this.#parentVhd.footer.diskType)
     )
   }
 
   async readBlockAllocationTable() {
-    this.#grainIndex = new Map()
+    const CHUNK_SIZE = 64 * 512
 
-    const tableSizeBytes = GRAIN_TABLE_COUNT * 8
-    const grainDirBuffer = await this.#read(this.#grainDirOffsetBytes, this.#grainDirSizeBytes)
-    // read the grain dir ( first level )
-    for (let grainDirIndex = 0; grainDirIndex < grainDirBuffer.length / 8; grainDirIndex++) {
-      const { type: grainDirType, tableIndex } = readSeSparseDir(grainDirBuffer, grainDirIndex)
-      if (grainDirType === SE_SPARSE_DIR_NON_ALLOCATED) {
-        // no grain table allocated at all in this grain dir
+    strictEqual(this.#grainTableSize % CHUNK_SIZE, 0)
+
+    for (let chunkIndex = 0, grainIndex = 0; chunkIndex < this.#grainTableSize / CHUNK_SIZE; chunkIndex++) {
+      process.stdin.write('.')
+      const start = chunkIndex * CHUNK_SIZE + this.#grainTableOffset
+      const end = start + 4096 * 8 - 1
+      const buffer = await this.#read(start, end)
+      for (let indexInChunk = 0; indexInChunk < 4096; indexInChunk++) {
+        const entry = buffer.readBigInt64LE(indexInChunk * 8)
+        switch (entry) {
+          case 0n: // not allocated, go to parent
+            break
+          case 1n: // unmapped
+            break
+        }
+        if (entry > 3n) {
+          this.#grainMap.set(grainIndex)
+          grainIndex++
+        }
+      }
+    }
+
+    // read grain directory and the grain tables
+    const nbBlocks = this.header.maxTableEntries
+    this.#grainDirectory = await this.#read(2048 /* header length */, 2048 + nbBlocks * 4 - 1)
+  }
+
+  // we're lucky : a grain address can address exacty a full block
+  async readBlock(blockId) {
+    notEqual(this.#grainDirectory, undefined, 'grainDirectory is not loaded')
+    const sectorOffset = this.#grainDirectory.readInt32LE(blockId * 4)
+
+    const buffer = (await this.#parentVhd.readBlock(blockId)).buffer
+
+    if (sectorOffset === 0) {
+      strictEqual(this.#lookMissingBlockInParent, true, "shouldn't have empty block in a delta alone")
+      return {
+        id: blockId,
+        bitmap: buffer.slice(0, 512),
+        data: buffer.slice(512),
+        buffer,
+      }
+    }
+    const offset = sectorOffset * 512
+
+    const graintable = await this.#read(offset, offset + 4096 * 4 /* grain table length */ - 1)
+
+    strictEqual(graintable.length, 4096 * 4)
+    // we have no guaranty that data are order or contiguous
+    // let's construct ranges to limit the number of queries
+    let rangeStart, offsetStart, offsetEnd
+
+    const changeRange = async (index, offset) => {
+      if (offsetStart !== undefined) {
+        // if there was a
+        if (offset === offsetEnd) {
+          offsetEnd++
+          return
+        }
+        const grains = await this.#read(offsetStart * 512, offsetEnd * 512 - 1)
+        grains.copy(buffer, (rangeStart + 1) /* block bitmap */ * 512)
+      }
+      if (offset) {
+        // we're at the beginning of a range present in the file
+        rangeStart = index
+        offsetStart = offset
+        offsetEnd = offset + 1
+      } else {
+        // we're at the beginning of a range from the parent or empty
+        rangeStart = undefined
+        offsetStart = undefined
+        offsetEnd = undefined
+      }
+    }
+
+    for (let i = 0; i < graintable.length / 4; i++) {
+      const grainOffset = graintable.readInt32LE(i * 4)
+      if (grainOffset === 0) {
+        await changeRange()
+        // from parent
         continue
       }
-      strictEqual(grainDirType, SE_SPARSE_DIR_ALLOCATED)
-      // read the corresponding grain table ( second level )
-      const grainTableBuffer = await this.#read(
-        this.#grainTableOffsetBytes + tableIndex * tableSizeBytes,
-        tableSizeBytes
-      )
-      // offset in bytes if >0, grainType if <=0
-      let grainOffsets = []
-      let blockId = grainDirIndex * 8
-
-      const addGrain = val => {
-        grainOffsets.push(val)
-        // 4096 block of 4Kb per dir entry =>16MB/grain dir
-        // 1 block = 2MB
-        // 512 grain => 1 block
-        // 8 block per dir entry
-        if (grainOffsets.length === 512) {
-          this.#grainIndex.set(blockId, grainOffsets)
-          grainOffsets = []
-          blockId++
-        }
+      if (grainOffset === 1) {
+        await changeRange()
+        // this is a emptied grain, no data, don't look into parent
+        buffer.fill(0, (i + 1) /* block bitmap */ * 512)
       }
 
-      for (let grainTableIndex = 0; grainTableIndex < grainTableBuffer.length / 8; grainTableIndex++) {
-        const { type: grainType, grainIndex } = readSeSparseTable(grainTableBuffer, grainTableIndex)
-        if (grainType === SE_SPARSE_GRAIN_ALLOCATED) {
-          // this is ok in 32 bits int with VMDK smaller than 2TB
-          const offsetByte = grainIndex * GRAIN_SIZE_BYTES + this.#grainOffsetBytes
-          addGrain(offsetByte)
-        } else {
-          // multiply by -1 to differenciate type and offset
-          // no offset can be zero
-          addGrain(-grainType)
-        }
-      }
-      strictEqual(grainOffsets.length, 0)
-    }
-  }
-
-  async readBlock(blockId) {
-    let changed = false
-    const parentBlock = await this.#parentVhd.readBlock(blockId)
-    const parentBuffer = parentBlock.buffer
-    const grainOffsets = this.#grainIndex.get(blockId) // may be undefined if the child contains block and lookMissingBlockInParent=true
-    const EMPTY_GRAIN = Buffer.alloc(GRAIN_SIZE_BYTES, 0)
-    for (const index in grainOffsets) {
-      const value = grainOffsets[index]
-      let data
-      if (value > 0) {
-        // it's the offset in byte of a grain type SE_SPARSE_GRAIN_ALLOCATED
-        data = await this.#read(value, GRAIN_SIZE_BYTES)
-      } else {
-        // back to the real grain type
-        const type = value * -1
-        switch (type) {
-          case SE_SPARSE_GRAIN_ZERO:
-          case SE_SPARSE_GRAIN_UNMAPPED:
-            data = EMPTY_GRAIN
-            break
-          case SE_SPARSE_GRAIN_NON_ALLOCATED:
-            /* from parent */
-            break
-          default:
-            throw new Error(`can't handle grain type ${type}`)
-        }
-      }
-      if (data) {
-        changed = true
-        data.copy(parentBuffer, index * GRAIN_SIZE_BYTES + 512 /* block bitmap */)
+      if (grainOffset > 1) {
+        // non empty grain
+        await changeRange(i, grainOffset)
       }
     }
-    // no need to copy if data all come from parent
-    return changed
-      ? {
-          id: blockId,
-          bitmap: parentBuffer.slice(0, 512),
-          data: parentBuffer.slice(512),
-          buffer: parentBuffer,
-        }
-      : parentBlock
+    await changeRange()
+    return {
+      id: blockId,
+      bitmap: buffer.slice(0, 512),
+      data: buffer.slice(512),
+      buffer,
+    }
   }
 }