@xen-orchestra/backups 0.14.0

package/writers/FullReplicationWriter.js

@@ -0,0 +1,88 @@
+const ignoreErrors = require('promise-toolbox/ignoreErrors.js')
+const { asyncMap, asyncMapSettled } = require('@xen-orchestra/async-map')
+const { formatDateTime } = require('@xen-orchestra/xapi')
+
+const { formatFilenameDate } = require('../_filenameDate.js')
+const { getOldEntries } = require('../_getOldEntries.js')
+const { Task } = require('../Task.js')
+
+const { AbstractFullWriter } = require('./_AbstractFullWriter.js')
+const { MixinReplicationWriter } = require('./_MixinReplicationWriter.js')
+const { listReplicatedVms } = require('./_listReplicatedVms.js')
+
+exports.FullReplicationWriter = class FullReplicationWriter extends MixinReplicationWriter(AbstractFullWriter) {
+  constructor(props) {
+    super(props)
+
+    this.run = Task.wrapFn(
+      {
+        name: 'export',
+        data: {
+          id: props.sr.uuid,
+          type: 'SR',
+
+          // necessary?
+          isFull: true,
+        },
+      },
+      this.run
+    )
+  }
+
+  async _run({ timestamp, sizeContainer, stream }) {
+    const sr = this._sr
+    const settings = this._settings
+    const { job, scheduleId, vm } = this._backup
+
+    const { uuid: srUuid, $xapi: xapi } = sr
+
+    // delete previous interrupted copies
+    ignoreErrors.call(
+      asyncMapSettled(listReplicatedVms(xapi, scheduleId, undefined, vm.uuid), vm => xapi.VM_destroy(vm.$ref))
+    )
+
+    const oldVms = getOldEntries(settings.copyRetention - 1, listReplicatedVms(xapi, scheduleId, srUuid, vm.uuid))
+
+    const deleteOldBackups = () => asyncMapSettled(oldVms, vm => xapi.VM_destroy(vm.$ref))
+    const { deleteFirst } = settings
+    if (deleteFirst) {
+      await deleteOldBackups()
+    }
+
+    let targetVmRef
+    await Task.run({ name: 'transfer' }, async () => {
+      targetVmRef = await xapi.VM_import(stream, sr.$ref, vm =>
+        Promise.all([
+          vm.add_tags('Disaster Recovery'),
+          vm.ha_restart_priority !== '' && Promise.all([vm.set_ha_restart_priority(''), vm.add_tags('HA disabled')]),
+          vm.set_name_label(`${vm.name_label} - ${job.name} - (${formatFilenameDate(timestamp)})`),
+        ])
+      )
+      return { size: sizeContainer.size }
+    })
+
+    const targetVm = await xapi.getRecord('VM', targetVmRef)
+
+    await Promise.all([
+      asyncMap(['start', 'start_on'], op =>
+        targetVm.update_blocked_operations(
+          op,
+          'Start operation for this vm is blocked, clone it if you want to use it.'
+        )
+      ),
+      targetVm.update_other_config({
+        'xo:backup:sr': srUuid,
+
+        // these entries need to be added in case of offline backup
+        'xo:backup:datetime': formatDateTime(timestamp),
+        'xo:backup:job': job.id,
+        'xo:backup:schedule': scheduleId,
+        'xo:backup:vm': vm.uuid,
+      }),
+    ])
+
+    if (!deleteFirst) {
+      await deleteOldBackups()
+    }
+  }
+}

package/writers/_AbstractDeltaWriter.js

@@ -0,0 +1,26 @@
+const { AbstractWriter } = require('./_AbstractWriter.js')
+
+exports.AbstractDeltaWriter = class AbstractDeltaWriter extends AbstractWriter {
+  checkBaseVdis(baseUuidToSrcVdi, baseVm) {
+    throw new Error('Not implemented')
+  }
+
+  cleanup() {
+    throw new Error('Not implemented')
+  }
+
+  prepare({ isFull }) {
+    throw new Error('Not implemented')
+  }
+
+  async transfer({ timestamp, deltaExport, sizeContainers }) {
+    try {
+      return await this._transfer({ timestamp, deltaExport, sizeContainers })
+    } finally {
+      // ensure all streams are properly closed
+      for (const stream of Object.values(deltaExport.streams)) {
+        stream.destroy()
+      }
+    }
+  }
+}

package/writers/_AbstractFullWriter.js

@@ -0,0 +1,12 @@
+const { AbstractWriter } = require('./_AbstractWriter.js')
+
+exports.AbstractFullWriter = class AbstractFullWriter extends AbstractWriter {
+  async run({ timestamp, sizeContainer, stream }) {
+    try {
+      return await this._run({ timestamp, sizeContainer, stream })
+    } finally {
+      // ensure stream is properly closed
+      stream.destroy()
+    }
+  }
+}

