@xen-orchestra/backups 0.68.2 → 0.69.1

package/disks/RemoteVhdDiskChain.mjs

@@ -0,0 +1,271 @@
+// @ts-check
+
+/**
+ * @typedef {import('./RemoteVhdDisk.mjs').VhdFooter} VhdFooter
+ * @typedef {import('./RemoteVhdDisk.mjs').RemoteVhdDisk} RemoteVhdDisk
+ * @typedef {import('@xen-orchestra/disk-transform').DiskBlock} DiskBlock
+ * @typedef {import('@xen-orchestra/disk-transform').FileAccessor} FileAccessor
+ */
+
+import { RemoteDisk } from './RemoteDisk.mjs'
+
+export class RemoteVhdDiskChain extends RemoteDisk {
+  /**
+   * @type {RemoteVhdDisk[]}
+   */
+  #disks
+
+  /**
+   * @type {number}
+   */
+  #blockSize = 2 * 1024 * 1024
+
+  /**
+   * @type {number}
+   */
+  #headerSize = 1024
+
+  /**
+   * @type {number}
+   */
+  #footerSize = 512
+
+  /**
+   * @type {number}
+   */
+  #bitmapSize = 512
+
+  /**
+   * @param {Object} params
+   * @param {FileAccessor} params.handler
+   * @param {RemoteVhdDisk[]} params.disks
+   */
+  constructor({ disks }) {
+    super()
+    this.#disks = disks
+  }
+
+  /**
+   * Initializes the VHD chain
+   * @param {Object} options
+   * @param {boolean} options.force
+   * @returns {Promise<void>}
+   */
+  async init(options) {
+    try {
+      await Promise.all(this.#disks.map(disk => disk.init(options)))
+      let parentUuid = ''
+      for (const [index, disk] of this.#disks.entries()) {
+        if (index !== 0) {
+          if (!disk.isDifferencing()) {
+            throw Object.assign(new Error("Can't init vhd directory with non differencing child disks"), {
+              code: 'NOT_SUPPORTED',
+            })
+          }
+          if (disk.getParentUuid() !== parentUuid) {
+            throw Object.assign(new Error("Can't init vhd directory with incorrect parentage"), {
+              code: 'NOT_SUPPORTED',
+            })
+          }
+        }
+
+        parentUuid = disk.getUuid()
+      }
+    } catch (error) {
+      await this.close()
+      throw error
+    }
+  }
+
+  /**
+   * Closes the VHD.
+   * @returns {Promise<void>}
+   */
+  async close() {
+    await Promise.all(this.#disks.map(disk => disk.close()))
+  }
+
+  /**
+   * @returns {number}
+   */
+  getVirtualSize() {
+    return this.#disks[this.#disks.length - 1].getVirtualSize()
+  }
+
+  /**
+   * @returns {number} size
+   */
+  getSizeOnDisk() {
+    const batEntrySize = 4
+    const sectorSize = 512
+    const batSize = Math.ceil((this.getMaxBlockCount() * batEntrySize) / sectorSize) * sectorSize
+
+    return (
+      this.#footerSize +
+      this.#headerSize +
+      batSize +
+      this.getBlockIndexes().length * (this.#blockSize + this.#bitmapSize) +
+      this.#footerSize
+    )
+  }
+
+  /**
+   * @returns {number}
+   */
+  getBlockSize() {
+    return this.#disks[this.#disks.length - 1].getBlockSize()
+  }
+
+  /**
+   * @returns {string}
+   */
+  getPath() {
+    return this.#disks[this.#disks.length - 1].getPath()
+  }
+
+  /**
+   * @returns {string}
+   */
+  getUuid() {
+    return this.#disks[this.#disks.length - 1].getUuid()
+  }
+
+  /**
+   * @returns {Promise<boolean>} canMergeConcurently
+   */
+  async canMergeConcurently() {
+    for (const disk of this.#disks) {
+      if (!(await disk.isDirectory())) {
+        return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * @returns {number} getMaxBlockCount
+   */
+  getMaxBlockCount() {
+    return this.#disks[this.#disks.length - 1].getMaxBlockCount()
+  }
+
+  /**
+   * Checks if the VHD contains a specific block.
+   * @param {number} index
+   * @returns {boolean}
+   */
+  hasBlock(index) {
+    for (const disk of this.#disks) {
+      if (disk.hasBlock(index)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Gets the indexes of all blocks in the VHD.
+   * @returns {Array<number>}
+   */
+  getBlockIndexes() {
+    const indexes = new Set()
+    for (const disk of this.#disks) {
+      for (const index of disk.getBlockIndexes()) {
+        indexes.add(index)
+      }
+    }
+    return [...indexes]
+  }
+
+  /**
+   * Returns the parent non inizialized instance
+   * @returns {RemoteDisk}
+   */
+  instantiateParent() {
+    return this.#disks[0].instantiateParent()
+  }
+
+  /**
+   * Writes a full block into this VHD.
+   * @param {DiskBlock} diskBlock
+   * @return {Promise<number>} blockSize
+   */
+  async writeBlock(diskBlock) {
+    throw new Error(`Can't write blocks into a disk chain`)
+  }
+
+  /**
+   * Reads a specific block from the VHD.
+   * @param {number} index
+   * @returns {Promise<DiskBlock>} diskBlock
+   */
+  async readBlock(index) {
+    const reversedDisks = this.#disks.slice().reverse()
+    for (const disk of reversedDisks) {
+      if (disk.hasBlock(index)) {
+        return disk.readBlock(index)
+      }
+    }
+    throw new Error(`Block ${index} not found in chain `)
+  }
+
+  /**
+   * Reads a specific block from the child disk to copy/move it to this disk.
+   * @param {RemoteDisk} childDisk
+   * @param {number} index
+   * @param {boolean} isResumingMerge
+   * @returns {Promise<number>} blockSize
+   */
+  async mergeBlock(childDisk, index, isResumingMerge) {
+    throw new Error(`Can't merge block into a disk chain`)
+  }
+
+  /**
+   * @returns {VhdFooter}
+   */
+  getMetadata() {
+    return this.#disks[this.#disks.length - 1].getMetadata()
+  }
+
+  /**
+   * @param {RemoteVhdDisk} childDisk
+   * @returns {Promise<void>}
+   */
+  async flushMetadata(childDisk) {
+    throw new Error(`Can't flush metadata on a disk chain`)
+  }
+
+  /**
+   * @param {RemoteVhdDisk} childDisk
+   */
+  mergeMetadata(childDisk) {
+    throw new Error(`Can't merge metadata on a disk chain`)
+  }
+
+  /**
+   * Checks if the VHD is a differencing disk.
+   * @returns {boolean}
+   */
+  isDifferencing() {
+    return this.#disks[0].isDifferencing()
+  }
+
+  /**
+   * Abstract
+   * Rename alias/disk
+   * @param {string} newPath
+   */
+  async rename(newPath) {
+    throw new Error(`Can't rename a disk chain`)
+  }
+
+  /**
+   * Deletes all the disks
+   */
+  async unlink() {
+    for (const disk of this.#disks) {
+      await disk.unlink()
+    }
+  }
+}

package/disks/openDiskChain.mjs

@@ -2,12 +2,14 @@
 /**
  *
  * @typedef {import('../../disk-transform/src/FileAccessor.mjs').FileAccessor} FileAccessor
+ * @typedef {import('./RemoteDisk.mjs').RemoteDisk} RemoteDisk
  */
 import { DiskChain } from '@xen-orchestra/disk-transform'
-import { RemoteVhd } from './RemoteVhd.mjs'
+import { RemoteVhdDisk } from './RemoteVhdDisk.mjs'
 
 import { defer } from 'golike-defer'
 /**
+ * @param {any} $defer
  * @param {Object} params
  * @param {FileAccessor} params.handler
  * @param {string} params.path
@@ -15,15 +17,18 @@ import { defer } from 'golike-defer'
  */
 async function _openDiskChain($defer, { handler, path, until }) {
   let disk
+  /**
+   * @type {Array<RemoteDisk>}
+   */
   const disks = []
   $defer.onFailure(() => Promise.all(disks.map(disk => disk.close())))
-  disk = new RemoteVhd({ handler, path })
+  disk = new RemoteVhdDisk({ handler, path })
 
   await disk.init()
   disks.push(disk)
   while (disk.isDifferencing()) {
     disk = await disk.openParent()
-    if (disk.path === until) {
+    if (disk.getPath() === until) {
       break
     }
     disks.unshift(disk)

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.68.2",
+  "version": "0.69.1",
   "engines": {
     "node": ">=14.18"
   },
@@ -30,7 +30,7 @@
     "@vates/parse-duration": "^0.1.1",
     "@xen-orchestra/async-map": "^0.1.2",
     "@xen-orchestra/disk-transform": "^1.2.1",
-    "@xen-orchestra/fs": "^4.6.6",
+    "@xen-orchestra/fs": "^4.6.7",
     "@xen-orchestra/log": "^0.7.1",
     "@xen-orchestra/qcow2": "^1.1.2",
     "@xen-orchestra/template": "^0.1.0",

package/disks/RemoteVhd.mjs

@@ -1,171 +0,0 @@
-// @ts-check
-
-/**
- * @typedef {import('@xen-orchestra/disk-transform').FileAccessor} FileAccessor
- * @typedef {import('@xen-orchestra/disk-transform').DiskBlock} DiskBlock
- * @typedef {import('@xen-orchestra/disk-transform').Disk} Disk
- * @typedef {import('vhd-lib/Vhd/VhdDirectory.js').VhdDirectory} VhdDirectory
- * @typedef {import('vhd-lib/Vhd/VhdFile.js').VhdFile} VhdFile
- */
-
-import { openVhd } from 'vhd-lib'
-import { DISK_TYPES } from 'vhd-lib/_constants.js'
-import { dirname, join } from 'node:path'
-import { RandomAccessDisk } from '@xen-orchestra/disk-transform'
-/**
- * Represents a remote VHD (Virtual Hard Disk) that extends RandomAccessDisk.
- */
-export class RemoteVhd extends RandomAccessDisk {
-  /**
-   * @type {string}
-   */
-  #path
-
-  /**
-   * @type {FileAccessor}
-   */
-  #handler
-
-  /**
-   * @type {VhdFile | VhdDirectory | undefined}
-   */
-  #vhd
-
-  /**
-   * @type {boolean | undefined}
-   */
-  #isDifferencing
-
-  /**
-   * @type {() => any}
-   */
-  #dispose = () => {}
-
-  /**
-   * @returns {string}
-   */
-  get path() {
-    return this.#path
-  }
-
-  /**
-   * @param {Object} params
-   * @param {FileAccessor} params.handler
-   * @param {string} params.path
-   */
-  constructor({ handler, path }) {
-    super()
-    // @todo : ensure this is the full path from the root of the remote
-    this.#path = path
-    this.#handler = handler
-  }
-
-  /**
-   * @returns {number}
-   */
-  getVirtualSize() {
-    if (this.#vhd === undefined) {
-      throw new Error(`can't call getvirtualsize of a RemoteVhd before init`)
-    }
-    return this.#vhd.footer.currentSize
-  }
-
-  /**
-   * @returns {number}
-   */
-  getBlockSize() {
-    return 2 * 1024 * 1024
-  }
-
-  /**
-   * Initializes the VHD.
-   * @returns {Promise<void>}
-   */
-  async init() {
-    const { value, dispose } = await openVhd(this.#handler, this.#path)
-    this.#vhd = value
-    this.#dispose = dispose
-    await this.#vhd.readBlockAllocationTable()
-    this.#isDifferencing = value.footer.diskType === DISK_TYPES.DIFFERENCING
-  }
-
-  /**
-   * Closes the VHD.
-   * @returns {Promise<void>}
-   */
-  async close() {
-    await this.#dispose()
-  }
-
-  /**
-   * Checks if the VHD contains a specific block.
-   * @param {number} index
-   * @returns {boolean}
-   */
-  hasBlock(index) {
-    if (this.#vhd === undefined) {
-      throw new Error(`can't call hasblock of a RemoteVhd before init`)
-    }
-    return this.#vhd.containsBlock(index)
-  }
-
-  /**
-   * Gets the indexes of all blocks in the VHD.
-   * @returns {Array<number>}
-   */
-  getBlockIndexes() {
-    if (this.#vhd === undefined) {
-      throw new Error(`can't call getBlockIndexes of a RemoteVhd before init`)
-    }
-    const index = []
-    for (let blockIndex = 0; blockIndex < this.#vhd.header.maxTableEntries; blockIndex++) {
-      if (this.hasBlock(blockIndex)) {
-        index.push(blockIndex)
-      }
-    }
-    return index
-  }
-
-  /**
-   * Reads a specific block from the VHD.
-   * @param {number} index
-   * @returns {Promise<DiskBlock>}
-   */
-  async readBlock(index) {
-    if (this.#vhd === undefined) {
-      throw new Error(`can't call readBlock of a RemoteVhd before init`)
-    }
-    const { data } = await this.#vhd.readBlock(index)
-    return {
-      index,
-      data,
-    }
-  }
-  /**
-   *
-   * @returns {RandomAccessDisk}
-   */
-  instantiateParent() {
-    if (this.#vhd === undefined) {
-      throw new Error(`can't call openParent of a RemoteVhd before init`)
-    }
-    const parentPath = this.#vhd.header.parentUnicodeName
-    const fullParentPath = join(dirname(this.#path), parentPath)
-    if (!parentPath) {
-      throw new Error(`Disk ${this.#path} doesn't have parents`)
-    }
-    const parent = new RemoteVhd({ handler: this.#handler, path: fullParentPath })
-    return parent
-  }
-
-  /**
-   * Checks if the VHD is a differencing disk.
-   * @returns {boolean}
-   */
-  isDifferencing() {
-    if (this.#isDifferencing === undefined) {
-      throw new Error(`can't call isDifferencing of a RemoteVhd before init`)
-    }
-    return this.#isDifferencing
-  }
-}