@xen-orchestra/backups 0.68.1 → 0.69.0

package/disks/RemoteDisk.mjs

@@ -0,0 +1,204 @@
+// @ts-check
+
+/**
+ * @typedef {import('@xen-orchestra/disk-transform').DiskBlock} DiskBlock
+ */
+
+import { RandomAccessDisk } from '@xen-orchestra/disk-transform'
+export class RemoteDisk extends RandomAccessDisk {
+  /**
+   * Abstract
+   * @param {Object} options
+   * @param {boolean} options.force
+   * @returns {Promise<void>}
+   */
+  async init(options = { force: false }) {
+    throw new Error(`init must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @returns {Promise<void>}
+   */
+  async close() {
+    throw new Error(`close must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @returns {number}
+   */
+  getVirtualSize() {
+    throw new Error(`getVirtualSize must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @returns {number} size
+   */
+  getSizeOnDisk() {
+    throw new Error(`getSizeOnDisk must be implemented`)
+  }
+
+  /**
+   * @returns {number}
+   */
+  getBlockSize() {
+    throw new Error(`getBlockSize must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @returns {string}
+   */
+  getPath() {
+    throw new Error(`getPath must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @returns {string}
+   */
+  getUuid() {
+    throw new Error(`getUuid must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @returns {Promise<boolean>} canMergeConcurently
+   */
+  async canMergeConcurently() {
+    throw new Error(`canMergeConcurently must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @returns {number} getMaxBlockCount
+   */
+  getMaxBlockCount() {
+    throw new Error(`getMaxBlockCount must be implemented`)
+  }
+
+  /**
+   * Checks if the VHD contains a specific block.
+   * @param {number} index
+   * @returns {boolean}
+   */
+  hasBlock(index) {
+    throw new Error(`hasBlock must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Gets the indexes of all blocks in the VHD.
+   * @returns {Array<number>}
+   */
+  getBlockIndexes() {
+    throw new Error(`getBlockIndexes must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Returns the parent non inizialized instance
+   * @returns {RemoteDisk}
+   */
+  instantiateParent() {
+    throw new Error(`instantiateParent must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Writes a full block.
+   * @param {DiskBlock} diskBlock
+   * @return {Promise<number>} blockSize
+   */
+  async writeBlock(diskBlock) {
+    throw new Error(`writeBlock must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Reads a specific block from the VHD.
+   * @param {number} index
+   * @returns {Promise<DiskBlock>} diskBlock
+   */
+  async readBlock(index) {
+    throw new Error(`readBlock must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * 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(`mergeBlock must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Manually set the disk allocated blocks.
+   * @param {Array<number>} blockIds
+   * @returns {Promise<void>}
+   */
+  async setAllocatedBlocks(blockIds) {
+    throw new Error(`setAllocatedBlocks must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @param {RemoteDisk} childDisk
+   * @returns {Promise<void>}
+   */
+  async flushMetadata(childDisk) {
+    throw new Error(`flushMetadata must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * @param {RemoteDisk} childDisk
+   */
+  mergeMetadata(childDisk) {
+    throw new Error(`mergeMetadata must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Checks if the VHD is a differencing disk.
+   * @returns {boolean}
+   */
+  isDifferencing() {
+    throw new Error(`isDifferencing must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Rename alias/disk
+   * @param {string} newPath
+   */
+  async rename(newPath) {
+    throw new Error(`rename must be implemented`)
+  }
+
+  /**
+   * Abstract
+   * Deletes alias/disk/disks
+   */
+  async unlink() {
+    throw new Error(`unlink must be implemented`)
+  }
+
+  /**
+   * @returns  {Promise<RemoteDisk>}
+   */
+  async openParent() {
+    const parent = await super.openParent()
+    if (!(parent instanceof RemoteDisk)) {
+      throw new Error('parent of a RemoteDisk must be also a RemoteDisk')
+    }
+    return parent
+  }
+}

package/disks/RemoteVhdDisk.mjs

@@ -0,0 +1,458 @@
+// @ts-check
+
+/**
+ * @typedef {import('vhd-lib/Vhd/VhdDirectory.js').VhdDirectory} VhdDirectory
+ * @typedef {import('vhd-lib/Vhd/VhdFile.js').VhdFile} VhdFile
+ * @typedef {import('vhd-lib/_createFooterHeader').VhdFooter} VhdFooter
+ * @typedef {import('@xen-orchestra/disk-transform').DiskBlock} DiskBlock
+ * @typedef {import('@xen-orchestra/disk-transform').FileAccessor} FileAccessor
+ *
+
+ */
+
+import { openVhd, VhdAbstract, VhdDirectory } from 'vhd-lib'
+import { RemoteDisk } from './RemoteDisk.mjs'
+import { DISK_TYPES } from 'vhd-lib/_constants.js'
+import { isVhdAlias, resolveVhdAlias } from 'vhd-lib/aliases.js'
+import { stringify } from 'uuid'
+import { dirname, join } from 'node:path'
+
+export class RemoteVhdDisk extends RemoteDisk {
+  /**
+   * @type {string}
+   */
+  #path
+
+  /**
+   * @type {FileAccessor}
+   */
+  #handler
+
+  /**
+   * @type {VhdFile | VhdDirectory | undefined}
+   */
+  #vhd
+
+  /**
+   * @type {boolean | undefined}
+   */
+  #isDifferencing
+
+  /**
+   * @type {number}
+   */
+  #blockSize = 2 * 1024 * 1024
+
+  /**
+   * @type {number}
+   */
+  #bitmapSize = 512
+
+  /**
+   * @type {() => any}
+   */
+  #dispose = () => {}
+
+  /**
+   * @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
+  }
+
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.force=false]
+   * @returns {Promise<void>}
+   */
+  async init(options = {}) {
+    if (this.#vhd === undefined) {
+      try {
+        const { value, dispose } = await openVhd(this.#handler, await resolveVhdAlias(this.#handler, this.#path), {
+          checkSecondFooter: !options.force,
+        })
+        this.#vhd = value
+
+        if ((await this.isDirectory()) && !isVhdAlias(this.#path)) {
+          this.#vhd = undefined
+          throw Object.assign(new Error("Can't init vhd directory without using alias"), { code: 'NOT_SUPPORTED' })
+        }
+
+        this.#dispose = dispose
+        await this.#vhd.readBlockAllocationTable()
+        this.#isDifferencing = value.footer.diskType === DISK_TYPES.DIFFERENCING
+      } catch (error) {
+        await this.close()
+        throw error
+      }
+    }
+  }
+
+  /**
+   * Closes the VHD.
+   * @returns {Promise<void>}
+   */
+  async close() {
+    await this.#dispose()
+  }
+
+  /**
+   * @returns {number}
+   */
+  getVirtualSize() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call getVirtualSize of a RemoteVhdDisk before init`)
+    }
+    return this.#vhd.footer.currentSize
+  }
+
+  /**
+   * @returns {number} size
+   */
+  getSizeOnDisk() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call getVirtualSize of a RemoteVhdDisk before init`)
+    }
+
+    return this.#vhd.streamSize()
+  }
+
+  /**
+   * @returns {number}
+   */
+  getBlockSize() {
+    return this.#blockSize
+  }
+
+  /**
+   * @returns {string}
+   */
+  getPath() {
+    return this.#path
+  }
+
+  /**
+   * @returns {string}
+   */
+  getUuid() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call getUid of a RemoteVhdDisk before init`)
+    }
+
+    return stringify(this.#vhd.footer.uuid)
+  }
+
+  /**
+   * @returns {string}
+   */
+  getParentUuid() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call getParentUid of a RemoteVhdDisk before init`)
+    }
+
+    return stringify(this.#vhd.header.parentUuid)
+  }
+
+  /**
+   * @returns {Promise<boolean>} canMergeConcurently
+   */
+  async canMergeConcurently() {
+    return await this.isDirectory()
+  }
+
+  /**
+   * @returns {number} getMaxBlockCount
+   */
+  getMaxBlockCount() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call getMaxBlockCount of a RemoteVhdDisk before init`)
+    }
+
+    return this.#vhd.header.maxTableEntries
+  }
+
+  /**
+   * 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 RemoteVhdDisk 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 RemoteVhdDisk before init`)
+    }
+    const indexes = []
+    for (let blockIndex = 0; blockIndex < this.#vhd.header.maxTableEntries; blockIndex++) {
+      if (this.hasBlock(blockIndex)) {
+        indexes.push(blockIndex)
+      }
+    }
+    return indexes
+  }
+
+  /**
+   * Returns the parent non inizialized instance
+   * @returns {RemoteDisk}
+   */
+  instantiateParent() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call instantiateParent of a RemoteVhdDisk 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 RemoteVhdDisk({ handler: this.#handler, path: fullParentPath })
+    return parent
+  }
+
+  /**
+   * Writes a full block into this VHD.
+   * @param {DiskBlock} diskBlock
+   * @return {Promise<number>} blockSize
+   */
+  async writeBlock(diskBlock) {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call readBlock of a RemoteVhdDisk before init`)
+    }
+    await this.#vhd.writeEntireBlock({
+      id: diskBlock.index,
+      buffer: Buffer.concat([Buffer.alloc(this.#bitmapSize, 255), diskBlock.data]),
+    })
+
+    return this.getBlockSize()
+  }
+
+  /**
+   * Reads a specific block from the VHD.
+   * @param {number} index
+   * @returns {Promise<DiskBlock>} diskBlock
+   */
+  async readBlock(index) {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call readBlock of a RemoteVhdDisk before init`)
+    }
+    const { data } = await this.#vhd.readBlock(index)
+    return {
+      index,
+      data,
+    }
+  }
+
+  /**
+   * 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) {
+    if ((await this.isDirectory()) && childDisk instanceof RemoteVhdDisk && (await childDisk.isDirectory())) {
+      try {
+        await this.#handler.rename(childDisk.getBlockPath(index), this.getBlockPath(index))
+
+        this.setAllocatedBlocks([index])
+      } catch (error) {
+        // @ts-ignore
+        if (error.code === 'ENOENT' && isResumingMerge === true) {
+          // when resuming, the blocks moved since the last merge state write are
+          // not in the child anymore but it should be ok
+
+          // it will throw an error if block is missing in parent
+          // won't detect if the block was already in parent and is broken/missing in child
+
+          // since we can't know the initial size, this will create a discrepancy
+          // on the size
+          const { data } = await this.readBlock(index)
+          if (data.length !== this.getBlockSize()) {
+            throw error
+          } else {
+            this.setAllocatedBlocks([index])
+          }
+        } else {
+          throw error
+        }
+      }
+
+      return this.getBlockSize()
+    } else {
+      return this.writeBlock(await childDisk.readBlock(index))
+    }
+  }
+
+  /**
+   * Gets a specific block path from the VHD directory.
+   * @param {number} index
+   * @returns {string} blockPath
+   */
+  getBlockPath(index) {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call readBlock of a RemoteVhdDisk before init`)
+    }
+
+    if (this.#vhd instanceof VhdDirectory) {
+      return this.#vhd.getFullBlockPath(index)
+    } else {
+      throw new Error(`can't call getBlockPath of non directory VHD`)
+    }
+  }
+
+  /**
+   * Manually set the disk allocated blocks.
+   * @param {Array<number>} blockIds
+   * @returns {Promise<void>}
+   */
+  async setAllocatedBlocks(blockIds) {
+    if (this.#vhd instanceof VhdDirectory) {
+      this.#vhd.setAllocatedBlocks(blockIds)
+    }
+  }
+
+  /**
+   * Writes Block Allocation Table
+   * @param {RemoteDisk} childDisk
+   * @returns {Promise<void>}
+   */
+  async flushMetadata(childDisk) {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call flushMetadata of a RemoteVhdDisk before init`)
+    }
+
+    await this.#vhd.writeBlockAllocationTable()
+  }
+
+  /**
+   * @returns {VhdFooter}
+   */
+  getMetadata() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call getMetadata of a RemoteVhdDisk before init`)
+    }
+
+    return this.#vhd.footer
+  }
+
+  /**
+   * @param {RemoteVhdDisk} childDisk
+   */
+  async mergeMetadata(childDisk) {
+    const childDiskMetadata = childDisk.getMetadata()
+
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call mergeMetadata of a RemoteVhdDisk before init`)
+    }
+
+    // @ts-ignore
+    this.#vhd.footer.currentSize = childDiskMetadata.currentSize
+    // @ts-ignore
+    this.#vhd.footer.diskGeometry = { ...childDiskMetadata.diskGeometry }
+    // @ts-ignore
+    this.#vhd.footer.originalSize = childDiskMetadata.originalSize
+    // @ts-ignore
+    this.#vhd.footer.timestamp = childDiskMetadata.timestamp
+    // @ts-ignore
+    this.#vhd.footer.uuid = childDiskMetadata.uuid
+
+    await this.#vhd.writeFooter()
+  }
+
+  /**
+   * Checks if the VHD is a differencing disk.
+   * @returns {boolean}
+   */
+  isDifferencing() {
+    if (this.#isDifferencing === undefined) {
+      throw new Error(`can't call isDifferencing of a RemoteVhdDisk before init`)
+    }
+    return this.#isDifferencing
+  }
+
+  /**
+   * Rename alias/disk
+   * @param {string} newPath
+   */
+  async rename(newPath) {
+    if (isVhdAlias(newPath)) {
+      const dataPath = await resolveVhdAlias(this.#handler, this.#path)
+
+      await this.#handler.unlink(this.#path)
+      await this.#handler.unlink(newPath)
+
+      await VhdAbstract.createAlias(this.#handler, newPath, dataPath)
+
+      this.#path = newPath
+    } else {
+      try {
+        await this.#handler.unlink(newPath)
+      } catch (err) {
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'EISDIR') {
+          await this.#handler.rmtree(newPath).catch(() => {})
+        }
+      }
+
+      await this.#handler.rename(this.#path, newPath)
+
+      this.#path = newPath
+    }
+  }
+
+  /**
+   * Deletes disk
+   */
+  async unlink() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call unlink of a RemoteVhdDisk before init`)
+    }
+
+    await this.close()
+
+    if (isVhdAlias(this.#path)) {
+      try {
+        await this.#handler.unlink(await resolveVhdAlias(this.#handler, this.#path))
+      } catch (err) {
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'EISDIR') {
+          await this.#handler.rmtree(await resolveVhdAlias(this.#handler, this.#path)).catch(() => {})
+        }
+      }
+    }
+
+    try {
+      await this.#handler.unlink(this.#path)
+    } catch (err) {
+      if (err && typeof err === 'object' && 'code' in err && err.code === 'EISDIR') {
+        await this.#handler.rmtree(this.#path).catch(() => {})
+      }
+    }
+  }
+
+  /**
+   * Check if the disk is a VHD directory.
+   * @returns {Promise<boolean>}
+   */
+  async isDirectory() {
+    if (this.#vhd === undefined) {
+      throw new Error(`can't call isDirectory of a RemoteVhdDisk before init`)
+    }
+
+    return this.#vhd instanceof VhdDirectory
+  }
+}