package/writers/_AbstractWriter.js

@@ -0,0 +1,10 @@
+exports.AbstractWriter = class AbstractWriter {
+  constructor({ backup, settings }) {
+    this._backup = backup
+    this._settings = settings
+  }
+
+  beforeBackup() {}
+
+  afterBackup() {}
+}

package/writers/_MixinBackupWriter.js

@@ -0,0 +1,51 @@
+const { createLogger } = require('@xen-orchestra/log')
+const { join } = require('path')
+
+const { BACKUP_DIR, getVmBackupDir } = require('../_getVmBackupDir.js')
+const MergeWorker = require('../merge-worker/index.js')
+const { formatFilenameDate } = require('../_filenameDate.js')
+
+const { warn } = createLogger('xo:backups:MixinBackupWriter')
+
+exports.MixinBackupWriter = (BaseClass = Object) =>
+  class MixinBackupWriter extends BaseClass {
+    #lock
+    #vmBackupDir
+
+    constructor({ remoteId, ...rest }) {
+      super(rest)
+
+      this._adapter = rest.backup.remoteAdapters[remoteId]
+      this._remoteId = remoteId
+
+      this.#vmBackupDir = getVmBackupDir(this._backup.vm.uuid)
+    }
+
+    _cleanVm(options) {
+      return this._adapter
+        .cleanVm(this.#vmBackupDir, { ...options, fixMetadata: true, onLog: warn, lock: false })
+        .catch(warn)
+    }
+
+    async beforeBackup() {
+      const { handler } = this._adapter
+      const vmBackupDir = this.#vmBackupDir
+      await handler.mktree(vmBackupDir)
+      this.#lock = await handler.lock(vmBackupDir)
+    }
+
+    async afterBackup() {
+      const { disableMergeWorker } = this._backup.config
+
+      const { merge } = await this._cleanVm({ remove: true, merge: disableMergeWorker })
+      await this.#lock.dispose()
+
+      // merge worker only compatible with local remotes
+      const { handler } = this._adapter
+      if (merge && !disableMergeWorker && typeof handler._getRealPath === 'function') {
+        await handler.outputFile(join(MergeWorker.CLEAN_VM_QUEUE, formatFilenameDate(new Date())), this._backup.vm.uuid)
+        const remotePath = handler._getRealPath()
+        await MergeWorker.run(remotePath)
+      }
+    }
+  }

package/writers/_MixinReplicationWriter.js

@@ -0,0 +1,8 @@
+exports.MixinReplicationWriter = (BaseClass = Object) =>
+  class MixinReplicationWriter extends BaseClass {
+    constructor({ sr, ...rest }) {
+      super(rest)
+
+      this._sr = sr
+    }
+  }

package/writers/_checkVhd.js

@@ -0,0 +1,5 @@
+const Vhd = require('vhd-lib').default
+
+exports.checkVhd = async function checkVhd(handler, path) {
+  await new Vhd(handler, path).readHeaderAndFooter()
+}

package/writers/_listReplicatedVms.js

@@ -0,0 +1,30 @@
+const getReplicatedVmDatetime = vm => {
+  const { 'xo:backup:datetime': datetime = vm.name_label.slice(-17, -1) } = vm.other_config
+  return datetime
+}
+
+const compareReplicatedVmDatetime = (a, b) => (getReplicatedVmDatetime(a) < getReplicatedVmDatetime(b) ? -1 : 1)
+
+exports.listReplicatedVms = function listReplicatedVms(xapi, scheduleOrJobId, srUuid, vmUuid) {
+  const { all } = xapi.objects
+  const vms = {}
+  for (const key in all) {
+    const object = all[key]
+    const oc = object.other_config
+    if (
+      object.$type === 'VM' &&
+      !object.is_a_snapshot &&
+      !object.is_a_template &&
+      'start' in object.blocked_operations &&
+      (oc['xo:backup:job'] === scheduleOrJobId || oc['xo:backup:schedule'] === scheduleOrJobId) &&
+      oc['xo:backup:sr'] === srUuid &&
+      (oc['xo:backup:vm'] === vmUuid ||
+        // 2018-03-28, JFT: to catch VMs replicated before this fix
+        oc['xo:backup:vm'] === undefined)
+    ) {
+      vms[object.$id] = object
+    }
+  }
+
+  return Object.values(vms).sort(compareReplicatedVmDatetime)
+}

package/writers/_packUuid.js

@@ -0,0 +1,5 @@
+const PARSE_UUID_RE = /-/g
+
+exports.packUuid = function packUuid(uuid) {
+  return Buffer.from(uuid.replace(PARSE_UUID_RE, ''), 'hex')
+}