mirror of
https://github.com/vatesfr/xen-orchestra.git
synced 2026-11-17 04:21:15 -06:00
Compare commits
6 Commits
fix_proxy_
...
pbt_diskal
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9c13ec98b3 | ||
|
|
c19acbeb74 | ||
|
|
b2a6f26eb2 | ||
|
|
38fec907c1 | ||
|
|
8f761a2398 | ||
|
|
3b2ab4fd92 |
16
.eslintrc.js
16
.eslintrc.js
@@ -85,21 +85,6 @@ module.exports = {
|
||||
XO_LITE_GIT_HEAD: true,
|
||||
},
|
||||
rules: {
|
||||
'import/extensions': [
|
||||
'error',
|
||||
'ignorePackages',
|
||||
{
|
||||
pattern: { ts: 'always', vue: 'always' },
|
||||
checkTypeImports: true,
|
||||
// '@core/*' and '@/*' look like scoped packages to the plugin, which 'ignorePackages' would skip
|
||||
pathGroupOverrides: [
|
||||
{ pattern: '@core/packages/*', action: 'ignore' }, // barrel files
|
||||
{ pattern: '@core/icons', action: 'ignore' },
|
||||
{ pattern: '@core/**', action: 'enforce' },
|
||||
{ pattern: '@/**', action: 'enforce' },
|
||||
],
|
||||
},
|
||||
],
|
||||
'import/order': [
|
||||
'error',
|
||||
{
|
||||
@@ -269,7 +254,6 @@ module.exports = {
|
||||
'zh-Hans',
|
||||
'sk',
|
||||
'pt',
|
||||
'ar',
|
||||
],
|
||||
},
|
||||
],
|
||||
|
||||
@@ -5,7 +5,3 @@
|
||||
# Generated files
|
||||
/@xen-orchestra/web/src/route-map.d.ts
|
||||
/@xen-orchestra/lite/src/route-map.d.ts
|
||||
|
||||
# Docusaurus MDX content: prettier's markdown parser corrupts JSX
|
||||
# comments ({/* … */} becomes {/_ … _/}) and other MDX constructs
|
||||
/docs/docs/**/*.md
|
||||
|
||||
@@ -24,7 +24,7 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@vates/multi-key-map": "^0.2.0",
|
||||
"@xen-orchestra/async-map": "^0.1.4",
|
||||
"@xen-orchestra/async-map": "^0.1.3",
|
||||
"@xen-orchestra/log": "^0.7.2",
|
||||
"ensure-array": "^1.0.0"
|
||||
},
|
||||
|
||||
@@ -19,12 +19,12 @@
|
||||
},
|
||||
"main": "./index.mjs",
|
||||
"dependencies": {
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/fs": "^4.9.2",
|
||||
"@xen-orchestra/log": "^0.7.2",
|
||||
"fuse-native": "^2.2.6",
|
||||
"lru-cache": "^7.14.0",
|
||||
"promise-toolbox": "^0.21.0",
|
||||
"vhd-lib": "^4.16.1"
|
||||
"vhd-lib": "^4.16.0"
|
||||
},
|
||||
"bin": {
|
||||
"xo-fuse-vhd": "./cli.mjs"
|
||||
|
||||
@@ -19,12 +19,6 @@ export class NbdDisk extends RandomAccessDisk {
|
||||
/** @type {number} */
|
||||
#blockSize
|
||||
|
||||
/** @type {number | undefined} */
|
||||
#hasBlockCursor
|
||||
|
||||
/** @type {number | undefined} */
|
||||
#hasBlockPreviousIndex
|
||||
|
||||
constructor(nbdInfos, blockSize, { dataMap } = {}) {
|
||||
super()
|
||||
this.#blockSize = blockSize
|
||||
@@ -33,38 +27,11 @@ export class NbdDisk extends RandomAccessDisk {
|
||||
}
|
||||
|
||||
#processDatamap(rawDataMap) {
|
||||
const ranges = rawDataMap
|
||||
.filter(({ type, length }) => type === 0 && length > 0)
|
||||
return rawDataMap
|
||||
.filter(({ type }) => type === 0)
|
||||
.map(({ offset, length }) => ({ offset, length }))
|
||||
.sort(({ offset: offset1 }, { offset: offset2 }) => offset1 - offset2)
|
||||
|
||||
// hasBlock()'s forward-only cursor is only correct if the extents are
|
||||
// sorted AND disjoint: an earlier extent must never reach into a block
|
||||
// after a later one, otherwise the cursor could skip it and wrongly report
|
||||
// a block as empty, dropping data and corrupting the output.
|
||||
// Touching extents (cur.offset === prevEnd) are merged
|
||||
const merged = []
|
||||
for (const range of ranges) {
|
||||
const last = merged[merged.length - 1]
|
||||
if (last !== undefined) {
|
||||
const lastEnd = last.offset + last.length
|
||||
if (range.offset < lastEnd) {
|
||||
throw new Error(
|
||||
`overlapping ranges in data map: [${last.offset}, ${lastEnd}) and [${range.offset}, ${range.offset + range.length})`
|
||||
)
|
||||
}
|
||||
if (range.offset === lastEnd) {
|
||||
// touching: extend the previous extent
|
||||
last.length += range.length
|
||||
continue
|
||||
}
|
||||
}
|
||||
// gap (or first range): new extent
|
||||
merged.push(range)
|
||||
}
|
||||
return merged
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} index
|
||||
* @returns {Promise<DiskBlock>}
|
||||
@@ -150,34 +117,6 @@ export class NbdDisk extends RandomAccessDisk {
|
||||
return [...indexes].sort((a, b) => a - b)
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts the allocated blocks without materializing the index list.
|
||||
*
|
||||
* @returns {number}
|
||||
*/
|
||||
getBlockIndexesCount() {
|
||||
if (!this.#dataMap) {
|
||||
throw new Error("can't getBlockIndexesCount before init")
|
||||
}
|
||||
|
||||
const blockSize = this.getBlockSize()
|
||||
|
||||
let count = 0
|
||||
let lastCountedBlock = -1
|
||||
for (const { offset, length } of this.#dataMap) {
|
||||
const firstBlockIndex = Math.floor(offset / blockSize)
|
||||
const lastBlockIndex = Math.floor((offset + length - 1) / blockSize)
|
||||
const from = Math.max(firstBlockIndex, lastCountedBlock + 1)
|
||||
|
||||
if (lastBlockIndex >= from) {
|
||||
count += lastBlockIndex - from + 1
|
||||
lastCountedBlock = lastBlockIndex
|
||||
}
|
||||
}
|
||||
|
||||
return count
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} index
|
||||
* @returns {boolean}
|
||||
@@ -186,32 +125,8 @@ export class NbdDisk extends RandomAccessDisk {
|
||||
if (!this.#dataMap) {
|
||||
throw new Error("can't hasBlock before init")
|
||||
}
|
||||
|
||||
const blockSize = this.getBlockSize()
|
||||
const blockStart = index * blockSize
|
||||
const blockEnd = blockStart + blockSize
|
||||
|
||||
let startExtentIndex = 0
|
||||
if (this.#hasBlockCursor !== undefined && index >= this.#hasBlockPreviousIndex) {
|
||||
startExtentIndex = this.#hasBlockCursor
|
||||
} else {
|
||||
this.#hasBlockCursor = undefined
|
||||
}
|
||||
this.#hasBlockPreviousIndex = index
|
||||
|
||||
const dataMap = this.#dataMap
|
||||
const l = dataMap.length
|
||||
for (let i = startExtentIndex; i < l; i++) {
|
||||
const { offset, length } = dataMap[i]
|
||||
if (offset >= blockEnd) {
|
||||
// extents are sorted: nothing from here on can overlap this block
|
||||
break
|
||||
}
|
||||
if (offset + length > blockStart) {
|
||||
this.#hasBlockCursor = i
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
const blockStart = index * this.getBlockSize()
|
||||
const blockEnd = (index + 1) * this.getBlockSize()
|
||||
return this.#dataMap.some(({ offset, length }) => offset + length > blockStart && offset < blockEnd)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,127 +0,0 @@
|
||||
import { describe, it } from 'node:test'
|
||||
import assert from 'node:assert'
|
||||
|
||||
import { NbdDisk } from './NbdDisk.mjs'
|
||||
|
||||
const KiB = 1024
|
||||
const MiB = 1024 * KiB
|
||||
const TiB = 1024 * 1024 * MiB
|
||||
|
||||
const SOURCE_BLOCK_SIZE = 2 * MiB // VHD_BLOCK_SIZE, the block size used when importing from VMware
|
||||
const CLUSTER_SIZE = 64 * KiB // qcow2 cluster size
|
||||
|
||||
// hasBlock() only needs the dataMap (passed through the constructor) and the
|
||||
// block size, so we can exercise it without a live NBD connection.
|
||||
describe('NbdDisk.hasBlock', () => {
|
||||
it('reports allocated and unallocated blocks correctly', () => {
|
||||
const dataMap = [
|
||||
{ type: 0, offset: 0, length: SOURCE_BLOCK_SIZE }, // block 0
|
||||
{ type: 0, offset: 5 * SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // block 5
|
||||
]
|
||||
const disk = new NbdDisk({}, SOURCE_BLOCK_SIZE, { dataMap })
|
||||
|
||||
assert.strictEqual(disk.hasBlock(0), true)
|
||||
assert.strictEqual(disk.hasBlock(1), false)
|
||||
assert.strictEqual(disk.hasBlock(4), false)
|
||||
assert.strictEqual(disk.hasBlock(5), true)
|
||||
assert.strictEqual(disk.hasBlock(6), false)
|
||||
})
|
||||
|
||||
it('handles repeated and out-of-order queries with the resume cursor', () => {
|
||||
const dataMap = [
|
||||
{ type: 0, offset: 0, length: SOURCE_BLOCK_SIZE }, // block 0
|
||||
{ type: 0, offset: 5 * SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // block 5
|
||||
]
|
||||
const disk = new NbdDisk({}, SOURCE_BLOCK_SIZE, { dataMap })
|
||||
|
||||
// repeated indexes (the qcow2 path queries each 2MB block ~32 times as it
|
||||
// walks 64KB clusters) must return a stable answer
|
||||
assert.strictEqual(disk.hasBlock(5), true)
|
||||
assert.strictEqual(disk.hasBlock(5), true)
|
||||
assert.strictEqual(disk.hasBlock(6), false)
|
||||
assert.strictEqual(disk.hasBlock(6), false)
|
||||
|
||||
// querying backwards must still be correct (falls back to a full scan)
|
||||
assert.strictEqual(disk.hasBlock(0), true)
|
||||
assert.strictEqual(disk.hasBlock(5), true)
|
||||
})
|
||||
|
||||
it('invalidates the cursor on a backward miss (no stale skip)', () => {
|
||||
const dataMap = [
|
||||
{ type: 0, offset: 3 * SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // block 3
|
||||
{ type: 0, offset: 10 * SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // block 10
|
||||
]
|
||||
const disk = new NbdDisk({}, SOURCE_BLOCK_SIZE, { dataMap })
|
||||
|
||||
assert.strictEqual(disk.hasBlock(10), true) // forward hit: cursor parks on the high extent
|
||||
assert.strictEqual(disk.hasBlock(1), false) // backward miss: must invalidate the cursor
|
||||
assert.strictEqual(disk.hasBlock(3), true) // lower extent must not be skipped
|
||||
})
|
||||
|
||||
it('throws on overlapping ranges (would break the resume cursor)', () => {
|
||||
const dataMap = [
|
||||
{ type: 0, offset: 0, length: SOURCE_BLOCK_SIZE },
|
||||
{ type: 0, offset: SOURCE_BLOCK_SIZE / 2, length: SOURCE_BLOCK_SIZE }, // overlaps the previous range
|
||||
]
|
||||
assert.throws(() => new NbdDisk({}, SOURCE_BLOCK_SIZE, { dataMap }), /overlapping ranges/)
|
||||
})
|
||||
|
||||
it('merges touching ranges and drops zero-length / non type-0 entries', () => {
|
||||
const dataMap = [
|
||||
{ type: 0, offset: 2 * SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // [2, 3)
|
||||
{ type: 0, offset: 0, length: SOURCE_BLOCK_SIZE / 2 }, // [0, .5)
|
||||
{ type: 0, offset: SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // [1, 2)
|
||||
{ type: 0, offset: SOURCE_BLOCK_SIZE / 2, length: SOURCE_BLOCK_SIZE / 2 }, // [.5, 1), touches [0, .5)
|
||||
{ type: 1, offset: 10 * SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // wrong type: ignored
|
||||
{ type: 0, offset: 7 * SOURCE_BLOCK_SIZE, length: 0 }, // zero length: ignored
|
||||
]
|
||||
const disk = new NbdDisk({}, SOURCE_BLOCK_SIZE, { dataMap })
|
||||
|
||||
assert.strictEqual(disk.hasBlock(0), true)
|
||||
assert.strictEqual(disk.hasBlock(1), true)
|
||||
assert.strictEqual(disk.hasBlock(2), true)
|
||||
assert.strictEqual(disk.hasBlock(3), false)
|
||||
assert.strictEqual(disk.hasBlock(7), false) // zero-length range dropped
|
||||
assert.strictEqual(disk.hasBlock(10), false) // non type-0 range dropped
|
||||
})
|
||||
})
|
||||
|
||||
describe('NbdDisk.getBlockIndexesCount', () => {
|
||||
const cases = {
|
||||
'aligned, disjoint blocks': [
|
||||
{ type: 0, offset: 0, length: SOURCE_BLOCK_SIZE }, // block 0
|
||||
{ type: 0, offset: 5 * SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE }, // block 5
|
||||
],
|
||||
'a range spanning several blocks': [
|
||||
{ type: 0, offset: SOURCE_BLOCK_SIZE / 2, length: 3 * SOURCE_BLOCK_SIZE }, // blocks 0,1,2,3
|
||||
],
|
||||
'two disjoint extents sharing block 0 (needs dedup)': [
|
||||
{ type: 0, offset: 0, length: SOURCE_BLOCK_SIZE / 2 }, // [0, .5) => block 0
|
||||
{ type: 0, offset: 3 * (SOURCE_BLOCK_SIZE / 4), length: SOURCE_BLOCK_SIZE }, // [.75, 1.75) => blocks 0,1
|
||||
],
|
||||
'touching sub-block fragments': [
|
||||
{ type: 0, offset: 0, length: SOURCE_BLOCK_SIZE / 2 },
|
||||
{ type: 0, offset: SOURCE_BLOCK_SIZE / 2, length: SOURCE_BLOCK_SIZE / 2 },
|
||||
{ type: 0, offset: SOURCE_BLOCK_SIZE, length: SOURCE_BLOCK_SIZE },
|
||||
],
|
||||
empty: [],
|
||||
}
|
||||
|
||||
for (const [name, dataMap] of Object.entries(cases)) {
|
||||
it(`matches getBlockIndexes().length: ${name}`, () => {
|
||||
const disk = new NbdDisk({}, SOURCE_BLOCK_SIZE, { dataMap })
|
||||
assert.strictEqual(disk.getBlockIndexesCount(), disk.getBlockIndexes().length)
|
||||
})
|
||||
}
|
||||
|
||||
it('matches getBlockIndexes().length on the large sparse map', () => {
|
||||
const virtualSize = Math.floor(3.5 * TiB)
|
||||
const NB_RANGES = 113528
|
||||
const dataMap = []
|
||||
for (let i = 0; i < NB_RANGES; i++) {
|
||||
dataMap.push({ type: 0, offset: Math.floor((i / NB_RANGES) * virtualSize), length: CLUSTER_SIZE })
|
||||
}
|
||||
const disk = new NbdDisk({}, SOURCE_BLOCK_SIZE, { dataMap })
|
||||
assert.strictEqual(disk.getBlockIndexesCount(), disk.getBlockIndexes().length)
|
||||
})
|
||||
})
|
||||
@@ -7,7 +7,6 @@ const { warn } = createLogger('vates:nbd-client:multi')
|
||||
export default class MultiNbdClient {
|
||||
#clients = []
|
||||
#nbdConcurrency
|
||||
#nextClient = 0
|
||||
#options
|
||||
#readAhead
|
||||
#settings
|
||||
@@ -98,31 +97,8 @@ export default class MultiNbdClient {
|
||||
* @returns {Promise<Buffer>}
|
||||
*/
|
||||
async readBlock(index, size = NBD_DEFAULT_BLOCK_SIZE) {
|
||||
const clientId = this.#nextClient++ % this.#clients.length
|
||||
const client = this.#clients[clientId]
|
||||
try {
|
||||
return await client.readBlock(index, size)
|
||||
} catch (err) {
|
||||
// client.readBlock() already exhausted its own retries/reconnects: this connection is dead.
|
||||
// Evict it so future reads stop being routed to it, and retry this read on a surviving
|
||||
// client, since the data is usually still reachable through the others.
|
||||
this.#evict(client)
|
||||
if (this.#clients.length === 0) {
|
||||
throw err
|
||||
}
|
||||
warn(`evicted a dead nbd client, retrying block ${index} on a remaining client`, { err })
|
||||
return this.readBlock(index, size)
|
||||
}
|
||||
}
|
||||
|
||||
// no-op if `client` was already evicted by a concurrent failed read on the same client
|
||||
#evict(client) {
|
||||
const i = this.#clients.indexOf(client)
|
||||
if (i === -1) {
|
||||
return
|
||||
}
|
||||
this.#clients.splice(i, 1)
|
||||
client.disconnect().catch(() => {})
|
||||
const clientId = index % this.#clients.length
|
||||
return this.#clients[clientId].readBlock(index, size)
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,130 +0,0 @@
|
||||
import { describe, it, mock } from 'node:test'
|
||||
import assert from 'node:assert'
|
||||
|
||||
// MultiNbdClient instantiates NbdClient itself (`import NbdClient from './index.mjs'`), so the
|
||||
// only way to control individual connections from a unit test is to replace that module with a
|
||||
// fake before importing multi.mjs.
|
||||
const created = []
|
||||
class FakeNbdClient {
|
||||
constructor(nbdInfo) {
|
||||
this.nbdInfo = nbdInfo
|
||||
this.disconnected = false
|
||||
// overridden per-test after connect() to script this instance's behavior
|
||||
this.readBlock = async () => {
|
||||
throw new Error('readBlock not configured for this fake client')
|
||||
}
|
||||
created.push(this)
|
||||
}
|
||||
|
||||
async connect() {}
|
||||
|
||||
async disconnect() {
|
||||
this.disconnected = true
|
||||
}
|
||||
|
||||
async getMap() {
|
||||
return []
|
||||
}
|
||||
}
|
||||
|
||||
mock.module('./index.mjs', {
|
||||
defaultExport: FakeNbdClient,
|
||||
})
|
||||
|
||||
const { default: MultiNbdClient } = await import('./multi.mjs')
|
||||
|
||||
// a single settings entry is enough: connect() reuses candidates across concurrent slots, so
|
||||
// nbdConcurrency still yields that many distinct FakeNbdClient instances
|
||||
async function connectWithFakes(nbdConcurrency) {
|
||||
created.length = 0
|
||||
const client = new MultiNbdClient({ address: 'fake-host' }, { nbdConcurrency })
|
||||
await client.connect()
|
||||
return { client, fakes: created.slice() }
|
||||
}
|
||||
|
||||
describe('MultiNbdClient.readBlock eviction', () => {
|
||||
it('evicts a client whose readBlock rejects and retries on a surviving client', async () => {
|
||||
const { client, fakes } = await connectWithFakes(2)
|
||||
const [dead, alive] = fakes
|
||||
dead.readBlock = async () => {
|
||||
throw new Error('connection is dead')
|
||||
}
|
||||
alive.readBlock = async index => Buffer.from([index])
|
||||
|
||||
// index 0 initially routes to `dead` (0 % 2 === 0)
|
||||
const data = await client.readBlock(0)
|
||||
|
||||
assert.deepStrictEqual(data, Buffer.from([0]))
|
||||
assert.strictEqual(dead.disconnected, true, 'the dead client should have been disconnected')
|
||||
|
||||
// future reads must no longer be routed to the evicted client: with only `alive` left,
|
||||
// every index should now succeed through it
|
||||
alive.readBlock = async index => Buffer.from([index])
|
||||
const data2 = await client.readBlock(1)
|
||||
assert.deepStrictEqual(data2, Buffer.from([1]))
|
||||
})
|
||||
|
||||
it('rejects once every client has been evicted, instead of retrying forever', async () => {
|
||||
const { client, fakes } = await connectWithFakes(2)
|
||||
const boom = new Error('connection is dead')
|
||||
for (const fake of fakes) {
|
||||
fake.readBlock = async () => {
|
||||
throw boom
|
||||
}
|
||||
}
|
||||
|
||||
await assert.rejects(() => client.readBlock(0), boom)
|
||||
assert.ok(
|
||||
fakes.every(fake => fake.disconnected),
|
||||
'every client should have been evicted (and disconnected) before giving up'
|
||||
)
|
||||
})
|
||||
|
||||
it('evicting the same dead client from concurrent failed reads is idempotent', async () => {
|
||||
const { client, fakes } = await connectWithFakes(2)
|
||||
const [dead, alive] = fakes
|
||||
dead.readBlock = async () => {
|
||||
throw new Error('connection is dead')
|
||||
}
|
||||
alive.readBlock = async index => Buffer.from([index])
|
||||
|
||||
let disconnectCalls = 0
|
||||
dead.disconnect = async () => {
|
||||
disconnectCalls++
|
||||
dead.disconnected = true
|
||||
}
|
||||
|
||||
// routing is round-robin by call order (0, 1, 0) over a 2-client pool: the 1st and 3rd
|
||||
// calls both land on `dead` before either failure has been handled, so they race to evict
|
||||
// the same client. The exact interleaving isn't guaranteed, only that eviction is safe
|
||||
// either way and every read still completes.
|
||||
const [data0, data1, data2] = await Promise.all([client.readBlock(10), client.readBlock(11), client.readBlock(12)])
|
||||
|
||||
assert.deepStrictEqual(data0, Buffer.from([10]))
|
||||
assert.deepStrictEqual(data1, Buffer.from([11]))
|
||||
assert.deepStrictEqual(data2, Buffer.from([12]))
|
||||
assert.strictEqual(disconnectCalls, 1, 'the dead client must only be evicted/disconnected once')
|
||||
})
|
||||
})
|
||||
|
||||
describe('MultiNbdClient.readBlock routing', () => {
|
||||
it('distributes reads round-robin by call order, not by index residue', async () => {
|
||||
const { client, fakes } = await connectWithFakes(4)
|
||||
const readsPerClient = fakes.map(() => 0)
|
||||
fakes.forEach((fake, i) => {
|
||||
fake.readBlock = async index => {
|
||||
readsPerClient[i]++
|
||||
return Buffer.from([index])
|
||||
}
|
||||
})
|
||||
|
||||
// a CBT-style changed-block set striding by exactly `nbdConcurrency`: under the old
|
||||
// `index % clients.length` routing this would collapse entirely onto a single client
|
||||
const stridedIndexes = Array.from({ length: 20 }, (_, i) => i * 4)
|
||||
for (const index of stridedIndexes) {
|
||||
await client.readBlock(index)
|
||||
}
|
||||
|
||||
assert.deepStrictEqual(readsPerClient, [5, 5, 5, 5])
|
||||
})
|
||||
})
|
||||
@@ -13,7 +13,7 @@
|
||||
"url": "https://vates.fr"
|
||||
},
|
||||
"license": "ISC",
|
||||
"version": "3.5.1",
|
||||
"version": "3.4.0",
|
||||
"engines": {
|
||||
"node": ">=14.0"
|
||||
},
|
||||
@@ -21,11 +21,11 @@
|
||||
"dependencies": {
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@vates/read-chunk": "^1.2.1",
|
||||
"@xen-orchestra/async-map": "^0.1.4",
|
||||
"@xen-orchestra/disk-transform": "^1.3.3",
|
||||
"@xen-orchestra/async-map": "^0.1.3",
|
||||
"@xen-orchestra/disk-transform": "^1.3.1",
|
||||
"@xen-orchestra/log": "^0.7.2",
|
||||
"promise-toolbox": "^0.21.0",
|
||||
"xen-api": "^4.9.0"
|
||||
"xen-api": "^4.7.8"
|
||||
},
|
||||
"devDependencies": {
|
||||
"tap": "^18.7.0",
|
||||
@@ -33,7 +33,6 @@
|
||||
},
|
||||
"scripts": {
|
||||
"postversion": "npm publish --access public",
|
||||
"test": "node --experimental-test-module-mocks --test",
|
||||
"test-integration": "tap --allow-incomplete-coverage tests/*.integ.mjs"
|
||||
"test-integration": "tap --allow-incomplete-coverage"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -153,13 +153,7 @@ CYu1Xn/FVPx1HoRgWc7E8wFhDcA/P3SJtfIQWHB9FzSaBflKGR4t8WCE2eE8+cTB
|
||||
nbdServer = await spawnNbdKit(path)
|
||||
}
|
||||
}
|
||||
// reading past the end of the export must reject: a single client so the failure isn't
|
||||
// multiplied by nbdConcurrency evicting and retrying on every other (equally healthy, equally
|
||||
// unable to satisfy this out-of-range request) client
|
||||
const singleClient = new MultiNbdClient(connectionSettings, { nbdConcurrency: 1, readAhead: 2 })
|
||||
await singleClient.connect()
|
||||
await assert.rejects(() => singleClient.readBlock(100, CHUNK_SIZE))
|
||||
await singleClient.disconnect()
|
||||
assert.rejects(() => client.readBlock(100, CHUNK_SIZE))
|
||||
|
||||
await client.disconnect()
|
||||
// double disconnection shouldn't pose any problem
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "@vates/types",
|
||||
"private": false,
|
||||
"version": "2.0.1",
|
||||
"version": "1.28.0",
|
||||
"main": "./dist/index.mjs",
|
||||
"exports": {
|
||||
".": {
|
||||
@@ -32,8 +32,7 @@
|
||||
"devDependencies": {
|
||||
"@eslint/js": "^9.19.0",
|
||||
"typescript": "~5.6.3",
|
||||
"typescript-eslint": "^8.61.0",
|
||||
"@types/express": "^5.0.0"
|
||||
"typescript-eslint": "^8.61.0"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
|
||||
@@ -755,9 +755,9 @@ export type TrafficRuleDirection = 'from' | 'to' | 'from/to'
|
||||
|
||||
export type RawTrafficRule = {
|
||||
allow: boolean
|
||||
protocol: TrafficRuleProtocol
|
||||
protocol: string
|
||||
ipRange: string
|
||||
direction: TrafficRuleDirection
|
||||
direction: string
|
||||
port?: string
|
||||
}
|
||||
|
||||
|
||||
@@ -5,4 +5,3 @@ export * from './xo-app.mjs'
|
||||
export * from './lib/xen-orchestra-xapi.mjs'
|
||||
export * from './lib/xen-orchestra-acl.mjs'
|
||||
export * from './lib/complex-matcher.mjs'
|
||||
export * from './lib/rest-api.mjs'
|
||||
|
||||
@@ -1,96 +0,0 @@
|
||||
import type { NextFunction, Request, Response } from 'express'
|
||||
import type { VatesTask } from './vates-task.mjs'
|
||||
import type { XoApp } from '../xo-app.mjs'
|
||||
|
||||
export type SecurityName = '*' | 'token' | 'basic' | 'none'
|
||||
|
||||
export type FieldDefinition = { optional?: boolean; nullable?: boolean } & (
|
||||
| {
|
||||
type: 'string'
|
||||
example?: string
|
||||
}
|
||||
| {
|
||||
type: 'boolean'
|
||||
example?: boolean
|
||||
}
|
||||
| {
|
||||
type: 'number'
|
||||
example?: number
|
||||
}
|
||||
| {
|
||||
type: 'enum'
|
||||
enum: string[]
|
||||
example?: string
|
||||
}
|
||||
| {
|
||||
type: 'object'
|
||||
fields: Record<string, FieldDefinition>
|
||||
}
|
||||
| {
|
||||
type: 'array'
|
||||
items: FieldDefinition
|
||||
example?: unknown[]
|
||||
}
|
||||
)
|
||||
export type ParamFieldDefinition = Exclude<
|
||||
FieldDefinition,
|
||||
{ type: 'boolean' } | { type: 'object' } | { type: 'array' }
|
||||
>
|
||||
|
||||
export type QueryFieldDefinition = Exclude<FieldDefinition, { type: 'object' } | { type: 'array' }>
|
||||
type RestApi = object & { xoApp: XoApp }
|
||||
export type CreateAction = <Result>(
|
||||
callback: (task: VatesTask) => MaybePromise<Result>,
|
||||
opts: {
|
||||
sync?: boolean
|
||||
statusCode?: number
|
||||
taskProperties: { name: string; [key: string]: unknown }
|
||||
}
|
||||
) => Promise<Result | undefined>
|
||||
|
||||
export interface BaseRouteDefinition<Middleware> {
|
||||
method: 'get' | 'post' | 'put' | 'delete' | 'patch'
|
||||
endpoint: string
|
||||
description?: string
|
||||
tags?: string[]
|
||||
params?: Record<string, ParamFieldDefinition>
|
||||
query?: Record<string, QueryFieldDefinition>
|
||||
body?: Record<string, FieldDefinition>
|
||||
responses?: Array<{
|
||||
status: number
|
||||
description: string
|
||||
schema?: Record<string, FieldDefinition>
|
||||
}>
|
||||
middlewares?: Middleware[]
|
||||
scope?: 'acl'
|
||||
callback: (params: {
|
||||
req: Request
|
||||
res: Response
|
||||
next: NextFunction
|
||||
restApi: RestApi
|
||||
createAction: CreateAction
|
||||
}) => MaybePromise<unknown>
|
||||
security?: SecurityName
|
||||
}
|
||||
|
||||
export type MiddlewareDescriptor =
|
||||
| { name: 'json' | 'urlencoded' | 'text' | 'raw'; options?: Record<string, unknown> }
|
||||
| { name: 'acl'; acls: LooseAclEntry | LooseAclEntry[] }
|
||||
|
||||
type MaybePromise<T> = T | Promise<T>
|
||||
/**
|
||||
* Loosely-typed mirror of {@link https://github.com/vatesfr/xen-orchestra/blob/master/@xen-orchestra/rest-api/src/middlewares/acl.middleware.mts | AclEntry}
|
||||
* from `@xen-orchestra/rest-api/src/middlewares/acl.middleware.mts`.
|
||||
*/
|
||||
export type LooseAclEntry = {
|
||||
resource: string
|
||||
action?: string | ((opts: { req: object; restApi: RestApi }) => string | undefined)
|
||||
actions?: string[] | ((opts: { req: object; restApi: RestApi }) => string[])
|
||||
objectId?: string | ((opts: { req: object; restApi: RestApi }) => string)
|
||||
objectIds?: string[] | ((opts: { req: object; restApi: RestApi }) => string[])
|
||||
object?: object | ((opts: { req: object; restApi: RestApi }) => MaybePromise<object> | undefined)
|
||||
objects?: object[] | ((opts: { req: object; restApi: RestApi }) => MaybePromise<object[]> | undefined)
|
||||
getObject?: (opts: { restApi: RestApi }) => (id: string) => MaybePromise<object>
|
||||
}
|
||||
|
||||
export type PluginRestRouteDefinition = BaseRouteDefinition<MiddlewareDescriptor>
|
||||
@@ -1,24 +1,19 @@
|
||||
import { Branded } from '../common.mjs'
|
||||
import type { XoGroup, XoUser } from '../xo.mjs'
|
||||
|
||||
type XoAclBaseRole = {
|
||||
id: Branded<'acl-v2-role'>
|
||||
name: string
|
||||
description?: string
|
||||
privilegeIds: XoAclBasePrivilege['id'][]
|
||||
}
|
||||
|
||||
type XoAclRegularRole = XoAclBaseRole & {
|
||||
groupIds: XoGroup['id'][]
|
||||
userIds: XoUser['id'][]
|
||||
}
|
||||
|
||||
type XoAclTemplateRole = XoAclBaseRole & {
|
||||
isTemplate: true
|
||||
roleTemplateId: number
|
||||
}
|
||||
|
||||
export type XoAclRole = XoAclRegularRole | XoAclTemplateRole
|
||||
export type XoAclRole =
|
||||
| {
|
||||
id: Branded<'acl-v2-role'>
|
||||
name: string
|
||||
description?: string
|
||||
}
|
||||
| {
|
||||
id: Branded<'acl-v2-role'>
|
||||
name: string
|
||||
description?: string
|
||||
isTemplate: true
|
||||
roleTemplateId: number
|
||||
}
|
||||
|
||||
export type XoAclSupportedActionsByResource = {
|
||||
[resource: string]: Record<string, unknown>
|
||||
|
||||
@@ -233,36 +233,6 @@ export interface Xapi {
|
||||
powerOnHost(hostId: XoHost['id']): Promise<void>
|
||||
rebootHost(hostId: XoHost['id'], force?: boolean): Promise<void>
|
||||
shutdownHost(hostId: XoHost['id'], opts?: { force?: boolean; bypassEvacuate?: boolean }): Promise<void>
|
||||
SR_create(params: {
|
||||
content_type?: XoSr['content_type']
|
||||
// index signature, not `Record<string, string>`: tsoa emits an empty schema for `Record`
|
||||
// (https://github.com/lukeautry/tsoa/pull/1858). device_config keys are driver-specific (SR_type).
|
||||
device_config: {
|
||||
chapuser?: string
|
||||
chappassword?: string
|
||||
device?: string
|
||||
legacy_mode?: string
|
||||
location?: string
|
||||
nfsversion?: string
|
||||
options?: string
|
||||
password?: string
|
||||
SCSIid?: string
|
||||
server?: string
|
||||
serverpath?: string
|
||||
target?: string
|
||||
targetIQN?: string
|
||||
username?: string
|
||||
} & {
|
||||
[key: string]: string
|
||||
}
|
||||
host: XenApiHost['$ref']
|
||||
name_description?: XoSr['name_description']
|
||||
name_label: XoSr['name_label']
|
||||
physical_size?: number
|
||||
shared: boolean
|
||||
sm_config?: { [key: string]: string }
|
||||
type: XoSr['SR_type']
|
||||
}): Promise<XenApiSr['$ref']>
|
||||
SR_importVdi(
|
||||
ref: XenApiSr['$ref'],
|
||||
stream: Readable,
|
||||
@@ -358,7 +328,6 @@ export interface Xapi {
|
||||
vgpuType?: XoVgpuType['id']
|
||||
gpuGroup?: XoGpuGroup['id']
|
||||
copyHostBiosStrings?: boolean
|
||||
highAvailability?: XoVm['high_availability']
|
||||
hvmBootFirmware?: 'uefi' | 'bios'
|
||||
secureBoot?: boolean
|
||||
},
|
||||
@@ -411,7 +380,7 @@ export interface Xapi {
|
||||
): Promise<Readable & { length?: number }>
|
||||
VDI_importContent(
|
||||
vdiRef: XenApiVdi['$ref'],
|
||||
stream: Readable | Buffer,
|
||||
stream: Readable,
|
||||
opts: { cancelToken?: unknown; format: SUPPORTED_VDI_FORMAT }
|
||||
): Promise<void>
|
||||
VIF_create(
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import { EventEmitter } from 'node:stream'
|
||||
import type {
|
||||
AnyXoBackupJob,
|
||||
AnyXoJob,
|
||||
AnyXoLog,
|
||||
XapiXoRecord,
|
||||
@@ -20,7 +21,6 @@ import type {
|
||||
XoVmBackupArchive,
|
||||
} from './xo.mjs'
|
||||
import { VatesTask } from './lib/vates-task.mjs'
|
||||
import type { PluginRestRouteDefinition } from './lib/rest-api.mjs'
|
||||
import {
|
||||
Xapi,
|
||||
XapiHostStats,
|
||||
@@ -195,7 +195,6 @@ export type XoApp = {
|
||||
params?: any
|
||||
}
|
||||
) => () => void // eslint-disable-line @typescript-eslint/no-explicit-any
|
||||
registerRestRoutes: (routes: PluginRestRouteDefinition[], base?: string) => () => void
|
||||
authenticateUser: (
|
||||
credentials: { token?: string; username?: string; password?: string },
|
||||
userData?: { ip?: string },
|
||||
@@ -204,8 +203,6 @@ export type XoApp = {
|
||||
backupGuard(poolId: XoPool['id']): Promise<void>
|
||||
/* Throw if no authorization */
|
||||
checkFeatureAuthorization(featureCode: FeatureCode): Promise<void>
|
||||
/* validate, apply and persist the configuration of a plugin */
|
||||
configurePlugin(id: string, configuration: unknown, mergeWithExisting?: boolean): Promise<void>
|
||||
/* connect a server (XCP-ng/XenServer) */
|
||||
connectXenServer(id: XoServer['id']): Promise<void>
|
||||
// TODO: replace all XoAclBasePrivilege with a more strict type. (discriminate union)
|
||||
@@ -236,11 +233,7 @@ export type XoApp = {
|
||||
url: string
|
||||
}): Promise<XoBackupRepository>
|
||||
createUser(params: { name?: string; password?: string; [key: string]: unknown }): Promise<XoUser>
|
||||
deleteAclV2GroupRole(
|
||||
groupId: XoGroup['id'],
|
||||
roleId: XoAclRole['id'],
|
||||
opts?: { bypassAuthorization?: boolean }
|
||||
): Promise<boolean>
|
||||
deleteAclV2GroupRole(groupId: XoGroup['id'], roleId: XoAclRole['id']): Promise<boolean>
|
||||
deleteAclV2Privilege(privilegeId: XoAclBasePrivilege['id'], options?: { force?: boolean }): Promise<boolean>
|
||||
deleteAclV2Role(roleId: XoAclRole['id'], options?: { force?: boolean }): Promise<boolean>
|
||||
deleteGroup(id: XoGroup['id']): Promise<void>
|
||||
@@ -253,22 +246,10 @@ export type XoApp = {
|
||||
getAclV2Privilege(id: XoAclBasePrivilege['id']): Promise<XoAclBasePrivilege>
|
||||
getAclV2Privileges(): Promise<XoAclBasePrivilege[]>
|
||||
getAclV2RolePrivileges(roleId: XoAclRole['id']): Promise<XoAclBasePrivilege[]>
|
||||
getAclV2Role(id: XoAclRole['id'], opts?: { bypassAuthorization?: boolean }): Promise<XoAclRole>
|
||||
deleteAclV2UserRole(
|
||||
userId: XoUser['id'],
|
||||
roleId: XoAclRole['id'],
|
||||
opts?: { bypassAuthorization?: boolean }
|
||||
): Promise<boolean>
|
||||
getAclV2GroupRoles(
|
||||
groupId: XoGroup['id'],
|
||||
opts?: { bypassAuthorization?: boolean }
|
||||
): Promise<Exclude<XoAclRole, { isTemplate: true }>[]>
|
||||
getAclV2Role(id: XoAclRole['id']): Promise<XoAclRole>
|
||||
deleteAclV2UserRole(userId: XoUser['id'], roleId: XoAclRole['id']): Promise<boolean>
|
||||
getAclV2Roles(): Promise<XoAclRole[]>
|
||||
getAclV2UserPrivileges(userId: XoUser['id']): Promise<XoAclBasePrivilege[]>
|
||||
getAclV2UserRoles(
|
||||
userId: XoUser['id'],
|
||||
opts?: { bypassAuthorization?: boolean; fromGroup?: boolean; fromUser?: boolean }
|
||||
): Promise<XoAclRole[]>
|
||||
getAllGroups(): Promise<XoGroup[]>
|
||||
getAllProxies(): Promise<XoProxy[]>
|
||||
getAllJobs<T extends AnyXoJob['type']>(type: T): Promise<Extract<AnyXoJob, { type: T }>[]>
|
||||
@@ -330,11 +311,10 @@ export type XoApp = {
|
||||
xo: Record<XoBackupRepository['id'], XoConfigBackupArchive[]>
|
||||
pool: Record<XoBackupRepository['id'], Record<XoPool['id'], XoPoolBackupArchive[]>>
|
||||
}>
|
||||
/** `null` when the listing of a backup repository failed */
|
||||
listVmBackupsNg(
|
||||
backupRepositoryIds: XoBackupRepository['id'][],
|
||||
opts?: { _forceRefresh?: boolean; vmId?: XoVm['id'] }
|
||||
): Promise<Record<XoBackupRepository['id'], Record<XoVm['id'], XoVmBackupArchive[]> | null>>
|
||||
opts?: { _forceRefresh?: boolean; vmId: XoVm['id'] }
|
||||
): Promise<Record<XoBackupRepository['id'], Record<XoVm['id'], XoVmBackupArchive[]>>>
|
||||
pingRemote(id: XoBackupRepository['id']): Promise<{ success: true }>
|
||||
/** Allow to add a new server in the DB (XCP-ng/XenServer) */
|
||||
registerXenServer(
|
||||
@@ -344,11 +324,8 @@ export type XoApp = {
|
||||
readOnly?: XoServer['readOnly']
|
||||
}
|
||||
): Promise<XoServer>
|
||||
rollingPoolReboot(pool: XoPool, opts?: { parentTask?: VatesTask; shutdownPinnedVms?: boolean }): Promise<void>
|
||||
rollingPoolUpdate(
|
||||
pool: XoPool,
|
||||
opts?: { rebootVm?: boolean; parentTask?: VatesTask; shutdownPinnedVms?: boolean }
|
||||
): Promise<void>
|
||||
rollingPoolReboot(pool: XoPool, opts?: { parentTask?: VatesTask }): Promise<void>
|
||||
rollingPoolUpdate(pool: XoPool, opts?: { rebootVm?: boolean; parentTask?: VatesTask }): Promise<void>
|
||||
setVmResourceSet(vmId: XoVm['id'], resourceSetId: string | null, force?: boolean): Promise<void>
|
||||
shareVmResourceSet(vmId: XoVm['id']): Promise<void>
|
||||
removeUserFromGroup(userId: XoUser['id'], id: XoGroup['id']): Promise<void>
|
||||
|
||||
@@ -19,7 +19,7 @@ import type {
|
||||
VM_POWER_STATE,
|
||||
} from './common.mjs'
|
||||
import type * as CMType from './lib/complex-matcher.mjs'
|
||||
import { XoAclBasePrivilege, XoAclRole } from './lib/xen-orchestra-acl.mjs'
|
||||
import { XoAclPrivilege, XoAclRole, XoAclSupportedActionsByResource } from './lib/xen-orchestra-acl.mjs'
|
||||
import type { XenApiHost, XenApiPool } from './xen-api.mjs'
|
||||
|
||||
type BaseXapiXo = {
|
||||
@@ -76,7 +76,7 @@ type BaseXoVm = BaseXapiXo & {
|
||||
expNestedHvm: boolean
|
||||
isNestedVirtEnabled: boolean
|
||||
hasVendorDevice: boolean
|
||||
high_availability: 'best-effort' | 'restart' | ''
|
||||
high_availability: string
|
||||
installTime?: number | null
|
||||
isFirmwareSupported: boolean
|
||||
memory: {
|
||||
@@ -222,7 +222,6 @@ export type XoGroup = {
|
||||
provider?: string
|
||||
providerGroupId?: string
|
||||
users: XoUser['id'][]
|
||||
aclRoleIds: XoAclRole['id'][]
|
||||
}
|
||||
|
||||
export type XoHost = BaseXapiXo & {
|
||||
@@ -614,7 +613,7 @@ export type XoSr = BaseXapiXo & {
|
||||
VDIs: AnyXoVdi['id'][]
|
||||
|
||||
allocationStrategy?: 'thin' | 'thick' | 'unknown'
|
||||
content_type: 'user' | 'iso' | 'disk'
|
||||
content_type: string
|
||||
current_operations: Record<string, STORAGE_OPERATIONS>
|
||||
id: Branded<'SR'>
|
||||
inMaintenanceMode: boolean
|
||||
@@ -625,28 +624,7 @@ export type XoSr = BaseXapiXo & {
|
||||
shared: boolean
|
||||
size: number
|
||||
sm_config: Record<string, string>
|
||||
// SM drivers shipped with XCP-ng/XenServer
|
||||
SR_type:
|
||||
| 'cephfs'
|
||||
| 'dummy'
|
||||
| 'ext'
|
||||
| 'file'
|
||||
| 'glusterfs'
|
||||
| 'hba'
|
||||
| 'iso'
|
||||
| 'largeblock'
|
||||
| 'linstor'
|
||||
| 'lvm'
|
||||
| 'lvmofcoe'
|
||||
| 'lvmohba'
|
||||
| 'lvmoiscsi'
|
||||
| 'moosefs'
|
||||
| 'nfs'
|
||||
| 'shm'
|
||||
| 'smb'
|
||||
| 'udev'
|
||||
| 'xfs'
|
||||
| 'zfs'
|
||||
SR_type: string
|
||||
tags: string[]
|
||||
type: 'SR'
|
||||
usage: number
|
||||
@@ -889,7 +867,10 @@ export type XapiXoRecord =
|
||||
| XoVtpm
|
||||
| XoSm
|
||||
|
||||
export type NonXapiXoRecord =
|
||||
export type NonXapiXoRecord<
|
||||
TActionsByResource extends XoAclSupportedActionsByResource = never,
|
||||
TResource extends string = never,
|
||||
> =
|
||||
| AnyXoBackupArchive
|
||||
| AnyXoJob
|
||||
| AnyXoLog
|
||||
@@ -902,9 +883,12 @@ export type NonXapiXoRecord =
|
||||
| XoTask
|
||||
| XoUser
|
||||
| XoAclRole
|
||||
| XoAclBasePrivilege
|
||||
| XoAclPrivilege<TActionsByResource, TResource>
|
||||
|
||||
export type XoRecord = XapiXoRecord | NonXapiXoRecord
|
||||
export type XoRecord<
|
||||
TActionsByResource extends XoAclSupportedActionsByResource = never,
|
||||
TResource extends string = never,
|
||||
> = XapiXoRecord | NonXapiXoRecord<TActionsByResource, TResource>
|
||||
|
||||
export type AnyXoVm = XoVm | XoVmSnapshot | XoVmTemplate | XoVmController
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
"main": "dist/index.mjs",
|
||||
"name": "@xen-orchestra/acl",
|
||||
"homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/acl",
|
||||
"version": "1.6.1",
|
||||
"version": "1.4.0",
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"private": false,
|
||||
"type": "module",
|
||||
@@ -30,7 +30,7 @@
|
||||
},
|
||||
"devDependencies": {
|
||||
"@eslint/js": "^9.19.0",
|
||||
"@vates/types": "^2.0.1",
|
||||
"@vates/types": "^1.28.0",
|
||||
"rimraf": "^6.0.1",
|
||||
"typescript": "~5.6",
|
||||
"typescript-eslint": "^8.61.0"
|
||||
|
||||
@@ -16,7 +16,6 @@ export default {
|
||||
smart: true,
|
||||
},
|
||||
'restart-toolstack': true,
|
||||
'scan-pifs': true,
|
||||
shutdown: {
|
||||
clean: true,
|
||||
emergency: true,
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
export default {
|
||||
create: true,
|
||||
delete: true,
|
||||
forget: true,
|
||||
import: {
|
||||
|
||||
@@ -13,11 +13,11 @@ const wrapCall = (fn, arg, thisArg) => {
|
||||
*
|
||||
* WARNING: Does not handle plain objects
|
||||
*
|
||||
* @template Item, Result, [This=Iterable<Item>]
|
||||
* @template Item,This
|
||||
* @param {Iterable<Item>} iterable
|
||||
* @param {(this: This, item: Item) => (Result | PromiseLike<Result>)} mapFn
|
||||
* @param {This} [thisArg] defaults to `iterable`
|
||||
* @returns {Promise<Result[]>}
|
||||
* @param {(this: This, item: Item) => (Item | PromiseLike<Item>)} mapFn
|
||||
* @param {This} [thisArg]
|
||||
* @returns {Promise<Item[]>}
|
||||
*/
|
||||
exports.asyncMap = function asyncMap(iterable, mapFn, thisArg = iterable) {
|
||||
return Promise.all(Array.from(iterable, mapFn, thisArg))
|
||||
@@ -26,11 +26,11 @@ exports.asyncMap = function asyncMap(iterable, mapFn, thisArg = iterable) {
|
||||
/**
|
||||
* Like `asyncMap` but wait for all promises to settle before rejecting
|
||||
*
|
||||
* @template Item, Result, [This=Iterable<Item>]
|
||||
* @template Item,This
|
||||
* @param {Iterable<Item>} iterable
|
||||
* @param {(this: This, item: Item) => (Result | PromiseLike<Result>)} mapFn
|
||||
* @param {This} [thisArg] defaults to `iterable`
|
||||
* @returns {Promise<Result[]>}
|
||||
* @param {(this: This, item: Item) => (Item | PromiseLike<Item>)} mapFn
|
||||
* @param {This} [thisArg]
|
||||
* @returns {Promise<Item[]>}
|
||||
*/
|
||||
exports.asyncMapSettled = function asyncMapSettled(iterable, mapFn, thisArg = iterable) {
|
||||
return new Promise((resolve, reject) => {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"private": false,
|
||||
"name": "@xen-orchestra/async-map",
|
||||
"version": "0.1.4",
|
||||
"version": "0.1.3",
|
||||
"license": "ISC",
|
||||
"description": "Promise.all + map for all iterables",
|
||||
"keywords": [
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@xen-orchestra/backup-archive",
|
||||
"version": "1.1.2",
|
||||
"version": "1.0.4",
|
||||
"description": "Helper to handle generic backup archives",
|
||||
"license": "ISC",
|
||||
"author": "",
|
||||
@@ -21,24 +21,23 @@
|
||||
"tar-stream": "^3.1.8",
|
||||
"@types/tar-stream": "^3.1.4",
|
||||
"tmp": "^0.2.1",
|
||||
"@vates/types": "^2.0.1"
|
||||
"@vates/types": "^1.28.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@xen-orchestra/log": "^0.7.1",
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/disk-transform": "^1.3.3",
|
||||
"@xen-orchestra/fs": "^4.9.2",
|
||||
"@xen-orchestra/disk-transform": "^1.3.1",
|
||||
"@vates/task": "0.7.0",
|
||||
"golike-defer": "0.5.1",
|
||||
"uuid": "^9.0.0",
|
||||
"promise-toolbox": "^0.21.0",
|
||||
"@vates/async-each": "^1.0.1",
|
||||
"vhd-lib": "^4.16.1"
|
||||
"vhd-lib": "^4.14.7"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "yarn run clean && tsc",
|
||||
"dev": "tsc --watch",
|
||||
"postversion": "npm publish --access public",
|
||||
"test": "yarn run clean && tsc && node --test **/*.test.mjs",
|
||||
"test-integration": "yarn run clean && tsc && node --test **/*.integ.mjs",
|
||||
"clean": "rimraf dist/"
|
||||
},
|
||||
|
||||
@@ -10,11 +10,6 @@ export interface PartialBackupMetadata {
|
||||
jobId: string
|
||||
scheduleId: string
|
||||
timestamp: number
|
||||
// 'true' when written by code including the non-NBD qcow2 corruption fix and its force-full
|
||||
// gate; its absence marks a potentially-corrupt older backup and makes the gate re-probe.
|
||||
// Preserved (never stamped) across merges here.
|
||||
// @todo remove this code and the logic associated on 2027 01 01
|
||||
includeNonNbdQcow2Fix?: boolean
|
||||
}
|
||||
export const DEFAULT_MERGE_CONCURRENCY = 1
|
||||
export const DEFAULT_REMOVE_CONCURRENCY = 4
|
||||
|
||||
@@ -39,10 +39,6 @@ export class VmBackupDirectory implements VmBackupInterface {
|
||||
#checkResult: (CheckResult & { orphans: string[]; linked: string[] }) | undefined = undefined
|
||||
#uniqueLineages: Map<string, RemoteDiskLineage> | undefined = undefined
|
||||
|
||||
// Set by #checkCacheCount(): the on-disk cache did not match the archives found
|
||||
// on disk, so clean() must regenerate it even when nothing was merged/removed.
|
||||
#cacheOutOfSync = false
|
||||
|
||||
constructor(
|
||||
handler: RemoteHandlerAbstract,
|
||||
vmBackupPath: string,
|
||||
@@ -187,7 +183,7 @@ export class VmBackupDirectory implements VmBackupInterface {
|
||||
{ concurrency: 2 }
|
||||
)
|
||||
|
||||
if (allMergedSizes.size > 0 || cacheNeedsRegen || this.#cacheOutOfSync) {
|
||||
if (allMergedSizes.size > 0 || cacheNeedsRegen) {
|
||||
await this.#regenerateCache()
|
||||
}
|
||||
|
||||
@@ -218,8 +214,7 @@ export class VmBackupDirectory implements VmBackupInterface {
|
||||
const existingCache = await this.#readCache(cachePath)
|
||||
const actual = existingCache === undefined ? 0 : Object.keys(existingCache).length
|
||||
const expected = this.backupArchives.size
|
||||
this.#cacheOutOfSync = actual !== expected
|
||||
if (this.#cacheOutOfSync) {
|
||||
if (actual !== expected) {
|
||||
this.opts.logWarn('unexpected number of entries in backup cache', { path: cachePath, actual, expected })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,14 +13,10 @@ import { MergeRemoteDisk } from '../dist/disks/MergeRemoteDisk.mjs'
|
||||
import { VHDFOOTER, VHDHEADER } from './tests.fixtures.mjs'
|
||||
import { VhdFile, Constants, VhdDirectory, VhdAbstract } from 'vhd-lib'
|
||||
import { dirname, basename } from 'node:path'
|
||||
import { promisify } from 'node:util'
|
||||
import zlib from 'node:zlib'
|
||||
import { rimraf } from 'rimraf'
|
||||
|
||||
const { beforeEach, afterEach, describe } = test
|
||||
|
||||
const gunzip = promisify(zlib.gunzip)
|
||||
|
||||
let tempDir, handler, jobId, vdiId, basePath, relativePath, vdiId2, basePath2, relativePath2
|
||||
const rootPath = 'xo-vm-backups/VMUUID/'
|
||||
|
||||
@@ -832,28 +828,3 @@ test('it preserves VDI directory when handler.list() throws during lineage init'
|
||||
const remaining = await handler.list(basePath)
|
||||
assert.ok(remaining.includes('snapshot.vhd'), 'VHD must survive when handler.list() throws during lineage init')
|
||||
})
|
||||
|
||||
test('it regenerates the cache when its entry count is out of sync, even with nothing to merge/remove', async () => {
|
||||
// a referenced disk + its metadata, but no cache.json.gz on disk
|
||||
await generateVhd(`${basePath}/diskA1.vhd`)
|
||||
await handler.writeFile(
|
||||
`${rootPath}/metadata.json`,
|
||||
JSON.stringify({ mode: 'delta', vhds: [`${relativePath}/diskA1.vhd`] })
|
||||
)
|
||||
await assert.rejects(handler.readFile(`${rootPath}/cache.json.gz`), { code: 'ENOENT' })
|
||||
|
||||
const logged = []
|
||||
// remove/merge both false: cacheNeedsRegen stays false and no merge happens,
|
||||
// so only the cache-count mismatch can trigger the regeneration
|
||||
await VmBackupDirectory.cleanVm(handler, rootPath, {
|
||||
remove: false,
|
||||
merge: false,
|
||||
logInfo: () => {},
|
||||
logWarn: message => logged.push(message),
|
||||
})
|
||||
|
||||
assert.ok(logged.includes('unexpected number of entries in backup cache'), 'mismatch should be reported')
|
||||
|
||||
const cache = JSON.parse((await gunzip(await handler.readFile(`${rootPath}/cache.json.gz`))).toString())
|
||||
assert.equal(Object.keys(cache).length, 1, 'cache should be regenerated to match the archives on disk')
|
||||
})
|
||||
|
||||
260
@xen-orchestra/backup-archive/src/disks/RemotePathDisk.mjs
Normal file
260
@xen-orchestra/backup-archive/src/disks/RemotePathDisk.mjs
Normal file
@@ -0,0 +1,260 @@
|
||||
// @ts-check
|
||||
|
||||
/**
|
||||
* @typedef {import('@xen-orchestra/disk-transform').FileAccessor} FileAccessor
|
||||
*/
|
||||
|
||||
import { DiskAlias, AliasMissingError, AliasIsDirectoryError } from '@xen-orchestra/disk-transform'
|
||||
import { normalize } from '@xen-orchestra/fs/path'
|
||||
import { RemoteDisk } from './RemoteDisk.mjs'
|
||||
|
||||
/**
|
||||
* A RemoteDisk backed by a single handler + path (possibly an alias to another path).
|
||||
* Owns the alias-driven rename/unlink/clean/listAssociatedFiles logic so format-specific
|
||||
* subclasses (RemoteVhdDisk, and later others) don't have to reimplement it.
|
||||
*/
|
||||
export class RemotePathDisk extends RemoteDisk {
|
||||
/** @type {FileAccessor} */
|
||||
#handler
|
||||
|
||||
/** @type {string} */
|
||||
#path
|
||||
|
||||
/** @type {DiskAlias} */
|
||||
#alias
|
||||
|
||||
/**
|
||||
* @param {Object} params
|
||||
* @param {FileAccessor} params.handler
|
||||
* @param {string} params.path
|
||||
* @param {string} params.extension - e.g. 'vhd', used to build the `*.alias.<extension>` suffix
|
||||
*/
|
||||
constructor({ handler, path, extension }) {
|
||||
super()
|
||||
this.#handler = handler
|
||||
this.#path = path
|
||||
this.#alias = new DiskAlias(extension)
|
||||
}
|
||||
|
||||
/** @returns {FileAccessor} */
|
||||
get handler() {
|
||||
return this.#handler
|
||||
}
|
||||
|
||||
/** @returns {string} */
|
||||
get path() {
|
||||
return this.#path
|
||||
}
|
||||
|
||||
set path(newPath) {
|
||||
this.#path = newPath
|
||||
}
|
||||
|
||||
/** @returns {DiskAlias} */
|
||||
get alias() {
|
||||
return this.#alias
|
||||
}
|
||||
|
||||
/**
|
||||
* Abstract - true once the disk's format-specific state has been opened (e.g. after init()).
|
||||
* @returns {boolean}
|
||||
*/
|
||||
get isOpen() {
|
||||
throw new Error('isOpen must be implemented')
|
||||
}
|
||||
|
||||
/**
|
||||
* Abstract - throws if `target` isn't a valid, openable disk of this format.
|
||||
* @param {string} target
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async validateTarget(target) {
|
||||
throw new Error('validateTarget must be implemented')
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {string}
|
||||
*/
|
||||
getPath() {
|
||||
return this.path
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {string[]}
|
||||
*/
|
||||
getPaths() {
|
||||
return [this.getPath()]
|
||||
}
|
||||
|
||||
/**
|
||||
* Rename alias/disk
|
||||
* @param {string} newPath
|
||||
*/
|
||||
async rename(newPath) {
|
||||
const { handler, alias } = this
|
||||
if (alias.isAlias(newPath)) {
|
||||
const dataPath = await alias.resolve(handler, this.path)
|
||||
await handler.unlink(newPath)
|
||||
await alias.create(handler, newPath, dataPath)
|
||||
await handler.unlink(this.path)
|
||||
this.path = newPath
|
||||
} else {
|
||||
try {
|
||||
await handler.unlink(newPath)
|
||||
} catch (err) {
|
||||
if (err && typeof err === 'object' && 'code' in err && err.code === 'EISDIR') {
|
||||
await handler.rmtree(newPath).catch(() => {})
|
||||
}
|
||||
}
|
||||
await handler.rename(this.path, newPath)
|
||||
this.path = newPath
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes alias/disk
|
||||
* @param {Object} options
|
||||
* @param {boolean} [options.force]
|
||||
*/
|
||||
async unlink({ force = false } = {}) {
|
||||
const { handler, alias } = this
|
||||
|
||||
if (!this.isOpen) {
|
||||
if (!force) {
|
||||
throw new Error(`can't call unlink of a ${this.constructor.name} before init`)
|
||||
}
|
||||
await alias.unlink(handler, this.path)
|
||||
return
|
||||
}
|
||||
|
||||
await this.close()
|
||||
|
||||
if (alias.isAlias(this.path)) {
|
||||
try {
|
||||
await handler.unlink(await alias.resolve(handler, this.path))
|
||||
} catch (err) {
|
||||
if (err && typeof err === 'object' && 'code' in err && err.code === 'EISDIR') {
|
||||
await handler.rmtree(await alias.resolve(handler, this.path)).catch(() => {})
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
await handler.unlink(this.path)
|
||||
} catch (err) {
|
||||
if (err && typeof err === 'object' && 'code' in err && err.code === 'EISDIR') {
|
||||
await handler.rmtree(this.path).catch(() => {})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all file paths within dir that this disk claims.
|
||||
* For a plain disk: [path]
|
||||
* For an alias: [aliasPath, resolvedDataPath]
|
||||
* If the alias target cannot be resolved, only the alias path is returned.
|
||||
*
|
||||
* @param {string} dir
|
||||
* @returns {Promise<string[]>}
|
||||
*/
|
||||
async listAssociatedFiles(dir) {
|
||||
const { handler, alias } = this
|
||||
const prefix = normalize(dir.endsWith('/') ? dir : dir + '/')
|
||||
const isInDir = /** @param {string} p */ p => p === dir || p.startsWith(prefix)
|
||||
|
||||
const files = []
|
||||
if (isInDir(this.path)) {
|
||||
files.push(this.path)
|
||||
}
|
||||
|
||||
if (alias.isAlias(this.path)) {
|
||||
try {
|
||||
const resolved = await alias.resolve(handler, this.path)
|
||||
if (isInDir(resolved)) {
|
||||
files.push(resolved)
|
||||
}
|
||||
} catch {
|
||||
// broken alias, no data file to claim
|
||||
}
|
||||
}
|
||||
|
||||
return files
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks the integrity of this disk's alias reference.
|
||||
* Only meaningful for alias files; no-op for plain disks.
|
||||
* Returns the resolved target path when the alias is valid, undefined otherwise.
|
||||
*
|
||||
* @param {Object} [opts]
|
||||
* @param {boolean} [opts.remove]
|
||||
* @param {Function} [opts.logWarn]
|
||||
* @param {Function} [opts.logInfo]
|
||||
* @returns {Promise<string | undefined>}
|
||||
*/
|
||||
async clean({ remove = false, logWarn = () => {}, logInfo = () => {} } = {}) {
|
||||
const { handler, alias } = this
|
||||
|
||||
if (!alias.isAlias(this.path)) {
|
||||
return undefined
|
||||
}
|
||||
|
||||
let target
|
||||
try {
|
||||
target = await alias.resolve(handler, this.path)
|
||||
} catch (err) {
|
||||
if (err instanceof AliasMissingError) {
|
||||
logWarn('missing target of alias', { alias: this.path })
|
||||
if (remove) {
|
||||
logInfo('removing alias with missing target', { alias: this.path })
|
||||
await handler.unlink(this.path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
if (err instanceof AliasIsDirectoryError) {
|
||||
logWarn('alias is a directory', { alias: this.path })
|
||||
if (remove) {
|
||||
logInfo('removing directory named as alias', { alias: this.path })
|
||||
await alias.unlink(handler, this.path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
logWarn('unhandled error while checking alias', { alias: this.path, err })
|
||||
return undefined
|
||||
}
|
||||
|
||||
if (target === '') {
|
||||
logWarn('empty target for alias', { alias: this.path })
|
||||
if (remove) {
|
||||
logInfo('removing alias with empty target', { alias: this.path })
|
||||
await handler.unlink(this.path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
try {
|
||||
await this.validateTarget(target)
|
||||
return target
|
||||
} catch (error) {
|
||||
if (error?.invalidTargetName) {
|
||||
logWarn('alias references an invalid target', { alias: this.path, target })
|
||||
if (remove) {
|
||||
logInfo('removing alias and invalid target', { alias: this.path, target })
|
||||
await handler.unlink(target)
|
||||
await handler.unlink(this.path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
logWarn('missing or broken alias target', { alias: this.path, target, error })
|
||||
if (remove) {
|
||||
try {
|
||||
await alias.unlink(handler, this.path)
|
||||
} catch (err) {
|
||||
if (err.code !== 'ENOENT') {
|
||||
logWarn('error deleting broken alias', { alias: this.path, target, err })
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -5,31 +5,21 @@
|
||||
* @typedef {import('vhd-lib/Vhd/VhdFile.js').VhdFile} VhdFile
|
||||
* @typedef {import('vhd-lib/_createFooterHeader.js').VhdFooter} VhdFooter
|
||||
* @typedef {import('@xen-orchestra/disk-transform').DiskBlock} DiskBlock
|
||||
* @typedef {import('@xen-orchestra/fs').RemoteHandlerAbstract} RemoteHandlerAbstract
|
||||
* @typedef {import('@xen-orchestra/disk-transform').FileAccessor} FileAccessor
|
||||
* @typedef {import('./RemoteDisk.mjs').RemoteDisk} RemoteDisk
|
||||
*
|
||||
|
||||
*/
|
||||
|
||||
import { openVhd, VhdAbstract, VhdDirectory } from 'vhd-lib'
|
||||
import { RemoteDisk } from './RemoteDisk.mjs'
|
||||
import { openVhd, VhdDirectory } from 'vhd-lib'
|
||||
import { RemotePathDisk } from './RemotePathDisk.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'
|
||||
import { RemoteVhdDiskChain } from './RemoteVhdDiskChain.mjs'
|
||||
import { normalize } from '@xen-orchestra/fs/path'
|
||||
|
||||
export class RemoteVhdDisk extends RemoteDisk {
|
||||
/**
|
||||
* @type {string}
|
||||
*/
|
||||
#path
|
||||
|
||||
/**
|
||||
* @type {RemoteHandlerAbstract}
|
||||
*/
|
||||
#handler
|
||||
|
||||
export class RemoteVhdDisk extends RemotePathDisk {
|
||||
/**
|
||||
* @type {VhdFile | VhdDirectory | undefined}
|
||||
*/
|
||||
@@ -57,14 +47,19 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
|
||||
/**
|
||||
* @param {Object} params
|
||||
* @param {RemoteHandlerAbstract} params.handler
|
||||
* @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
|
||||
super({ handler, path, extension: 'vhd' })
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {boolean}
|
||||
*/
|
||||
get isOpen() {
|
||||
return this.#vhd !== undefined
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -76,12 +71,12 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
async init(options = {}) {
|
||||
if (this.#vhd === undefined) {
|
||||
try {
|
||||
const { value, dispose } = await openVhd(this.#handler, await resolveVhdAlias(this.#handler, this.#path), {
|
||||
const { value, dispose } = await openVhd(this.handler, this.path, {
|
||||
checkSecondFooter: !options.force,
|
||||
})
|
||||
this.#vhd = value
|
||||
|
||||
if ((await this.isDirectory()) && !isVhdAlias(this.#path)) {
|
||||
if ((await this.isDirectory()) && !this.alias.isAlias(this.path)) {
|
||||
this.#vhd = undefined
|
||||
throw Object.assign(new Error("Can't init vhd directory without using alias"), { code: 'NOT_SUPPORTED' })
|
||||
}
|
||||
@@ -138,22 +133,6 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
return this.#blockSize
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {string}
|
||||
*/
|
||||
getPath() {
|
||||
return this.#path
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the disk path in an array.
|
||||
*
|
||||
* @returns {string[]}
|
||||
*/
|
||||
getPaths() {
|
||||
return [this.getPath()]
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {string}
|
||||
*/
|
||||
@@ -187,7 +166,7 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
}
|
||||
|
||||
const parentPath = this.#vhd.header.parentUnicodeName
|
||||
return normalize(join(dirname(this.#path), parentPath))
|
||||
return normalize(join(dirname(this.path), parentPath))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -236,13 +215,13 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
}
|
||||
|
||||
const parentPath = this.#vhd.header.parentUnicodeName
|
||||
const fullParentPath = normalize(join(dirname(this.#path), parentPath))
|
||||
const fullParentPath = normalize(join(dirname(this.path), parentPath))
|
||||
|
||||
if (!parentPath) {
|
||||
throw new Error(`disk ${this.#path} doesn't have parents`)
|
||||
throw new Error(`disk ${this.path} doesn't have parents`)
|
||||
}
|
||||
|
||||
const parent = new RemoteVhdDisk({ handler: this.#handler, path: fullParentPath })
|
||||
const parent = new RemoteVhdDisk({ handler: this.handler, path: fullParentPath })
|
||||
return parent
|
||||
}
|
||||
/**
|
||||
@@ -300,7 +279,7 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
(await childDisk.isDirectory())
|
||||
) {
|
||||
try {
|
||||
await this.#handler.rename(childDisk.getBlockPath(index), this.getBlockPath(index))
|
||||
await this.handler.rename(childDisk.getBlockPath(index), this.getBlockPath(index))
|
||||
|
||||
this.setAllocatedBlocks([index])
|
||||
} catch (error) {
|
||||
@@ -434,92 +413,7 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
}
|
||||
|
||||
/**
|
||||
* Rename alias/disk
|
||||
* @param {string} newPath
|
||||
*/
|
||||
async rename(newPath) {
|
||||
if (isVhdAlias(newPath)) {
|
||||
const dataPath = await resolveVhdAlias(this.#handler, this.#path)
|
||||
|
||||
await this.#handler.unlink(newPath)
|
||||
await VhdAbstract.createAlias(this.#handler, newPath, dataPath)
|
||||
await this.#handler.unlink(this.#path)
|
||||
|
||||
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
|
||||
* @param {Object} options
|
||||
*/
|
||||
async unlink({ force = false } = {}) {
|
||||
if (this.#vhd === undefined) {
|
||||
if (force) {
|
||||
let resolved = this.#path
|
||||
try {
|
||||
resolved = await resolveVhdAlias(this.#handler, this.#path)
|
||||
} catch (err) {
|
||||
// broken vhd directory must be unlinkable
|
||||
if (err.code !== 'EISDIR') {
|
||||
throw err
|
||||
}
|
||||
// warn('Deleting directly a VhdDirectory', { this.#path, err })
|
||||
}
|
||||
try {
|
||||
await this.#handler.unlink(resolved)
|
||||
} catch (err) {
|
||||
if (err.code === 'EISDIR') {
|
||||
await this.#handler.rmtree(resolved)
|
||||
} else {
|
||||
throw err
|
||||
}
|
||||
}
|
||||
|
||||
// also delete the alias file
|
||||
if (this.#path !== resolved) {
|
||||
await this.#handler.unlink(this.#path)
|
||||
}
|
||||
} else {
|
||||
throw new Error(`can't call unlink of a RemoteVhdDisk before init`)
|
||||
}
|
||||
} else {
|
||||
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.
|
||||
* Checks if the disk is a VHD directory.
|
||||
* @returns {Promise<boolean>}
|
||||
*/
|
||||
async isDirectory() {
|
||||
@@ -531,116 +425,19 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all file paths within dir that this disk claims.
|
||||
* For a plain VHD or VHD directory: [path]
|
||||
* For a VHD alias: [aliasPath, resolvedDataPath]
|
||||
* If the alias target cannot be resolved, only the alias path is returned.
|
||||
*
|
||||
* @param {string} dir
|
||||
* @returns {Promise<string[]>}
|
||||
* Throws if `target` isn't a valid, openable VHD.
|
||||
* @param {string} target
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async listAssociatedFiles(dir) {
|
||||
const prefix = normalize(dir.endsWith('/') ? dir : dir + '/')
|
||||
const isInDir = /** @param {string} p */ p => p === dir || p.startsWith(prefix)
|
||||
|
||||
const files = []
|
||||
if (isInDir(this.#path)) {
|
||||
files.push(this.#path)
|
||||
async validateTarget(target) {
|
||||
if (!this.alias.isAlias(target) && !target.endsWith('.vhd')) {
|
||||
throw Object.assign(new Error(`${target} is not a vhd target`), { invalidTargetName: true })
|
||||
}
|
||||
|
||||
if (isVhdAlias(this.#path)) {
|
||||
try {
|
||||
const resolved = await resolveVhdAlias(this.#handler, this.#path)
|
||||
if (isInDir(resolved)) {
|
||||
files.push(resolved)
|
||||
}
|
||||
} catch {
|
||||
// broken alias, no data file to claim
|
||||
}
|
||||
}
|
||||
|
||||
return files
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks the integrity of this disk's alias reference.
|
||||
* Only meaningful for alias files (.alias.vhd); no-op for plain VHDs.
|
||||
* Returns the resolved target path when the alias is valid, undefined otherwise.
|
||||
*
|
||||
* @param {Object} [opts]
|
||||
* @param {boolean} [opts.remove]
|
||||
* @param {Function} [opts.logWarn]
|
||||
* @param {Function} [opts.logInfo]
|
||||
* @returns {Promise<string | undefined>}
|
||||
*/
|
||||
async clean({ remove = false, logWarn = () => {}, logInfo = () => {} } = {}) {
|
||||
if (!isVhdAlias(this.#path)) {
|
||||
return undefined
|
||||
}
|
||||
|
||||
let target
|
||||
const { dispose } = await openVhd(this.handler, target)
|
||||
try {
|
||||
target = await resolveVhdAlias(this.#handler, this.#path)
|
||||
} catch (err) {
|
||||
if (err.code === 'ENOENT') {
|
||||
logWarn('missing target of alias', { alias: this.#path })
|
||||
if (remove) {
|
||||
logInfo('removing alias with missing target', { alias: this.#path })
|
||||
await this.#handler.unlink(this.#path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
if (err.code === 'EISDIR') {
|
||||
logWarn('alias is a vhd directory', { alias: this.#path })
|
||||
if (remove) {
|
||||
logInfo('removing vhd directory named as alias', { alias: this.#path })
|
||||
await VhdAbstract.unlink(this.#handler, this.#path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
logWarn('unhandled error while checking alias', { alias: this.#path, err })
|
||||
return undefined
|
||||
}
|
||||
|
||||
if (target === '') {
|
||||
logWarn('empty target for alias', { alias: this.#path })
|
||||
if (remove) {
|
||||
logInfo('removing alias with empty target', { alias: this.#path })
|
||||
await this.#handler.unlink(this.#path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
if (!isVhdAlias(target) && !target.endsWith('.vhd')) {
|
||||
logWarn('alias references non VHD target', { alias: this.#path, target })
|
||||
if (remove) {
|
||||
logInfo('removing alias and non VHD target', { alias: this.#path, target })
|
||||
await this.#handler.unlink(target)
|
||||
await this.#handler.unlink(this.#path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
try {
|
||||
const { dispose } = await openVhd(this.#handler, target)
|
||||
try {
|
||||
await dispose()
|
||||
} catch (_) {
|
||||
// errors during dispose should not trigger deletion
|
||||
}
|
||||
return target
|
||||
} catch (error) {
|
||||
logWarn('missing or broken alias target', { alias: this.#path, target, error })
|
||||
if (remove) {
|
||||
try {
|
||||
await VhdAbstract.unlink(this.#handler, this.#path)
|
||||
} catch (/** @type {any} */ err) {
|
||||
if (err.code !== 'ENOENT') {
|
||||
logWarn('error deleting broken alias', { alias: this.#path, target, err })
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
await dispose()
|
||||
} catch (_) {
|
||||
// errors during dispose should not trigger deletion
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -312,12 +312,4 @@ export class RemoteVhdDiskChain extends RemoteDisk {
|
||||
async clean(opts = {}) {
|
||||
throw new Error(`Can't clean a disk chain`)
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @returns {RemoteVhdDisk|undefined}
|
||||
*/
|
||||
getRootDisk() {
|
||||
return this.#disks[0]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
"bugs": "https://github.com/vatesfr/xen-orchestra/issues",
|
||||
"dependencies": {
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@xen-orchestra/async-map": "^0.1.4",
|
||||
"@xen-orchestra/backups": "^0.74.2",
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/async-map": "^0.1.3",
|
||||
"@xen-orchestra/backups": "^0.73.7",
|
||||
"@xen-orchestra/fs": "^4.9.2",
|
||||
"filenamify": "^6.0.0",
|
||||
"getopts": "^2.2.5",
|
||||
"lodash": "^4.18.0",
|
||||
@@ -28,7 +28,7 @@
|
||||
"scripts": {
|
||||
"postversion": "npm publish --access public"
|
||||
},
|
||||
"version": "1.1.14",
|
||||
"version": "1.1.13",
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"author": {
|
||||
"name": "Vates SAS",
|
||||
|
||||
@@ -315,11 +315,6 @@ export class RemoteAdapter {
|
||||
fn(cache)
|
||||
|
||||
await this._writeCache(path, cache)
|
||||
} else {
|
||||
const regenerated = await this.#getCacheableDataListVmBackups(dirname(path))
|
||||
if (regenerated !== undefined) {
|
||||
await this._writeCache(path, regenerated)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -388,7 +383,8 @@ export class RemoteAdapter {
|
||||
return
|
||||
}
|
||||
|
||||
await this._writeCache(path, backups)
|
||||
// detached async action, will not reject
|
||||
this._writeCache(path, backups)
|
||||
|
||||
return backups
|
||||
}
|
||||
@@ -453,7 +449,7 @@ export class RemoteAdapter {
|
||||
return path
|
||||
}
|
||||
|
||||
async writeVhd(path, disk, { validator = noop, writeBlockConcurrency, uuid, parentUuid, parentPath } = {}) {
|
||||
async writeVhd(path, disk, { validator = noop, writeBlockConcurrency } = {}) {
|
||||
const handler = this._handler
|
||||
|
||||
if (this.useVhdDirectory()) {
|
||||
@@ -465,19 +461,11 @@ export class RemoteAdapter {
|
||||
concurrency: writeBlockConcurrency,
|
||||
validator,
|
||||
compression: 'brotli',
|
||||
uuid,
|
||||
parentUuid,
|
||||
parentPath,
|
||||
},
|
||||
})
|
||||
} else {
|
||||
const stream = await toVhdStream(disk, { uuid, parentUuid, parentPath })
|
||||
const size = await this.outputStream(path, stream, {
|
||||
validator,
|
||||
// no checksum for VHDs, because they will be invalidated by
|
||||
// merges and chains
|
||||
checksum: false,
|
||||
})
|
||||
const stream = await toVhdStream(disk)
|
||||
const size = await this.outputStream(path, stream, { validator, checksum: false })
|
||||
await validator(path)
|
||||
return size
|
||||
}
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
import { strict as assert } from 'node:assert'
|
||||
import test from 'node:test'
|
||||
import { execFile } from 'node:child_process'
|
||||
import { copyFile, mkdtemp, rm, writeFile } from 'node:fs/promises'
|
||||
import { Stream } from 'node:stream'
|
||||
import { copyFile, mkdtemp, rm } from 'node:fs/promises'
|
||||
import { tmpdir } from 'node:os'
|
||||
import { join } from 'node:path'
|
||||
import { promisify } from 'node:util'
|
||||
@@ -40,37 +39,6 @@ async function createLvmImage(imagePath, vgName, lvName) {
|
||||
})
|
||||
}
|
||||
|
||||
// xo-proxy answers this stream through Koa, which pipes only bodies passing `instanceof Stream`
|
||||
// and JSON-serializes anything else: node-tar >= 7 returns a duck-typed (Minipass) stream, which
|
||||
// silently turned a proxied file restore into a JSON dump of the tar object. Every format must
|
||||
// resolve with a real node stream.
|
||||
test('fetchPartitionFiles resolves with a node:stream for every format', async t => {
|
||||
const tmp = await mkdtemp(join(tmpdir(), 'xo-flr-fetch-'))
|
||||
t.after(() => rm(tmp, { recursive: true, force: true }))
|
||||
await writeFile(join(tmp, 'file.txt'), 'hello')
|
||||
|
||||
const adapter = new RemoteAdapter({})
|
||||
// at this point of a real restore the partition is already mounted
|
||||
adapter.getPartition = Disposable.factory(async function* () {
|
||||
yield tmp
|
||||
})
|
||||
|
||||
for (const [format, magic] of [
|
||||
['tgz', Buffer.from([0x1f, 0x8b])],
|
||||
['zip', Buffer.from('PK')],
|
||||
]) {
|
||||
const stream = await adapter.fetchPartitionFiles('disk', 'partition', ['/file.txt'], format)
|
||||
assert.ok(stream instanceof Stream, `${format}: expected a node:stream instance`)
|
||||
|
||||
const chunks = []
|
||||
for await (const chunk of stream) {
|
||||
chunks.push(chunk)
|
||||
}
|
||||
const archive = Buffer.concat(chunks)
|
||||
assert.deepEqual(archive.subarray(0, magic.length), magic, `${format}: unexpected archive header`)
|
||||
}
|
||||
})
|
||||
|
||||
test('LVM file-restore against real losetup/dmsetup/lvm', { skip }, async t => {
|
||||
const tmp = await mkdtemp(join(tmpdir(), 'xo-flr-'))
|
||||
const adapter = new RemoteAdapter({})
|
||||
|
||||
@@ -12,7 +12,6 @@ import { compose } from '@vates/compose'
|
||||
import { createLogger } from '@xen-orchestra/log'
|
||||
import { deduped } from '@vates/disposable/deduped.js'
|
||||
import { randomBytes } from 'node:crypto'
|
||||
import { Readable } from 'node:stream'
|
||||
import { join, resolve } from 'node:path'
|
||||
import { execFile } from 'child_process'
|
||||
import { finished } from 'node:stream/promises'
|
||||
@@ -298,15 +297,7 @@ export const fileRestoreMethods = {
|
||||
// simultaneous reads. Those saturate the libuv threadpool and starve
|
||||
// the underlying vhd/CIFS reads NTFS-3g depends on (FUSE-on-FUSE
|
||||
// threadpool deadlock). Serializing keeps a worker free for them.
|
||||
const pack = tar.c({ cwd: path, gzip: true, jobs: 1 }, paths.map(makeRelative))
|
||||
|
||||
// node-tar >= 7 returns a Minipass stream: it has `pipe()` but is not a `node:stream`
|
||||
// instance. xo-proxy serves this stream through Koa, which pipes only bodies passing
|
||||
// `instanceof Stream` and JSON-serializes anything else — so a file restore through a
|
||||
// proxy answered a JSON dump of the tar object instead of the archive. Wrapping it in a
|
||||
// real node stream also propagates tar errors to the consumer and aborts the tar job
|
||||
// when the client disconnects.
|
||||
outputStream = Readable.from(pack, { objectMode: false })
|
||||
outputStream = tar.c({ cwd: path, gzip: true, jobs: 1 }, paths.map(makeRelative))
|
||||
resolve(outputStream)
|
||||
} else if (format === 'zip') {
|
||||
const zip = new ZipFile()
|
||||
|
||||
@@ -16,15 +16,42 @@ import { toQcow2Stream } from '@xen-orchestra/qcow2'
|
||||
|
||||
const ensureArray = value => (value === undefined ? [] : Array.isArray(value) ? value : [value])
|
||||
|
||||
// The dynamic memory range MUST respect this inequality at any moment: static_min <= dynamic_min <= dynamic_max <= static_max.
|
||||
// VM.set_memory_limits sets all four fields atomically, so there is no intermediate state for XAPI to reject
|
||||
export async function updateMemoryFields(xapi, targetVm, vmRecord) {
|
||||
const staticMin = vmRecord.memory_static_min ?? targetVm.memory_static_min
|
||||
const staticMax = vmRecord.memory_static_max ?? targetVm.memory_static_max
|
||||
const dynamicMin = vmRecord.memory_dynamic_min ?? targetVm.memory_dynamic_min
|
||||
const dynamicMax = vmRecord.memory_dynamic_max ?? targetVm.memory_dynamic_max
|
||||
const orderedMemoryLimits = ['memory_static_min', 'memory_dynamic_min', 'memory_dynamic_max', 'memory_static_max']
|
||||
|
||||
await xapi.call('VM.set_memory_limits', targetVm.$ref, staticMin, staticMax, dynamicMin, dynamicMax)
|
||||
// The dynamic memory range MUST respect this inequality at any moment: static_min <= dynamic_min <= dynamic_max <= static_max.
|
||||
// We must update these properties in the right order to avoid XAPI error.
|
||||
// The order depends on the values. It can be an increase, a decrease or a mix of both, so any order could be required.
|
||||
export async function updateMemoryFields(xapi, targetVm, vmRecord) {
|
||||
const memoryValues = {}
|
||||
for (const key of orderedMemoryLimits) {
|
||||
memoryValues[key] = {
|
||||
currentValue: targetVm[key],
|
||||
newValue: vmRecord[key] ?? targetVm[key],
|
||||
}
|
||||
}
|
||||
|
||||
while (await updateNextMemoryField(xapi, memoryValues, targetVm.$ref)) {
|
||||
/* execute until all memory fields are updated */
|
||||
}
|
||||
}
|
||||
|
||||
// Update one more memory field if needed, then return a boolean describing if a field was updated or if all fields are up to date
|
||||
async function updateNextMemoryField(xapi, memoryValues, vmRef) {
|
||||
for (let i = 0; i < orderedMemoryLimits.length; i++) {
|
||||
const currentField = memoryValues[orderedMemoryLimits[i]]
|
||||
const nextField = i === orderedMemoryLimits.length - 1 ? undefined : memoryValues[orderedMemoryLimits[i + 1]]
|
||||
if (
|
||||
currentField.newValue !== currentField.currentValue &&
|
||||
(nextField === undefined || currentField.newValue <= nextField.currentValue)
|
||||
) {
|
||||
// no need to check that previousField.currentValue <= currentField.newValue, as we can deduce it
|
||||
await xapi.setField('VM', vmRef, orderedMemoryLimits[i], currentField.newValue)
|
||||
await xapi.barrier()
|
||||
currentField.currentValue = currentField.newValue
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
export async function exportIncrementalVm(
|
||||
|
||||
122
@xen-orchestra/backups/_incrementalVm.test.mjs
Normal file
122
@xen-orchestra/backups/_incrementalVm.test.mjs
Normal file
@@ -0,0 +1,122 @@
|
||||
import { describe, it } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
|
||||
import { updateMemoryFields } from './_incrementalVm.mjs'
|
||||
|
||||
const MOCK_REF = 'mockRef'
|
||||
|
||||
function mockXapiVm(initialMemoryValues) {
|
||||
const res = {
|
||||
...initialMemoryValues,
|
||||
updates: [],
|
||||
barrier: () => {},
|
||||
setField: (type, ref, field, value) => {
|
||||
assert(type === 'VM')
|
||||
assert(ref === MOCK_REF)
|
||||
res.updates.push({ field, value })
|
||||
res[field] = value
|
||||
assert(res.memory_static_min <= res.memory_dynamic_min)
|
||||
assert(res.memory_dynamic_min <= res.memory_dynamic_max)
|
||||
assert(res.memory_dynamic_max <= res.memory_static_max)
|
||||
},
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
const tests = [
|
||||
{
|
||||
label: 'handles a memory increase',
|
||||
targetVm: {
|
||||
memory_static_min: 2,
|
||||
memory_dynamic_min: 4,
|
||||
memory_dynamic_max: 4,
|
||||
memory_static_max: 8,
|
||||
},
|
||||
vmRecord: {
|
||||
memory_static_min: 16,
|
||||
memory_dynamic_min: 16,
|
||||
memory_dynamic_max: 16,
|
||||
memory_static_max: 16,
|
||||
},
|
||||
expectedUpdates: [
|
||||
{ field: 'memory_static_max', value: 16 },
|
||||
{ field: 'memory_dynamic_max', value: 16 },
|
||||
{ field: 'memory_dynamic_min', value: 16 },
|
||||
{ field: 'memory_static_min', value: 16 },
|
||||
],
|
||||
},
|
||||
{
|
||||
label: 'handles a memory decrease',
|
||||
targetVm: {
|
||||
memory_static_min: 4,
|
||||
memory_dynamic_min: 8,
|
||||
memory_dynamic_max: 16,
|
||||
memory_static_max: 16,
|
||||
},
|
||||
vmRecord: {
|
||||
memory_static_min: 2,
|
||||
memory_dynamic_min: 2,
|
||||
memory_dynamic_max: 2,
|
||||
memory_static_max: 2,
|
||||
},
|
||||
expectedUpdates: [
|
||||
{ field: 'memory_static_min', value: 2 },
|
||||
{ field: 'memory_dynamic_min', value: 2 },
|
||||
{ field: 'memory_dynamic_max', value: 2 },
|
||||
{ field: 'memory_static_max', value: 2 },
|
||||
],
|
||||
},
|
||||
{
|
||||
label: 'handles a more complex case',
|
||||
targetVm: {
|
||||
memory_static_min: 1,
|
||||
memory_dynamic_min: 2,
|
||||
memory_dynamic_max: 8,
|
||||
memory_static_max: 16,
|
||||
},
|
||||
vmRecord: {
|
||||
memory_static_min: 4,
|
||||
memory_dynamic_min: 4,
|
||||
memory_dynamic_max: 4,
|
||||
memory_static_max: 4,
|
||||
},
|
||||
expectedUpdates: [
|
||||
{ field: 'memory_dynamic_min', value: 4 },
|
||||
{ field: 'memory_static_min', value: 4 },
|
||||
{ field: 'memory_dynamic_max', value: 4 },
|
||||
{ field: 'memory_static_max', value: 4 },
|
||||
],
|
||||
},
|
||||
{
|
||||
label: 'avoids updating identical value',
|
||||
targetVm: {
|
||||
memory_static_min: 1,
|
||||
memory_dynamic_min: 2,
|
||||
memory_dynamic_max: 4,
|
||||
memory_static_max: 8,
|
||||
},
|
||||
vmRecord: {
|
||||
memory_static_min: 1,
|
||||
memory_dynamic_min: 2,
|
||||
memory_dynamic_max: 4,
|
||||
memory_static_max: 8,
|
||||
},
|
||||
expectedUpdates: [],
|
||||
},
|
||||
]
|
||||
|
||||
describe('updateMemoryFields() should update in the right order', () => {
|
||||
for (const test of tests) {
|
||||
it(test.label, async () => {
|
||||
const mock = mockXapiVm(test.targetVm)
|
||||
test.targetVm.$ref = MOCK_REF
|
||||
await updateMemoryFields(mock, test.targetVm, test.vmRecord)
|
||||
|
||||
assert.equal(mock.updates.length, test.expectedUpdates.length)
|
||||
for (let i = 0; i < mock.updates.length; i++) {
|
||||
assert.equal(mock.updates[i].value, test.expectedUpdates[i].value)
|
||||
assert.equal(mock.updates[i].field, test.expectedUpdates[i].field)
|
||||
}
|
||||
})
|
||||
}
|
||||
})
|
||||
@@ -33,13 +33,6 @@ export const VM_UUID = 'xo:backup:vm'
|
||||
// allows direction-agnostic discovery of common base VDIs (e.g. for failback/reverse replication)
|
||||
export const CONTENT_KEY = 'xo:backup:contentKey'
|
||||
|
||||
// in `other_config` of a replicated VM and its VDIs
|
||||
// set to the string 'true' on every write done by code that includes the non-NBD qcow2
|
||||
// corruption fix (fix(disk-transform): erroneous DiskLargerBlock copy offset). Its absence
|
||||
// on a qcow2 full means the replica may be silently corrupt and its chain must be re-based
|
||||
// with a clean full. Named after the specific fix so future fixes get their own flag.
|
||||
export const INCLUDE_NON_NBD_QCOW2_FIX = 'xo:backup:includeNonNbdQcow2Fix'
|
||||
|
||||
async function listVdiRefs(xapi, vmRef) {
|
||||
return xapi.VM_getDisks(vmRef)
|
||||
}
|
||||
@@ -97,7 +90,6 @@ export function resetVmOtherConfig(xapi, vmRef) {
|
||||
[DATETIME]: null,
|
||||
[DELTA_CHAIN_LENGTH]: null,
|
||||
[EXPORTED_SUCCESSFULLY]: null,
|
||||
[INCLUDE_NON_NBD_QCOW2_FIX]: null,
|
||||
[JOB_ID]: null,
|
||||
[SCHEDULE_ID]: null,
|
||||
[VM_UUID]: null,
|
||||
@@ -128,10 +120,6 @@ export async function setVmOtherConfig(xapi, vmRef, { timestamp, jobId, schedule
|
||||
xapi.setFieldEntries(type, ref, 'other_config', {
|
||||
[REPLICATED_TO_SR_UUID]: srUuid,
|
||||
[DATETIME]: formatDateTime(timestamp),
|
||||
// stamped on every write: its presence marks the object as produced by code
|
||||
// that includes the non-NBD qcow2 corruption fix, so a chain rooted in a pre-fix
|
||||
// qcow2 full (missing this flag) can be detected and re-based with a clean full
|
||||
[INCLUDE_NON_NBD_QCOW2_FIX]: 'true',
|
||||
[JOB_ID]: jobId,
|
||||
[SCHEDULE_ID]: scheduleId,
|
||||
[VM_UUID]: vmUuid,
|
||||
|
||||
@@ -9,9 +9,7 @@ import { getAdaptersByRemote } from './_getAdaptersByRemote.mjs'
|
||||
import { IncrementalXapi } from './_vmRunners/IncrementalXapi.mjs'
|
||||
import { FullXapi } from './_vmRunners/FullXapi.mjs'
|
||||
import { Throttle } from '@vates/generator-toolbox'
|
||||
import { asyncEach } from '@vates/async-each'
|
||||
import createStreamThrottle from './_createStreamThrottle.mjs'
|
||||
import { selectSynchronizedSnapshotVms } from './_selectSynchronizedSnapshotVms.mjs'
|
||||
|
||||
const noop = Function.prototype
|
||||
|
||||
@@ -33,9 +31,7 @@ const DEFAULT_XAPI_VM_SETTINGS = {
|
||||
nRetriesVmBackupFailures: 0,
|
||||
offlineBackup: false,
|
||||
offlineSnapshot: false,
|
||||
snapshotConcurrency: 2,
|
||||
snapshotRetention: 0,
|
||||
synchronizedSnapshot: false,
|
||||
timeout: 0,
|
||||
useNbd: false,
|
||||
unconditionalSnapshot: false,
|
||||
@@ -51,16 +47,6 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
|
||||
return baseSettings
|
||||
}
|
||||
|
||||
_getVmBackup(jobMode, opts) {
|
||||
if (jobMode === 'delta') {
|
||||
return new IncrementalXapi(opts)
|
||||
} else if (jobMode === 'full') {
|
||||
return new FullXapi(opts)
|
||||
}
|
||||
|
||||
throw new Error(`Job mode ${jobMode} not implemented`)
|
||||
}
|
||||
|
||||
async run() {
|
||||
const job = this._job
|
||||
|
||||
@@ -109,81 +95,7 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
|
||||
const allSettings = this._job.settings
|
||||
const baseSettings = this._baseSettings
|
||||
|
||||
const preTakenTimestampByVmId = {}
|
||||
const failedSnapshotByVmId = {}
|
||||
if (settings.synchronizedSnapshot) {
|
||||
await Task.run({ properties: { name: 'snapshot VMs' } }, async () => {
|
||||
await Disposable.use(
|
||||
Disposable.all(vmIds.map(vmId => this._getRecord('VM', vmId).catch(noop))),
|
||||
async vms => {
|
||||
// remove vms that failed (already handled)
|
||||
vms = vms.filter(_ => _ !== undefined)
|
||||
|
||||
const batchIds = selectSynchronizedSnapshotVms(settings.synchronizedSnapshot, vms)
|
||||
|
||||
await asyncEach(
|
||||
[...vms].filter(vm => batchIds.has(vm.uuid)),
|
||||
async vm => {
|
||||
const vmSettings = { ...settings, ...allSettings[vm.uuid] }
|
||||
const opts = {
|
||||
baseSettings,
|
||||
config,
|
||||
getSnapshotNameLabel,
|
||||
healthCheckSr,
|
||||
job,
|
||||
remoteAdapters,
|
||||
schedule,
|
||||
settings: vmSettings,
|
||||
srs,
|
||||
throttleGenerator,
|
||||
throttleStream,
|
||||
vm,
|
||||
}
|
||||
|
||||
let vmBackup
|
||||
try {
|
||||
vmBackup = this._getVmBackup(job.mode, opts)
|
||||
if (
|
||||
!vmBackup._settings.offlineBackup &&
|
||||
!vmBackup._settings.offlineSnapshot &&
|
||||
(await vmBackup._mustDoSnapshot())
|
||||
) {
|
||||
await vmBackup._prepareAndSnapshot()
|
||||
preTakenTimestampByVmId[vm.uuid] = vmBackup.timestamp
|
||||
}
|
||||
} catch (error) {
|
||||
failedSnapshotByVmId[vm.uuid] = error
|
||||
if (vmBackup !== undefined) {
|
||||
try {
|
||||
await vmBackup._fetchJobSnapshots()
|
||||
await vmBackup._removeUnusedSnapshots()
|
||||
await vmBackup._cleanMetadata()
|
||||
} catch (cleanupError) {
|
||||
// Best effort cleanup
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
concurrency: settings.snapshotConcurrency,
|
||||
}
|
||||
)
|
||||
}
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
const snapshotedVmIds = new Set(vmIds.filter(id => !(id in failedSnapshotByVmId)))
|
||||
Object.entries(failedSnapshotByVmId).forEach(([vmId, error]) => {
|
||||
Task.run(
|
||||
{
|
||||
properties: { id: vmId, name: 'backup VM', type: 'VM' },
|
||||
},
|
||||
() => Promise.reject(error)
|
||||
).catch(noop)
|
||||
})
|
||||
|
||||
const queue = new Set(snapshotedVmIds)
|
||||
const queue = new Set(vmIds)
|
||||
const taskByVmId = {}
|
||||
const nTriesByVmId = {}
|
||||
|
||||
@@ -243,16 +155,21 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
|
||||
schedule,
|
||||
settings: vmSettings,
|
||||
srs,
|
||||
// when set, the batch phase already snapshotted this VM; the
|
||||
// runner re-finds that snapshot by its metadata (see _snapshot)
|
||||
synchronizedSnapshotTimestamp: preTakenTimestampByVmId[vmUuid],
|
||||
throttleGenerator,
|
||||
throttleStream,
|
||||
vm,
|
||||
}
|
||||
|
||||
const vmBackup = this._getVmBackup(job.mode, opts)
|
||||
|
||||
let vmBackup
|
||||
if (job.mode === 'delta') {
|
||||
vmBackup = new IncrementalXapi(opts)
|
||||
} else {
|
||||
if (job.mode === 'full') {
|
||||
vmBackup = new FullXapi(opts)
|
||||
} else {
|
||||
throw new Error(`Job mode ${job.mode} not implemented`)
|
||||
}
|
||||
}
|
||||
return vmBackup.run().catch(error => {
|
||||
taskError = error
|
||||
})
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
import { Task } from '@vates/task'
|
||||
|
||||
export function selectSynchronizedSnapshotVms(synchronizedSnapshot, vms) {
|
||||
if (synchronizedSnapshot === false) {
|
||||
return new Set()
|
||||
}
|
||||
|
||||
let matches
|
||||
if (typeof synchronizedSnapshot === 'string') {
|
||||
matches = vms.filter(vm => vm.tags.includes(synchronizedSnapshot))
|
||||
} else if (synchronizedSnapshot === true) {
|
||||
matches = vms
|
||||
} else {
|
||||
Task.warning('unsupported synchronizedSnapshot option, expected a boolean or a tag name', { synchronizedSnapshot })
|
||||
return new Set()
|
||||
}
|
||||
|
||||
return new Set(matches.map(vm => vm.uuid))
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
import { describe, it } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
|
||||
import { selectSynchronizedSnapshotVms } from './_selectSynchronizedSnapshotVms.mjs'
|
||||
|
||||
// Helper mirroring the minimal VM record shape the selector needs.
|
||||
const vm = (uuid, tags = []) => ({ uuid, tags })
|
||||
|
||||
// `selectSynchronizedSnapshotVms(synchronizedSnapshot, vms)` must return a Set
|
||||
// of the UUIDs that should be snapshotted together in the batch phase.
|
||||
// - false -> feature off, no VM is batched
|
||||
// - true -> every VM is batched, regardless of tags
|
||||
// - '<tagName>' -> only VMs carrying that exact tag are batched
|
||||
const tests = [
|
||||
{
|
||||
label: 'false disables batching',
|
||||
setting: false,
|
||||
vms: [vm('a', ['prod']), vm('b')],
|
||||
expected: [],
|
||||
},
|
||||
{
|
||||
label: 'true batches every VM regardless of tags',
|
||||
setting: true,
|
||||
vms: [vm('a', ['prod']), vm('b')],
|
||||
expected: ['a', 'b'],
|
||||
},
|
||||
{
|
||||
label: 'tag batches only the VMs carrying it',
|
||||
setting: 'prod',
|
||||
vms: [vm('a', ['prod']), vm('b', ['dev']), vm('c', ['prod', 'other'])],
|
||||
expected: ['a', 'c'],
|
||||
},
|
||||
{
|
||||
label: 'tag carried by no VM yields an empty batch',
|
||||
setting: 'prod',
|
||||
vms: [vm('a', ['dev']), vm('b')],
|
||||
expected: [],
|
||||
},
|
||||
{
|
||||
label: 'tag carried by every VM batches all of them',
|
||||
setting: 'prod',
|
||||
vms: [vm('a', ['prod']), vm('b', ['prod'])],
|
||||
expected: ['a', 'b'],
|
||||
},
|
||||
{
|
||||
label: 'empty VM list yields an empty batch',
|
||||
setting: true,
|
||||
vms: [],
|
||||
expected: [],
|
||||
},
|
||||
{
|
||||
label: 'empty-string tag matches no VM when none carries an empty tag',
|
||||
setting: '',
|
||||
vms: [vm('a', ['prod'])],
|
||||
expected: [],
|
||||
},
|
||||
{
|
||||
label: 'non boolean or string yiels an empty batch',
|
||||
setting: 1,
|
||||
vms: [vm('a', ['prod'])],
|
||||
expected: [],
|
||||
},
|
||||
]
|
||||
|
||||
describe('selectSynchronizedSnapshotVms()', () => {
|
||||
for (const { label, setting, vms, expected } of tests) {
|
||||
it(label, () => {
|
||||
const result = selectSynchronizedSnapshotVms(setting, vms)
|
||||
assert.ok(result instanceof Set, 'result must be a Set')
|
||||
assert.deepEqual([...result].sort(), [...expected].sort())
|
||||
})
|
||||
}
|
||||
})
|
||||
@@ -80,14 +80,14 @@ export const FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
|
||||
|
||||
const sizeContainer = watchStreamSize(stream)
|
||||
|
||||
const transferStart = Date.now()
|
||||
const timestamp = Date.now()
|
||||
await this._callWriters(
|
||||
writer =>
|
||||
writer.run({
|
||||
maxStreamLength,
|
||||
sizeContainer,
|
||||
stream: forkStreamUnpipe(stream),
|
||||
timestamp: this.timestamp,
|
||||
timestamp,
|
||||
vm,
|
||||
vmSnapshot: exportedVm,
|
||||
}),
|
||||
@@ -95,7 +95,8 @@ export const FullXapi = class FullXapiVmBackupRunner extends AbstractXapi {
|
||||
)
|
||||
|
||||
const { size } = sizeContainer
|
||||
const duration = Date.now() - transferStart
|
||||
const end = Date.now()
|
||||
const duration = end - timestamp
|
||||
debug('transfer complete', {
|
||||
duration,
|
||||
speed: duration !== 0 ? (size * 1e3) / 1024 / 1024 / duration : 0,
|
||||
|
||||
@@ -99,7 +99,6 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
|
||||
writer =>
|
||||
writer.transfer({
|
||||
deltaExport: forkDeltaExport(incrementalExport, writer.constructor.name),
|
||||
includeNonNbdQcow2Fix: metadata.includeNonNbdQcow2Fix,
|
||||
isVhdDifferencing,
|
||||
timestamp: metadata.timestamp,
|
||||
vm: metadata.vm,
|
||||
@@ -107,6 +106,16 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
|
||||
}),
|
||||
'writer.transfer()'
|
||||
)
|
||||
// this will update parent name with the needed alias
|
||||
await this._callWriters(
|
||||
writer =>
|
||||
writer.updateUuidAndChain({
|
||||
isVhdDifferencing,
|
||||
timestamp: metadata.timestamp,
|
||||
vdis: incrementalExport.vdis,
|
||||
}),
|
||||
'writer.updateUuidAndChain()'
|
||||
)
|
||||
|
||||
await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
|
||||
// for healthcheck
|
||||
|
||||
@@ -13,6 +13,7 @@ import {
|
||||
DELTA_CHAIN_LENGTH,
|
||||
EXPORTED_SUCCESSFULLY,
|
||||
setVmDeltaChainLength,
|
||||
markExportSuccessfull,
|
||||
} from '../../_otherConfig.mjs'
|
||||
import { ThrottledDisk, SynchronizedDisk } from '@xen-orchestra/disk-transform'
|
||||
import { AggregatedIncrementalRemoteWriter } from '../_writers/AggregatedIncrementalRemoteWriter.mjs'
|
||||
@@ -67,21 +68,27 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
|
||||
|
||||
// @todo : reimplement throttle
|
||||
|
||||
const timestamp = Date.now()
|
||||
await this._callWriters(
|
||||
writer =>
|
||||
writer.transfer({
|
||||
deltaExport: forkDeltaExport(deltaExport, writer.constructor.name),
|
||||
// freshly exported from XAPI by code that has the fix and the force-full gate
|
||||
// (writer.checkBaseVdis ran before this transfer), so the chain is verified/forced
|
||||
// clean; the tip's flag lets the next run skip re-probing
|
||||
includeNonNbdQcow2Fix: true,
|
||||
isVhdDifferencing,
|
||||
timestamp: this.timestamp,
|
||||
timestamp,
|
||||
vm,
|
||||
vmSnapshot: exportedVm,
|
||||
}),
|
||||
'writer.transfer()'
|
||||
)
|
||||
await this._callWriters(
|
||||
writer =>
|
||||
writer.updateUuidAndChain({
|
||||
isVhdDifferencing,
|
||||
timestamp,
|
||||
vdis: deltaExport.vdis,
|
||||
}),
|
||||
'writer.updateUuidAndChain()'
|
||||
)
|
||||
|
||||
if (isFull) {
|
||||
await setVmDeltaChainLength(this._xapi, exportedVm.$ref, 0)
|
||||
@@ -89,6 +96,11 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
|
||||
await setVmDeltaChainLength(this._xapi, exportedVm.$ref, (this._deltaChainLength ?? 0) + 1)
|
||||
}
|
||||
|
||||
// not the case if offlineBackup
|
||||
if (exportedVm.is_a_snapshot) {
|
||||
await markExportSuccessfull(this._xapi, exportedVm.$ref)
|
||||
}
|
||||
|
||||
await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
|
||||
}
|
||||
|
||||
|
||||
@@ -7,7 +7,6 @@ import { asyncEach } from '@vates/async-each'
|
||||
import { decorateMethodsWith } from '@vates/decorate-with'
|
||||
import { defer } from 'golike-defer'
|
||||
import { Task } from '@vates/task'
|
||||
import { formatDateTime } from '@xen-orchestra/xapi'
|
||||
|
||||
import { getOldEntries } from '../../_getOldEntries.mjs'
|
||||
import { Abstract } from './_Abstract.mjs'
|
||||
@@ -17,11 +16,9 @@ import {
|
||||
JOB_ID,
|
||||
SCHEDULE_ID,
|
||||
VM_UUID,
|
||||
EXPORTED_SUCCESSFULLY,
|
||||
resetVmOtherConfig,
|
||||
setVmOtherConfig,
|
||||
setVmSnapshotContentKeys,
|
||||
markExportSuccessfull,
|
||||
} from '../../_otherConfig.mjs'
|
||||
|
||||
const { warn, info } = createLogger('xo:backups:AbstractXapi')
|
||||
@@ -39,7 +36,6 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
schedule,
|
||||
settings,
|
||||
srs,
|
||||
synchronizedSnapshotTimestamp,
|
||||
throttleGenerator,
|
||||
throttleStream,
|
||||
vm,
|
||||
@@ -67,9 +63,9 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
|
||||
// VM (snapshot) that is really exported
|
||||
this._exportedVm = undefined
|
||||
this._synchronizedSnapshotTimestamp = synchronizedSnapshotTimestamp
|
||||
this._vm = vm
|
||||
|
||||
this._baseVdis = undefined
|
||||
this._getSnapshotNameLabel = getSnapshotNameLabel
|
||||
this._isIncremental = job.mode === 'delta'
|
||||
this._healthCheckSr = healthCheckSr
|
||||
@@ -184,27 +180,6 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
}
|
||||
|
||||
async _snapshot() {
|
||||
if (this._synchronizedSnapshotTimestamp !== undefined) {
|
||||
const datetime = formatDateTime(this._synchronizedSnapshotTimestamp)
|
||||
const candidates = this._vm.$snapshots.filter(
|
||||
snapshot =>
|
||||
snapshot?.other_config[JOB_ID] === this._jobId &&
|
||||
snapshot?.other_config[DATETIME] === datetime &&
|
||||
!snapshot.other_config[EXPORTED_SUCCESSFULLY]
|
||||
)
|
||||
if (candidates.length === 1) {
|
||||
this._exportedVm = candidates[0]
|
||||
this.timestamp = this._synchronizedSnapshotTimestamp
|
||||
return
|
||||
}
|
||||
|
||||
warn('expected exactly one synchronized snapshot to reuse, taking a fresh one', {
|
||||
vm: this._vm.uuid,
|
||||
datetime,
|
||||
count: candidates.length,
|
||||
})
|
||||
}
|
||||
|
||||
const vm = this._vm
|
||||
const xapi = this._xapi
|
||||
|
||||
@@ -421,20 +396,7 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
await xapi.barrier()
|
||||
// ensure cached object are up to date
|
||||
this._jobSnapshotVdis = this._jobSnapshotVdis.map(vdi => xapi.getObject(vdi.$ref))
|
||||
let disklessVmSnapshots = this._disklessJobSnapshotVms.map(vm => xapi.getObject(vm.$ref))
|
||||
|
||||
// The synchronized snapshot for this run is taken up-front by the batch
|
||||
// phase but transferred later. Until it has been exported, hide it from
|
||||
// retention so it is neither reclaimed nor allowed to steal the delta
|
||||
// base's "most recent" protection. This makes the pre-transfer pass behave
|
||||
// like a normal run, where the snapshot does not exist yet.
|
||||
if (this._synchronizedSnapshotTimestamp !== undefined) {
|
||||
const datetime = formatDateTime(this._synchronizedSnapshotTimestamp)
|
||||
const isInFlightSyncSnapshot = ({ other_config }) =>
|
||||
other_config[DATETIME] === datetime && !other_config[EXPORTED_SUCCESSFULLY]
|
||||
this._jobSnapshotVdis = this._jobSnapshotVdis.filter(vdi => !isInFlightSyncSnapshot(vdi))
|
||||
disklessVmSnapshots = disklessVmSnapshots.filter(vm => !isInFlightSyncSnapshot(vm))
|
||||
}
|
||||
const disklessVmSnapshots = this._disklessJobSnapshotVms.map(vm => xapi.getObject(vm.$ref))
|
||||
|
||||
// get the datetime of the most recent snapshot across both VDI and diskless VM snapshots
|
||||
const lastSnapshotDateTime = [...this._jobSnapshotVdis, ...disklessVmSnapshots]
|
||||
@@ -502,7 +464,6 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
vm = vdiVm
|
||||
}
|
||||
}
|
||||
|
||||
if (vm?.$ref !== undefined) {
|
||||
return xapi.VM_destroy(vm.$ref)
|
||||
} else {
|
||||
@@ -532,7 +493,6 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
if (this.job.mode === 'delta' && datetime === lastSnapshotDateTime) {
|
||||
return
|
||||
}
|
||||
|
||||
await xapi.VM_destroy(snapshotPerDatetime[datetime])
|
||||
})
|
||||
})
|
||||
@@ -591,11 +551,6 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
throw new Error('Not implemented')
|
||||
}
|
||||
|
||||
async _prepareAndSnapshot() {
|
||||
await this._cleanMetadata()
|
||||
await this._snapshot()
|
||||
}
|
||||
|
||||
async run($defer) {
|
||||
const settings = this._settings
|
||||
assert(
|
||||
@@ -659,10 +614,6 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
if (this._writers.size !== 0) {
|
||||
await this._copy()
|
||||
}
|
||||
// not the case if offlineBackup
|
||||
if (this._exportedVm.is_a_snapshot) {
|
||||
await markExportSuccessfull(this._xapi, this._exportedVm.$ref)
|
||||
}
|
||||
} finally {
|
||||
if (startAfter) {
|
||||
ignoreErrors.call(vm.$callAsync('start', false, false))
|
||||
|
||||
@@ -1,327 +0,0 @@
|
||||
import { describe, it } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
|
||||
import { formatDateTime } from '@xen-orchestra/xapi'
|
||||
|
||||
import { AbstractXapi } from './_AbstractXapi.mjs'
|
||||
import { DATETIME, EXPORTED_SUCCESSFULLY, JOB_ID, SCHEDULE_ID } from '../../_otherConfig.mjs'
|
||||
|
||||
// Build an AbstractXapi instance without running its heavy constructor, then
|
||||
// assign only the fields the method under test reads.
|
||||
const makeRunner = props => Object.assign(Object.create(AbstractXapi.prototype), props)
|
||||
|
||||
describe('_snapshot() synchronized-snapshot reuse guard', () => {
|
||||
it('reuses the batch snapshot, found by metadata, without snapshotting again', async () => {
|
||||
let mustDoSnapshotCalls = 0
|
||||
const timestamp = 1717200000000
|
||||
// the snapshot taken by the batch phase, identified by its other_config
|
||||
const batchSnapshot = {
|
||||
$ref: 'batch-snapshot-ref',
|
||||
other_config: {
|
||||
[JOB_ID]: 'job-1',
|
||||
[SCHEDULE_ID]: 'schedule-1',
|
||||
[DATETIME]: formatDateTime(timestamp),
|
||||
},
|
||||
}
|
||||
const runner = makeRunner({
|
||||
_synchronizedSnapshotTimestamp: timestamp,
|
||||
_jobId: 'job-1',
|
||||
scheduleId: 'schedule-1',
|
||||
_vm: { uuid: 'vm-uuid', $snapshots: [batchSnapshot] },
|
||||
_xapi: { barrier: async () => {} },
|
||||
// if the metadata lookup fails, _snapshot() falls through to here
|
||||
_mustDoSnapshot: async () => {
|
||||
mustDoSnapshotCalls++
|
||||
return false
|
||||
},
|
||||
})
|
||||
|
||||
await runner._snapshot()
|
||||
|
||||
assert.equal(mustDoSnapshotCalls, 0, '_mustDoSnapshot() should not be called when the batch snapshot is found')
|
||||
assert.equal(runner._exportedVm, batchSnapshot, '_exportedVm should be the batch snapshot found by metadata')
|
||||
assert.equal(runner.timestamp, timestamp, 'timestamp should be the synchronized snapshot timestamp')
|
||||
})
|
||||
|
||||
it('takes a fresh snapshot when the batch snapshot can no longer be found', async () => {
|
||||
let mustDoSnapshotCalls = 0
|
||||
const vm = { uuid: 'vm-uuid', $snapshots: [] } // the pre-taken snapshot is gone
|
||||
const runner = makeRunner({
|
||||
_synchronizedSnapshotTimestamp: 1717200000000,
|
||||
_jobId: 'job-1',
|
||||
scheduleId: 'schedule-1',
|
||||
_vm: vm,
|
||||
_xapi: { barrier: async () => {} },
|
||||
_settings: {},
|
||||
_mustDoSnapshot: async () => {
|
||||
mustDoSnapshotCalls++
|
||||
return false
|
||||
},
|
||||
})
|
||||
|
||||
await runner._snapshot()
|
||||
|
||||
assert.equal(
|
||||
mustDoSnapshotCalls,
|
||||
1,
|
||||
'a missing batch snapshot should not be reused: _snapshot() should fall through and take a fresh snapshot'
|
||||
)
|
||||
assert.equal(
|
||||
runner._exportedVm,
|
||||
vm,
|
||||
'_exportedVm should fall back to the freshly-snapshotted VM, not stay on a stale/missing batch snapshot'
|
||||
)
|
||||
})
|
||||
|
||||
it('without a pre-taken snapshot and no snapshot needed, exports the live VM', async () => {
|
||||
let mustDoSnapshotCalls = 0
|
||||
const vm = { uuid: 'vm-uuid' }
|
||||
const runner = makeRunner({
|
||||
_exportedVm: undefined,
|
||||
_vm: vm,
|
||||
_xapi: {},
|
||||
_settings: {},
|
||||
_mustDoSnapshot: async () => {
|
||||
mustDoSnapshotCalls++
|
||||
return false
|
||||
},
|
||||
})
|
||||
|
||||
await runner._snapshot()
|
||||
|
||||
assert.equal(mustDoSnapshotCalls, 1, '_mustDoSnapshot() should be called once when no snapshot was pre-taken')
|
||||
assert.equal(runner._exportedVm, vm, '_exportedVm should be set to the live VM when no snapshot is needed')
|
||||
assert.equal(typeof runner.timestamp, 'number', 'timestamp should be set when exporting the live VM')
|
||||
})
|
||||
})
|
||||
|
||||
describe('_removeUnusedSnapshots() protects the pre-taken synchronized snapshot', () => {
|
||||
const OLD_DATETIME = '20240101T00:00:00Z'
|
||||
const SYNC_TIMESTAMP = 1717200000000
|
||||
const SYNC_DATETIME = formatDateTime(SYNC_TIMESTAMP)
|
||||
|
||||
// Full-mode job with snapshotRetention 0, so retention wants to remove every
|
||||
// snapshot. `vdi-fresh` is the snapshot taken up-front by the synchronized
|
||||
// batch phase (identified by SYNC_TIMESTAMP); until it is exported it must be
|
||||
// hidden from retention.
|
||||
const makeRemoveRunner = ({ exported }) => {
|
||||
const destroyed = []
|
||||
|
||||
const snapshotVm = ($ref, name_label) => ({
|
||||
$ref,
|
||||
name_label,
|
||||
is_control_domain: false,
|
||||
$snapshot_of: 'live-vm-ref',
|
||||
other_config: {},
|
||||
})
|
||||
const freshSnapshotVm = snapshotVm('vm-fresh', 'fresh')
|
||||
const oldSnapshotVm = snapshotVm('vm-old', 'old')
|
||||
|
||||
const vdi = ($ref, datetime, snapshotVmRecord, isExported = false) => ({
|
||||
$ref,
|
||||
other_config: {
|
||||
[DATETIME]: datetime,
|
||||
[SCHEDULE_ID]: 'schedule-1',
|
||||
...(isExported ? { [EXPORTED_SUCCESSFULLY]: 'true' } : {}),
|
||||
},
|
||||
$VBDs: [{ $VM: snapshotVmRecord }],
|
||||
})
|
||||
// the old snapshot was exported by a previous run
|
||||
const oldVdi = vdi('vdi-old', OLD_DATETIME, oldSnapshotVm, true)
|
||||
const freshVdi = vdi('vdi-fresh', SYNC_DATETIME, freshSnapshotVm, exported)
|
||||
|
||||
const registry = { 'vdi-old': oldVdi, 'vdi-fresh': freshVdi }
|
||||
|
||||
const runner = makeRunner({
|
||||
_synchronizedSnapshotTimestamp: SYNC_TIMESTAMP,
|
||||
_vm: { uuid: 'live-uuid', $snapshots: [] },
|
||||
_baseSettings: { snapshotRetention: 0 },
|
||||
_jobSnapshotVdis: [oldVdi, freshVdi],
|
||||
_disklessJobSnapshotVms: [],
|
||||
job: { mode: 'full', settings: {} },
|
||||
_xapi: {
|
||||
barrier: async () => {},
|
||||
getObject: ref => registry[ref],
|
||||
VM_destroy: async ref => {
|
||||
destroyed.push(ref)
|
||||
},
|
||||
VDI_destroy: async ref => {
|
||||
destroyed.push(ref)
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
return { runner, destroyed }
|
||||
}
|
||||
|
||||
it('does not destroy the pre-taken snapshot before it has been transferred', async () => {
|
||||
const { runner, destroyed } = makeRemoveRunner({ exported: false })
|
||||
|
||||
await runner._removeUnusedSnapshots()
|
||||
|
||||
assert.deepEqual(destroyed, ['vm-old'], 'only the older snapshot should be removed')
|
||||
})
|
||||
|
||||
it('destroys the snapshot once it has been transferred (retention 0, no leak)', async () => {
|
||||
const { runner, destroyed } = makeRemoveRunner({ exported: true })
|
||||
|
||||
await runner._removeUnusedSnapshots()
|
||||
|
||||
assert.deepEqual(destroyed.sort(), ['vm-fresh', 'vm-old'], 'both snapshots should be removed after transfer')
|
||||
})
|
||||
})
|
||||
|
||||
describe('_removeUnusedSnapshots() in the synchronized batch pre-snapshot state', () => {
|
||||
it('delta mode: keeps the base snapshot when the fresh one has not been taken yet', async () => {
|
||||
const destroyed = []
|
||||
|
||||
const BASE_DATETIME = '2024-06-01T00:00:00Z'
|
||||
const baseSnapshotVm = {
|
||||
$ref: 'vm-base',
|
||||
name_label: 'base',
|
||||
is_control_domain: false,
|
||||
$snapshot_of: 'live-vm-ref',
|
||||
// exported successfully by the previous run
|
||||
other_config: { [EXPORTED_SUCCESSFULLY]: 'true' },
|
||||
}
|
||||
const baseVdi = {
|
||||
$ref: 'vdi-base',
|
||||
other_config: { [DATETIME]: BASE_DATETIME, [SCHEDULE_ID]: 'schedule-1' },
|
||||
$VBDs: [{ $VM: baseSnapshotVm }],
|
||||
}
|
||||
const registry = { 'vdi-base': baseVdi }
|
||||
|
||||
const runner = makeRunner({
|
||||
// batch pre-snapshot state: the synchronized snapshot has not been taken yet
|
||||
_exportedVm: undefined,
|
||||
_vm: { uuid: 'live-uuid', $snapshots: [] },
|
||||
_baseSettings: { snapshotRetention: 0 },
|
||||
_jobSnapshotVdis: [baseVdi],
|
||||
_disklessJobSnapshotVms: [],
|
||||
job: { mode: 'delta', settings: {} },
|
||||
_xapi: {
|
||||
barrier: async () => {},
|
||||
getObject: ref => registry[ref],
|
||||
VM_destroy: async ref => {
|
||||
destroyed.push(ref)
|
||||
},
|
||||
VDI_destroy: async ref => {
|
||||
destroyed.push(ref)
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
await runner._removeUnusedSnapshots()
|
||||
|
||||
assert.deepEqual(destroyed, [], 'the base snapshot must be kept as the delta base for the upcoming transfer')
|
||||
})
|
||||
})
|
||||
|
||||
describe('_removeUnusedSnapshots() reclaims orphan / CBT snapshot VDIs (no attached VM)', () => {
|
||||
// Guards the `else` branch: snapshot VDIs that are not attached to any user VM
|
||||
// (e.g. CBT metadata, orphans) must be reclaimed via VDI_destroy, not VM_destroy.
|
||||
it('destroys snapshot VDIs directly when they are not attached to any VM', async () => {
|
||||
const vmDestroyed = []
|
||||
const vdiDestroyed = []
|
||||
|
||||
const orphanVdi = {
|
||||
$ref: 'vdi-orphan',
|
||||
other_config: { [DATETIME]: '2024-01-01T00:00:00Z', [SCHEDULE_ID]: 'schedule-1' },
|
||||
$VBDs: [], // not attached to any VM
|
||||
}
|
||||
const registry = { 'vdi-orphan': orphanVdi }
|
||||
|
||||
const runner = makeRunner({
|
||||
_exportedVm: undefined,
|
||||
_vm: { uuid: 'live-uuid', $snapshots: [] },
|
||||
_baseSettings: { snapshotRetention: 0 },
|
||||
_jobSnapshotVdis: [orphanVdi],
|
||||
_disklessJobSnapshotVms: [],
|
||||
job: { mode: 'full', settings: {} },
|
||||
_xapi: {
|
||||
barrier: async () => {},
|
||||
getObject: ref => registry[ref],
|
||||
VM_destroy: async ref => {
|
||||
vmDestroyed.push(ref)
|
||||
},
|
||||
VDI_destroy: async ref => {
|
||||
vdiDestroyed.push(ref)
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
await runner._removeUnusedSnapshots()
|
||||
|
||||
assert.deepEqual(vdiDestroyed, ['vdi-orphan'], 'the orphan VDI should be reclaimed via VDI_destroy')
|
||||
assert.deepEqual(vmDestroyed, [], 'no VM should be destroyed for an orphan VDI')
|
||||
})
|
||||
})
|
||||
|
||||
describe('_removeUnusedSnapshots() diskless VM snapshots', () => {
|
||||
const OLD_DATETIME = '20240101T00:00:00Z'
|
||||
const SYNC_TIMESTAMP = 1717200000000
|
||||
const SYNC_DATETIME = formatDateTime(SYNC_TIMESTAMP)
|
||||
|
||||
// A diskless VM's backup snapshots are tracked as VM snapshots (no VDIs to
|
||||
// anchor them). `dl-fresh` is the snapshot the synchronized batch pre-took,
|
||||
// identified by SYNC_TIMESTAMP.
|
||||
const makeDisklessRunner = ({ exported, mode = 'full' }) => {
|
||||
const destroyed = []
|
||||
|
||||
const oldSnap = { $ref: 'dl-old', other_config: { [DATETIME]: OLD_DATETIME, [SCHEDULE_ID]: 'schedule-1' } }
|
||||
const freshSnap = { $ref: 'dl-fresh', other_config: { [DATETIME]: SYNC_DATETIME, [SCHEDULE_ID]: 'schedule-1' } }
|
||||
if (exported) freshSnap.other_config[EXPORTED_SUCCESSFULLY] = 'true'
|
||||
const registry = { 'dl-old': oldSnap, 'dl-fresh': freshSnap }
|
||||
|
||||
const runner = makeRunner({
|
||||
_synchronizedSnapshotTimestamp: SYNC_TIMESTAMP,
|
||||
_vm: { uuid: 'live-uuid', $snapshots: [] },
|
||||
_baseSettings: { snapshotRetention: 0 },
|
||||
_jobSnapshotVdis: [],
|
||||
_disklessJobSnapshotVms: [oldSnap, freshSnap],
|
||||
job: { mode, settings: {} },
|
||||
_xapi: {
|
||||
barrier: async () => {},
|
||||
getObject: ref => registry[ref],
|
||||
VM_destroy: async ref => {
|
||||
destroyed.push(ref)
|
||||
},
|
||||
VDI_destroy: async ref => {
|
||||
destroyed.push(ref)
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
return { runner, destroyed }
|
||||
}
|
||||
|
||||
it('does not destroy the pre-taken diskless snapshot before it has been transferred', async () => {
|
||||
const { runner, destroyed } = makeDisklessRunner({ exported: false })
|
||||
|
||||
await runner._removeUnusedSnapshots()
|
||||
|
||||
assert.deepEqual(destroyed, ['dl-old'], 'only the older diskless snapshot should be removed')
|
||||
})
|
||||
|
||||
it('destroys the diskless snapshot once it has been transferred (retention 0, no leak)', async () => {
|
||||
const { runner, destroyed } = makeDisklessRunner({ exported: true })
|
||||
|
||||
await runner._removeUnusedSnapshots()
|
||||
|
||||
assert.deepEqual(
|
||||
destroyed.sort(),
|
||||
['dl-fresh', 'dl-old'],
|
||||
'both diskless snapshots should be removed after transfer'
|
||||
)
|
||||
})
|
||||
|
||||
it('keeps the most recent diskless snapshot in delta mode (base for next delta)', async () => {
|
||||
// Even after transfer (exported), delta mode must retain the latest
|
||||
// snapshot so the next run can compute its delta against it.
|
||||
const { runner, destroyed } = makeDisklessRunner({ exported: true, mode: 'delta' })
|
||||
|
||||
await runner._removeUnusedSnapshots()
|
||||
|
||||
assert.deepEqual(destroyed, ['dl-old'], 'the most recent diskless snapshot should be kept in delta mode')
|
||||
})
|
||||
})
|
||||
@@ -22,7 +22,7 @@ export class AggregatedIncrementalRemoteWriter extends AbstractAggregatedRemoteW
|
||||
}
|
||||
// update the parameter with our best candidate
|
||||
// that can be an empty map
|
||||
baseUuidToSrcVdi.forEach((_, key) => {
|
||||
baseUuidToSrcVdi.forEach(key => {
|
||||
if (!selectedCopy.has(key)) {
|
||||
baseUuidToSrcVdi.delete(key)
|
||||
}
|
||||
@@ -50,8 +50,13 @@ export class AggregatedIncrementalRemoteWriter extends AbstractAggregatedRemoteW
|
||||
await Promise.all(this.writers.map(writer => writer.prepare({ isFull })))
|
||||
}
|
||||
// write only on the main writer
|
||||
transfer(args) {
|
||||
return this.mainWriter.transfer(args)
|
||||
transfer({ isVhdDifferencing, timestamp, deltaExport, vm, vmSnapshot }) {
|
||||
return this.mainWriter.transfer({ isVhdDifferencing, timestamp, deltaExport, vm, vmSnapshot })
|
||||
}
|
||||
|
||||
// chain only on the main writer
|
||||
updateUuidAndChain({ isVhdDifferencing, vdis }) {
|
||||
return this.mainWriter.updateUuidAndChain({ isVhdDifferencing, vdis })
|
||||
}
|
||||
|
||||
// remove the backups and remove the entries
|
||||
|
||||
@@ -25,7 +25,7 @@ export class AggregatedIncrementalXapiWriter extends AbstractAggregatedXapiWrite
|
||||
}
|
||||
// update the parameter with our best candidate
|
||||
// that can be an empty map
|
||||
baseUuidToSrcVdi.forEach((_, key) => {
|
||||
baseUuidToSrcVdi.forEach(key => {
|
||||
if (!selectedCopy.has(key)) {
|
||||
baseUuidToSrcVdi.delete(key)
|
||||
}
|
||||
@@ -59,6 +59,11 @@ export class AggregatedIncrementalXapiWriter extends AbstractAggregatedXapiWrite
|
||||
return this.mainWriter.transfer(args)
|
||||
}
|
||||
|
||||
// chain only on the main writer
|
||||
updateUuidAndChain(args) {
|
||||
return this.mainWriter.updateUuidAndChain(args)
|
||||
}
|
||||
|
||||
// remove the backups and remove the entries
|
||||
async cleanup() {
|
||||
debug('cleanup')
|
||||
|
||||
@@ -2,11 +2,11 @@ import assert from 'node:assert'
|
||||
import mapValues from 'lodash/mapValues.js'
|
||||
import { asyncEach } from '@vates/async-each'
|
||||
import { asyncMap } from '@xen-orchestra/async-map'
|
||||
import { chainVhd, openVhd } from 'vhd-lib'
|
||||
import { createLogger } from '@xen-orchestra/log'
|
||||
import { decorateClass } from '@vates/decorate-with'
|
||||
import { defer } from 'golike-defer'
|
||||
import { dirname, basename } from 'node:path'
|
||||
import { relativeFromFile } from '@xen-orchestra/fs/path'
|
||||
import { Task } from '@vates/task'
|
||||
|
||||
import { formatFilenameDate } from '../../_filenameDate.mjs'
|
||||
@@ -16,18 +16,15 @@ import { MixinRemoteWriter } from './_MixinRemoteWriter.mjs'
|
||||
import { AbstractIncrementalWriter } from './_AbstractIncrementalWriter.mjs'
|
||||
import { checkVhd } from './_checkVhd.mjs'
|
||||
import { packUuid } from './_packUuid.mjs'
|
||||
import { openDiskChain } from '@xen-orchestra/backup-archive/disks'
|
||||
import { VDI_FORMAT_QCOW2 } from '@xen-orchestra/xapi'
|
||||
import { diskHasData } from './_diskHasData.mjs'
|
||||
import { Disposable } from 'promise-toolbox'
|
||||
|
||||
const { warn } = createLogger('xo:backups:DeltaBackupWriter')
|
||||
|
||||
export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrementalWriter) {
|
||||
#parentVdiPaths
|
||||
#parentUuids
|
||||
#vhds
|
||||
async checkBaseVdis(baseUuidToSrcVdi) {
|
||||
this.#parentVdiPaths = {}
|
||||
this.#parentUuids = {}
|
||||
const { handler } = this._adapter
|
||||
const adapter = this._adapter
|
||||
|
||||
@@ -35,7 +32,6 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
|
||||
await asyncMap(baseUuidToSrcVdi, async ([baseUuid, srcVdiUuid]) => {
|
||||
let parentDestPath
|
||||
let parentUuid
|
||||
const vhdDir = `${vdisDir}/${srcVdiUuid}`
|
||||
try {
|
||||
const vhds = await handler.list(vhdDir, {
|
||||
@@ -51,7 +47,6 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
try {
|
||||
if (await adapter.isMergeableParent(packedBaseUuid, path)) {
|
||||
parentDestPath = path
|
||||
parentUuid = packedBaseUuid
|
||||
}
|
||||
} catch (error) {
|
||||
warn('checkBaseVdis', { error })
|
||||
@@ -64,77 +59,11 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
if (parentDestPath === undefined) {
|
||||
baseUuidToSrcVdi.delete(baseUuid)
|
||||
} else {
|
||||
try {
|
||||
// A delta is only chained onto a qcow2 base when NBD is enabled; without NBD a qcow2
|
||||
// export falls back to a full, so there is no suspect base to worry about.
|
||||
if (this._settings.preferNbd && !(await this.#isBaseChainable(parentDestPath))) {
|
||||
Task.warning('forcing a full: qcow2 base predates the non-NBD qcow2 fix and looks corrupt', {
|
||||
parentDestPath,
|
||||
})
|
||||
baseUuidToSrcVdi.delete(baseUuid)
|
||||
return
|
||||
}
|
||||
this.#parentVdiPaths[vhdDir] = parentDestPath
|
||||
this.#parentUuids[vhdDir] = parentUuid
|
||||
} catch (error) {
|
||||
warn('checkBaseVdis: unexpected error, forcing a full', { error, parentDestPath })
|
||||
baseUuidToSrcVdi.delete(baseUuid)
|
||||
}
|
||||
this.#parentVdiPaths[vhdDir] = parentDestPath
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Decide whether it is safe to chain a delta onto `parentDestPath` (the chain tip).
|
||||
// A qcow2 full exported before the DiskLargerBlock 20260724 fix can be silently corrupt (block 0
|
||||
// valid, following allocated blocks all zero); chaining a delta onto it would extend a
|
||||
// broken chain, so we detect that case and let the caller fall back to a full.
|
||||
async #isBaseChainable(parentDestPath) {
|
||||
// parentDestPath is the chain tip = most-recent backup; its filename is stable under
|
||||
// merges (merges rename the OLDER disks), so unlike the root it maps reliably to its
|
||||
// metadata json.
|
||||
const parentDate = basename(parentDestPath).replace(/\.(alias\.)?vhd$/, '')
|
||||
let metadata
|
||||
try {
|
||||
metadata = await this._adapter.readVmBackupMetadata(`${this._vmBackupDir}/${parentDate}.json`)
|
||||
} catch (error) {
|
||||
warn('checkBaseVdis: cannot read parent metadata, will probe', { error, parentDestPath })
|
||||
}
|
||||
if (metadata?.includeNonNbdQcow2Fix === true) {
|
||||
// written by code that has the fix and this gate, so its chain was already
|
||||
// verified/forced clean — no disk open needed
|
||||
// we can't have includeNonNbdQcow2Fix = false since it would have restarted a clean chain
|
||||
return true
|
||||
}
|
||||
const isQcow2 =
|
||||
metadata === undefined ||
|
||||
Object.values(metadata.vdis ?? {}).some(vdi => vdi?.sm_config?.['image-format'] === VDI_FORMAT_QCOW2)
|
||||
if (!isQcow2) {
|
||||
// only qcow2 exports can carry this corruption
|
||||
return true
|
||||
}
|
||||
return this.#baseHasData(parentDestPath)
|
||||
}
|
||||
|
||||
// Probe the first data blocks of the chain root for the DiskLargerBlock corruption
|
||||
// signature. Returns false only when enough allocated blocks past the first are all zero.
|
||||
async #baseHasData(parentDestPath) {
|
||||
const { handler } = this._adapter
|
||||
// open the chain (with block allocation tables) and probe its root full. This only runs
|
||||
// once per chain — afterwards the includeNonNbdQcow2Fix flag on the tip skips it — so
|
||||
// reading the deltas' BATs here is negligible and lets us reuse the root disk directly.
|
||||
const chain = await openDiskChain({ handler, path: parentDestPath })
|
||||
try {
|
||||
const root = chain.getRootDisk()
|
||||
if (root === undefined) {
|
||||
throw new Error(`can't resolve root of chain ${parentDestPath}`)
|
||||
}
|
||||
|
||||
return await diskHasData(root)
|
||||
} finally {
|
||||
await chain.close()
|
||||
}
|
||||
}
|
||||
|
||||
async beforeBackup() {
|
||||
await super.beforeBackup()
|
||||
return this._cleanVm({ merge: true, remove: true })
|
||||
@@ -197,6 +126,48 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
}
|
||||
}
|
||||
|
||||
async updateUuidAndChain({ isVhdDifferencing, vdis }) {
|
||||
assert.notStrictEqual(
|
||||
this.#vhds,
|
||||
undefined,
|
||||
'_transfer must be called before updateUuidAndChain for incremental backups'
|
||||
)
|
||||
|
||||
const parentVdiPaths = this.#parentVdiPaths
|
||||
const { handler } = this._adapter
|
||||
const vhds = this.#vhds
|
||||
await asyncEach(Object.entries(vdis), async ([id, vdi]) => {
|
||||
const isDifferencing = isVhdDifferencing[id]
|
||||
const path = `${this._vmBackupDir}/${vhds[id]}`
|
||||
if (isDifferencing) {
|
||||
assert.notStrictEqual(
|
||||
parentVdiPaths,
|
||||
undefined,
|
||||
'checkbasevdi must be called before updateUuidAndChain for incremental backups'
|
||||
)
|
||||
const parentPath = parentVdiPaths[dirname(path)]
|
||||
// we are in a incremental backup
|
||||
// we already computed the chain in checkBaseVdis
|
||||
assert.notStrictEqual(parentPath, undefined, 'A differential VHD must have a parent')
|
||||
// forbid any kind of loop
|
||||
assert.ok(basename(parentPath) < basename(path), `vhd must be sorted to be chained`)
|
||||
// re-chainVhd is mandatory
|
||||
// since the parent may be a alias or not
|
||||
// and the child may be the other
|
||||
await chainVhd(handler, parentPath, handler, path)
|
||||
}
|
||||
|
||||
// set the correct UUID in the VHD if needed
|
||||
await Disposable.use(openVhd(handler, path), async vhd => {
|
||||
if (!vhd.footer.uuid.equals(packUuid(vdi.uuid))) {
|
||||
vhd.footer.uuid = packUuid(vdi.uuid)
|
||||
await vhd.readBlockAllocationTable() // required by writeFooter()
|
||||
await vhd.writeFooter()
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
async _deleteOldEntries() {
|
||||
const adapter = this._adapter
|
||||
const oldEntries = this._oldEntries
|
||||
@@ -207,7 +178,7 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
}
|
||||
}
|
||||
|
||||
async _transfer($defer, { includeNonNbdQcow2Fix, isVhdDifferencing, timestamp, deltaExport, vm, vmSnapshot }) {
|
||||
async _transfer($defer, { isVhdDifferencing, timestamp, deltaExport, vm, vmSnapshot }) {
|
||||
const adapter = this._adapter
|
||||
const job = this._job
|
||||
const scheduleId = this._schedule.id
|
||||
@@ -215,8 +186,10 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
const jobId = job.id
|
||||
const handler = adapter.handler
|
||||
|
||||
const filenameDate = formatFilenameDate(timestamp)
|
||||
const vhds = mapValues(
|
||||
const basename = formatFilenameDate(timestamp)
|
||||
// update this.#vhds before eventually skipping transfer, so that
|
||||
// updateUuidAndChain has all the mandatory data
|
||||
const vhds = (this.#vhds = mapValues(
|
||||
deltaExport.vdis,
|
||||
vdi =>
|
||||
`vdis/${jobId}/${
|
||||
@@ -225,8 +198,8 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
// don't do delta for it
|
||||
vdi.uuid
|
||||
: vdi.$snapshot_of$uuid
|
||||
}/${adapter.getVhdFileName(filenameDate)}`
|
||||
)
|
||||
}/${adapter.getVhdFileName(basename)}`
|
||||
))
|
||||
|
||||
let metadataContent = await this._isAlreadyTransferred(timestamp)
|
||||
if (metadataContent !== undefined) {
|
||||
@@ -236,11 +209,6 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
}
|
||||
|
||||
metadataContent = {
|
||||
// marks whether the disk data is known-good w.r.t. the non-NBD qcow2 corruption bug.
|
||||
// A fresh XAPI export by fixed code passes `true`; the mirror runner propagates the
|
||||
// source backup's value (copying corrupt source data must NOT become "fixed"). Its
|
||||
// absence flags a potentially-corrupt older disk (used by cleanVm and the force-full gate).
|
||||
includeNonNbdQcow2Fix,
|
||||
isVhdDifferencing,
|
||||
jobId,
|
||||
mode: job.mode,
|
||||
@@ -261,24 +229,12 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
Object.entries(deltaExport.disks),
|
||||
async ([diskRef, disk]) => {
|
||||
const path = `${this._vmBackupDir}/${vhds[diskRef]}`
|
||||
const vdi = deltaExport.vdis[diskRef]
|
||||
|
||||
let parentUuid, parentPath
|
||||
if (isVhdDifferencing[diskRef]) {
|
||||
const parentDestPath = this.#parentVdiPaths[dirname(path)]
|
||||
parentUuid = this.#parentUuids[dirname(path)]
|
||||
assert.notStrictEqual(parentDestPath, undefined, 'A differential VHD must have a parent')
|
||||
// forbid any kind of loop
|
||||
assert.ok(basename(parentDestPath) < basename(path), `vhd must be sorted to be chained`)
|
||||
parentPath = relativeFromFile(path, parentDestPath)
|
||||
}
|
||||
|
||||
const transferred = await adapter.writeVhd(path, disk, {
|
||||
// no checksum for VHDs, because they will be invalidated by
|
||||
// merges and chains
|
||||
checksum: false,
|
||||
validator: tmpPath => checkVhd(handler, tmpPath),
|
||||
writeBlockConcurrency: this._config.writeBlockConcurrency,
|
||||
uuid: packUuid(vdi.uuid),
|
||||
parentUuid,
|
||||
parentPath,
|
||||
})
|
||||
size += transferred
|
||||
},
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
import assert from 'node:assert'
|
||||
import humanFormat from 'human-format'
|
||||
|
||||
import { asyncMapSettled } from '@xen-orchestra/async-map'
|
||||
@@ -21,7 +20,6 @@ import {
|
||||
DATETIME,
|
||||
VM_UUID,
|
||||
CONTENT_KEY,
|
||||
INCLUDE_NON_NBD_QCOW2_FIX,
|
||||
resetVmOtherConfig,
|
||||
} from '../../_otherConfig.mjs'
|
||||
import { formatFilenameDate } from '../../_filenameDate.mjs'
|
||||
@@ -29,9 +27,8 @@ import { XapiDiskSource } from '@xen-orchestra/xapi'
|
||||
import { asyncEach } from '@vates/async-each'
|
||||
import { createLogger } from '@xen-orchestra/log'
|
||||
import { VM_POWER_STATE } from '@vates/types'
|
||||
import { diskHasData } from './_diskHasData.mjs'
|
||||
|
||||
const { debug, warn } = createLogger('xo:backups:IncrementalXapiWriter')
|
||||
const { debug } = createLogger('xo:backups:IncrementalXapiWriter')
|
||||
|
||||
export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWriter) {
|
||||
// Map of source VDI UUID (COPY_OF) → validated active VDI on the target SR.
|
||||
@@ -96,45 +93,6 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
|
||||
)
|
||||
}
|
||||
if (target !== undefined) {
|
||||
// A delta is only chained onto a qcow2 base when NBD is enabled; without NBD a qcow2
|
||||
// export falls back to a full, so there is no suspect base.
|
||||
if (this._settings.preferNbd) {
|
||||
// Every copy written by fixed code carries the flag, so the marker on the most recent
|
||||
// link is enough: if it is there, this chain was already verified (or re-based) by a
|
||||
// run that had the fix, and older links need no re-check.
|
||||
const suspect = target.other_config[INCLUDE_NON_NBD_QCOW2_FIX] !== 'true'
|
||||
if (suspect) {
|
||||
const chain = this.#diskReplicaSnapshots(target)
|
||||
// probe the OLDEST link (least-masked view of the corruption — a later delta could
|
||||
// have overwritten the corrupt blocks and hidden the damage on a more recent snapshot).
|
||||
// Re-replicating a full is expensive, so only force one when it actually looks corrupt.
|
||||
let base = target
|
||||
assert.notStrictEqual(base.other_config[DATETIME], undefined)
|
||||
for (const vdi of chain) {
|
||||
const datetime = vdi.other_config[DATETIME]
|
||||
assert.notStrictEqual(datetime, undefined)
|
||||
if (datetime < base.other_config[DATETIME]) {
|
||||
base = vdi
|
||||
}
|
||||
}
|
||||
let chainable
|
||||
try {
|
||||
chainable = await this.#baseVdiHasData(base.$ref)
|
||||
} catch (error) {
|
||||
// can't read the base to decide → don't chain onto it
|
||||
warn('checkBaseVdis: error probing replicated base, forcing a full', { error, baseVdi: base.uuid })
|
||||
chainable = false
|
||||
}
|
||||
if (!chainable) {
|
||||
Task.warning('forcing a full: replicated qcow2 chain predates the non-NBD qcow2 fix and looks corrupt', {
|
||||
baseVdi: base.uuid,
|
||||
})
|
||||
// drop it so neither the snapshot nor the legacy fallback reuses it → full
|
||||
baseUuidToSrcVdi.delete(baseUuid)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
snapshotCandidates.set(baseUuid, target)
|
||||
}
|
||||
}
|
||||
@@ -175,42 +133,6 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// All replica snapshots of a given disk share the same active target VDI ($snapshot_of). Return
|
||||
// them (same job+vm) so the caller can inspect the whole chain: any link missing the fix marker
|
||||
// makes the chain suspect, and the oldest link (by DATETIME) is the least-masked base to probe.
|
||||
// Scoped by $snapshot_of, so history before a CR VM recreation (which resets it) is not included.
|
||||
#diskReplicaSnapshots(target) {
|
||||
const activeUuid = target.$snapshot_of?.uuid
|
||||
const snapshots = []
|
||||
for (const vdi of this._sr.$VDIs) {
|
||||
if (
|
||||
vdi?.managed &&
|
||||
vdi?.is_a_snapshot &&
|
||||
vdi.$snapshot_of?.uuid === activeUuid &&
|
||||
vdi.other_config[JOB_ID] === this._job.id &&
|
||||
vdi.other_config[VM_UUID] === this._vmUuid
|
||||
) {
|
||||
snapshots.push(vdi)
|
||||
}
|
||||
}
|
||||
return snapshots
|
||||
}
|
||||
|
||||
// Probe a replicated base VDI for the DiskLargerBlock corruption signature (block 0 valid,
|
||||
// following allocated blocks all zero). Uses an export (not NBD): block flow is guaranteed
|
||||
// to be in index order, so block 0 comes first and inspecting the first few blocks is enough.
|
||||
// Returns false only when no allocated non-zero block is found among the first ones.
|
||||
async #baseVdiHasData(vdiRef) {
|
||||
const source = new XapiDiskSource({ xapi: this._sr.$xapi, vdiRef, preferNbd: false })
|
||||
try {
|
||||
await source.init()
|
||||
return await diskHasData(source)
|
||||
} finally {
|
||||
await source.close()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 6.3+ snapshot-based validation: for each snapshot candidate, check whether
|
||||
* the active VDI has diverged from the snapshot. Returns a baseVdisBySourceUuid
|
||||
@@ -263,7 +185,6 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
|
||||
vdiRef: activeVdi.$ref,
|
||||
baseRef: snapshot.$ref,
|
||||
onlyListChangedBlocks: true,
|
||||
preferNbd: this._settings.preferNbd,
|
||||
})
|
||||
await diffDisk.init()
|
||||
if (diffDisk.getBlockIndexes().length === 0) {
|
||||
@@ -314,6 +235,9 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
|
||||
return { baseVdisBySourceUuid, targetVmRef }
|
||||
}
|
||||
|
||||
updateUuidAndChain() {
|
||||
// nothing to do, the chaining is not modified in this case
|
||||
}
|
||||
prepare({ isFull }) {
|
||||
// create the task related to this export and ensure all methods are called in this context
|
||||
const task = new Task({
|
||||
@@ -419,10 +343,6 @@ export class IncrementalXapiWriter extends MixinXapiWriter(AbstractIncrementalWr
|
||||
if (baseDeltaVdiUuid !== undefined) {
|
||||
// reuse the validated mapping built by checkBaseVdis
|
||||
vdi.baseVdi = this.#baseVdisBySourceUuid.get(baseDeltaVdiUuid)
|
||||
// BASE_DELTA_VDI is set, so the export is differencing. Without a base to clone,
|
||||
// importIncrementalVm would create a blank VDI and write only the changed blocks
|
||||
// into it, silently producing a corrupt replica: fail the job instead.
|
||||
assert.notStrictEqual(vdi.baseVdi, undefined, `no validated target base for ${baseDeltaVdiUuid}`)
|
||||
} else {
|
||||
// first replication of this disk (full, no base)
|
||||
vdi.baseVdi = undefined
|
||||
|
||||
@@ -5,6 +5,10 @@ export class AbstractIncrementalWriter extends AbstractWriter {
|
||||
throw new Error('Not implemented')
|
||||
}
|
||||
|
||||
updateUuidAndChain() {
|
||||
throw new Error('Not implemented')
|
||||
}
|
||||
|
||||
cleanup() {
|
||||
throw new Error('Not implemented')
|
||||
}
|
||||
@@ -16,6 +20,8 @@ export class AbstractIncrementalWriter extends AbstractWriter {
|
||||
async transfer({ deltaExport, ...other }) {
|
||||
try {
|
||||
return await this._transfer({ deltaExport, ...other })
|
||||
} catch (err) {
|
||||
console.error({ err })
|
||||
} finally {
|
||||
// ensure all sources are properly closed
|
||||
for (const disk of Object.values(deltaExport.disks)) {
|
||||
|
||||
@@ -1,26 +0,0 @@
|
||||
// Probe a disk for the DiskLargerBlock corruption signature (block 0 valid,
|
||||
// following allocated blocks all zero). Uses an export (not NBD): block flow is guaranteed
|
||||
// to be in index order, so block 0 comes first and inspecting the first few blocks is enough.
|
||||
|
||||
// Returns false only when no allocated non-zero block is found among the first ones.
|
||||
export async function diskHasData(source) {
|
||||
const empty = Buffer.alloc(source.getBlockSize(), 0)
|
||||
const MAX_EMPTY = 10
|
||||
let nbEmpty = 0
|
||||
// diskBlocks() closes the source when the iteration ends or is broken out of
|
||||
for await (const { index, data } of source.diskBlocks()) {
|
||||
if (index === 0) {
|
||||
// block 0 stays valid even in the corruption signature — skip it
|
||||
continue
|
||||
}
|
||||
if (!data.equals(empty)) {
|
||||
// an allocated block holds real data → not corrupt
|
||||
return true
|
||||
}
|
||||
if (++nbEmpty >= MAX_EMPTY) {
|
||||
break
|
||||
}
|
||||
}
|
||||
// no allocated non-zero block among the first ones → looks corrupt (or empty; a full is cheap then)
|
||||
return false
|
||||
}
|
||||
@@ -230,6 +230,7 @@ Settings are described in [`@xen-orchestra/backups/\_runners/VmsXapi.mjs``](http
|
||||
- `checkBaseVdis(baseUuidToSrcVdi, baseVm)`
|
||||
- `prepare({ isFull })`
|
||||
- `transfer({ timestamp, deltaExport, sizeContainers })`
|
||||
- `updateUuidAndChain({ isVhdDifferencing, vdis })`
|
||||
- `cleanup()`
|
||||
- `healthCheck()` // is not executed if no health check sr or tag doesn't match
|
||||
- **Full**
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
"type": "git",
|
||||
"url": "https://github.com/vatesfr/xen-orchestra.git"
|
||||
},
|
||||
"version": "0.74.2",
|
||||
"version": "0.73.7",
|
||||
"engines": {
|
||||
"node": ">=14.18"
|
||||
},
|
||||
@@ -27,17 +27,17 @@
|
||||
"@vates/disposable": "^0.1.6",
|
||||
"@vates/fuse-vhd": "^2.1.3",
|
||||
"@vates/generator-toolbox": "^1.1.3",
|
||||
"@vates/nbd-client": "^3.5.1",
|
||||
"@vates/nbd-client": "^3.4.0",
|
||||
"@vates/parse-duration": "^0.1.1",
|
||||
"@vates/task": "^0.7.0",
|
||||
"@vates/types": "^2.0.1",
|
||||
"@xen-orchestra/async-map": "^0.1.4",
|
||||
"@xen-orchestra/disk-transform": "^1.3.3",
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@vates/types": "^1.28.0",
|
||||
"@xen-orchestra/async-map": "^0.1.3",
|
||||
"@xen-orchestra/disk-transform": "^1.3.1",
|
||||
"@xen-orchestra/fs": "^4.9.2",
|
||||
"@xen-orchestra/log": "^0.7.2",
|
||||
"@xen-orchestra/qcow2": "^1.3.1",
|
||||
"@xen-orchestra/template": "^0.1.1",
|
||||
"@xen-orchestra/backup-archive": "^1.1.2",
|
||||
"@xen-orchestra/backup-archive": "^1.0.4",
|
||||
"app-conf": "^3.0.0",
|
||||
"compare-versions": "^6.0.0",
|
||||
"d3-time-format": "^4.1.0",
|
||||
@@ -52,11 +52,11 @@
|
||||
"parse-pairs": "^2.0.0",
|
||||
"promise-toolbox": "^0.21.0",
|
||||
"proper-lockfile": "^4.1.2",
|
||||
"tar": "^7.5.19",
|
||||
"tar": "^7.5.3",
|
||||
"uuid": "^9.0.0",
|
||||
"value-matcher": "^0.2.0",
|
||||
"vhd-lib": "^4.16.1",
|
||||
"xen-api": "^4.9.0",
|
||||
"vhd-lib": "^4.16.0",
|
||||
"xen-api": "^4.7.8",
|
||||
"yazl": "^2.5.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
@@ -67,7 +67,7 @@
|
||||
"typescript": "^5.9.3"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@xen-orchestra/xapi": "^8.10.5"
|
||||
"@xen-orchestra/xapi": "^8.9.0"
|
||||
},
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"author": {
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
"preferGlobal": true,
|
||||
"dependencies": {
|
||||
"golike-defer": "^0.5.1",
|
||||
"xen-api": "^4.9.0"
|
||||
"xen-api": "^4.7.8"
|
||||
},
|
||||
"scripts": {
|
||||
"postversion": "npm publish"
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"private": false,
|
||||
"name": "@xen-orchestra/disk-cli",
|
||||
"version": "2.2.1",
|
||||
"version": "2.1.2",
|
||||
"description": "CLI tool to inspect and manage disks in backup repositories",
|
||||
"type": "module",
|
||||
"bin": {
|
||||
@@ -20,13 +20,13 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@xen-orchestra/backups": "^0.74.2",
|
||||
"@xen-orchestra/backup-archive": "^1.1.2",
|
||||
"@xen-orchestra/disk-transform": "^1.3.3",
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/backups": "^0.73.7",
|
||||
"@xen-orchestra/backup-archive": "^1.0.4",
|
||||
"@xen-orchestra/disk-transform": "^1.3.1",
|
||||
"@xen-orchestra/fs": "^4.9.2",
|
||||
"@xen-orchestra/qcow2": "^1.3.1",
|
||||
"promise-toolbox": "^0.21.0",
|
||||
"vhd-lib": "^4.16.1"
|
||||
"vhd-lib": "^4.16.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.3.0",
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
{
|
||||
"name": "@xen-orchestra/disk-transform",
|
||||
"version": "1.3.3",
|
||||
"version": "1.3.1",
|
||||
"main": "./dist/index.mjs",
|
||||
"license": "MIT",
|
||||
"private": false,
|
||||
"type": "module",
|
||||
"devDependencies": {
|
||||
"@eslint/js": "^9.19.0",
|
||||
"@xen-orchestra/fs": "^4.9.2",
|
||||
"rimraf": "^6.0.1",
|
||||
"@types/node": "^22.3.0",
|
||||
"typescript": "~5.6",
|
||||
@@ -17,6 +18,7 @@
|
||||
"dev": "tsc --watch",
|
||||
"postversion": "npm publish --access public",
|
||||
"test": "tsc && node --test **/*.test.mjs",
|
||||
"test-integration": "node --test **/*.integ.mjs",
|
||||
"clean": "rimraf dist/"
|
||||
},
|
||||
"homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/disk-transform",
|
||||
|
||||
109
@xen-orchestra/disk-transform/src/DiskAlias.integ.mts
Normal file
109
@xen-orchestra/disk-transform/src/DiskAlias.integ.mts
Normal file
@@ -0,0 +1,109 @@
|
||||
import { afterEach, beforeEach, test } from 'node:test'
|
||||
import assert from 'node:assert'
|
||||
import { mkdtemp } from 'node:fs/promises'
|
||||
import { tmpdir } from 'node:os'
|
||||
import { join } from 'node:path'
|
||||
import { rimraf } from 'rimraf'
|
||||
import { getSyncedHandler } from '@xen-orchestra/fs'
|
||||
import type { FileAccessor } from './FileAccessor.mjs'
|
||||
import {
|
||||
AliasChainError,
|
||||
AliasIsDirectoryError,
|
||||
AliasMissingError,
|
||||
AliasTooLongError,
|
||||
ALIAS_MAX_PATH_LENGTH,
|
||||
DiskAlias,
|
||||
} from './DiskAlias.mjs'
|
||||
|
||||
let tempDir: string
|
||||
let dispose: () => Promise<void>
|
||||
let handler: FileAccessor
|
||||
|
||||
beforeEach(async () => {
|
||||
tempDir = await mkdtemp(join(tmpdir(), 'disk-alias-'))
|
||||
const synced = await getSyncedHandler({ url: `file://${tempDir}` })
|
||||
handler = synced.value as unknown as FileAccessor
|
||||
dispose = synced.dispose
|
||||
})
|
||||
|
||||
afterEach(async () => {
|
||||
await dispose()
|
||||
await rimraf(tempDir)
|
||||
})
|
||||
|
||||
test('DiskAlias resolve()', async t => {
|
||||
await t.test('gets the path of the target file for an alias, same directory', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
const alias = 'alias.alias.vhd'
|
||||
await handler.writeFile(alias, 'target.vhd')
|
||||
assert.equal(await vhdAlias.resolve(handler, alias), 'target.vhd')
|
||||
})
|
||||
|
||||
await t.test('gets the path of the target file for an alias, different directory', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
const alias = 'alias.alias.vhd'
|
||||
await handler.mktree('sub')
|
||||
await handler.writeFile(alias, 'sub/target.vhd', { flags: 'w' })
|
||||
assert.equal(await vhdAlias.resolve(handler, alias), 'sub/target.vhd')
|
||||
})
|
||||
|
||||
await t.test('throws AliasChainError on an alias to an alias', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
const alias = 'alias.alias.vhd'
|
||||
const target = 'target.alias.vhd'
|
||||
await handler.writeFile(alias, target)
|
||||
await assert.rejects(async () => await vhdAlias.resolve(handler, alias), AliasChainError)
|
||||
})
|
||||
|
||||
await t.test('throws AliasTooLongError on a file too big', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
await handler.writeFile('toobig.alias.vhd', '0'.repeat(ALIAS_MAX_PATH_LENGTH + 1))
|
||||
await assert.rejects(async () => await vhdAlias.resolve(handler, 'toobig.alias.vhd'), AliasTooLongError)
|
||||
})
|
||||
|
||||
await t.test('throws AliasMissingError when the alias file does not exist', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
await assert.rejects(async () => await vhdAlias.resolve(handler, 'missing.alias.vhd'), AliasMissingError)
|
||||
})
|
||||
|
||||
await t.test('throws AliasIsDirectoryError when the alias path is a directory', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
await handler.mktree('broken.alias.vhd')
|
||||
await assert.rejects(async () => await vhdAlias.resolve(handler, 'broken.alias.vhd'), AliasIsDirectoryError)
|
||||
})
|
||||
})
|
||||
|
||||
test('DiskAlias create()', async t => {
|
||||
await t.test('writes the relative path from the alias to the target', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
await handler.mktree('data')
|
||||
await vhdAlias.create(handler, 'disk.alias.vhd', 'data/disk.vhd')
|
||||
assert.equal((await handler.readFile('disk.alias.vhd')).toString(), 'data/disk.vhd')
|
||||
})
|
||||
|
||||
await t.test('rejects chaining alias to alias', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
await assert.rejects(
|
||||
async () => await vhdAlias.create(handler, 'disk.alias.vhd', 'other.alias.vhd'),
|
||||
AliasChainError
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
test('DiskAlias unlink()', async t => {
|
||||
await t.test('removes the alias file and its target', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
await handler.writeFile('data.vhd', 'content')
|
||||
await vhdAlias.create(handler, 'disk.alias.vhd', 'data.vhd')
|
||||
await vhdAlias.unlink(handler, 'disk.alias.vhd')
|
||||
await assert.rejects(async () => await handler.getSize('disk.alias.vhd'))
|
||||
await assert.rejects(async () => await handler.getSize('data.vhd'))
|
||||
})
|
||||
|
||||
await t.test('removes a broken alias that is actually a directory', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
await handler.mktree('broken.alias.vhd')
|
||||
await vhdAlias.unlink(handler, 'broken.alias.vhd')
|
||||
await assert.rejects(async () => await handler.getSize('broken.alias.vhd'))
|
||||
})
|
||||
})
|
||||
121
@xen-orchestra/disk-transform/src/DiskAlias.mts
Normal file
121
@xen-orchestra/disk-transform/src/DiskAlias.mts
Normal file
@@ -0,0 +1,121 @@
|
||||
import { dirname, relative, resolve } from 'node:path'
|
||||
import type { FileAccessor } from './FileAccessor.mjs'
|
||||
|
||||
export const ALIAS_MAX_PATH_LENGTH = 1024
|
||||
|
||||
export class DiskAliasError extends Error {}
|
||||
export class AliasMissingError extends DiskAliasError {
|
||||
code = 'ENOENT'
|
||||
}
|
||||
export class AliasIsDirectoryError extends DiskAliasError {
|
||||
code = 'EISDIR'
|
||||
}
|
||||
export class AliasChainError extends DiskAliasError {}
|
||||
export class AliasTooLongError extends DiskAliasError {}
|
||||
|
||||
function resolveRelativeFromFile(file: string, targetPath: string): string {
|
||||
if (file.startsWith('/')) {
|
||||
return resolve(dirname(file), targetPath)
|
||||
}
|
||||
return resolve('/', dirname(file), targetPath).slice(1)
|
||||
}
|
||||
|
||||
/**
|
||||
* an alias is a small text file containing the path, relative to itself,
|
||||
* of the disk (file or directory) it points to
|
||||
*/
|
||||
export class DiskAlias {
|
||||
#extension: string
|
||||
|
||||
constructor(extension: string) {
|
||||
this.#extension = extension
|
||||
}
|
||||
|
||||
get suffix(): string {
|
||||
return `.alias.${this.#extension}`
|
||||
}
|
||||
|
||||
isAlias(filename: string): boolean {
|
||||
return filename.endsWith(this.suffix)
|
||||
}
|
||||
|
||||
async resolve(handler: FileAccessor, filename: string): Promise<string> {
|
||||
if (!this.isAlias(filename)) {
|
||||
return filename
|
||||
}
|
||||
|
||||
let aliasContent: string
|
||||
try {
|
||||
aliasContent = (await handler.readFile(filename)).toString().trim()
|
||||
} catch (err: any) {
|
||||
if (err.code === 'ENOENT') {
|
||||
throw new AliasMissingError(`The alias file ${filename} does not exist`)
|
||||
}
|
||||
if (err.code === 'EISDIR') {
|
||||
throw new AliasIsDirectoryError(`The alias file ${filename} is a directory`)
|
||||
}
|
||||
throw err
|
||||
}
|
||||
|
||||
if (!handler.isEncrypted && aliasContent.length > ALIAS_MAX_PATH_LENGTH) {
|
||||
throw new AliasTooLongError(`The alias file ${filename} is too long (${aliasContent.length} chars)`)
|
||||
}
|
||||
|
||||
// also handle circular references and unreasonably long chains
|
||||
if (this.isAlias(aliasContent)) {
|
||||
throw new AliasChainError(`Chaining alias is forbidden ${filename} to ${aliasContent}`)
|
||||
}
|
||||
|
||||
// the target is relative to the alias location
|
||||
return resolveRelativeFromFile(filename, aliasContent)
|
||||
}
|
||||
|
||||
async create(handler: FileAccessor, aliasPath: string, targetPath: string): Promise<void> {
|
||||
if (!this.isAlias(aliasPath)) {
|
||||
throw new DiskAliasError(`Alias must be named *${this.suffix}, ${aliasPath} given`)
|
||||
}
|
||||
if (this.isAlias(targetPath)) {
|
||||
throw new AliasChainError(`Chaining alias is forbidden ${aliasPath} to ${targetPath}`)
|
||||
}
|
||||
|
||||
// aliasPath and targetPath are absolute path from the root of the handler
|
||||
// normalize them so they can't escape this dir
|
||||
const aliasDir = dirname(resolve('/', aliasPath))
|
||||
// only store the relative path from alias to target
|
||||
const relativePathToTarget = relative(aliasDir, resolve('/', targetPath))
|
||||
|
||||
if (relativePathToTarget.length > ALIAS_MAX_PATH_LENGTH) {
|
||||
throw new AliasTooLongError(
|
||||
`Alias relative path ${relativePathToTarget} is too long : ${relativePathToTarget.length} chars, max is ${ALIAS_MAX_PATH_LENGTH}`
|
||||
)
|
||||
}
|
||||
await handler.writeFile(aliasPath, relativePathToTarget)
|
||||
}
|
||||
|
||||
async unlink(handler: FileAccessor, path: string): Promise<void> {
|
||||
let resolved = path
|
||||
try {
|
||||
resolved = await this.resolve(handler, path)
|
||||
} catch (err) {
|
||||
// broken alias (named like an alias but is actually a directory) must still be unlinkable
|
||||
if (!(err instanceof AliasIsDirectoryError)) {
|
||||
throw err
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
await handler.unlink(resolved)
|
||||
} catch (err: any) {
|
||||
if (err.code === 'EISDIR') {
|
||||
await handler.rmtree(resolved)
|
||||
} else {
|
||||
throw err
|
||||
}
|
||||
}
|
||||
|
||||
// also delete the alias file
|
||||
if (path !== resolved) {
|
||||
await handler.unlink(path)
|
||||
}
|
||||
}
|
||||
}
|
||||
25
@xen-orchestra/disk-transform/src/DiskAlias.test.mts
Normal file
25
@xen-orchestra/disk-transform/src/DiskAlias.test.mts
Normal file
@@ -0,0 +1,25 @@
|
||||
import { test } from 'node:test'
|
||||
import assert from 'node:assert'
|
||||
import { DiskAlias } from './DiskAlias.mjs'
|
||||
|
||||
test('DiskAlias', async t => {
|
||||
await t.test('isAlias() recognizes only *.alias.<extension> files', () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
assert.equal(vhdAlias.isAlias('filename.alias.vhd'), true)
|
||||
assert.equal(vhdAlias.isAlias('alias.vhd'), false)
|
||||
assert.equal(vhdAlias.isAlias('filename.vhd'), false)
|
||||
assert.equal(vhdAlias.isAlias('filename.alias.vhd.other'), false)
|
||||
})
|
||||
|
||||
await t.test('isAlias() is scoped to its own extension', () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
const qcow2Alias = new DiskAlias('qcow2')
|
||||
assert.equal(vhdAlias.isAlias('filename.alias.qcow2'), false)
|
||||
assert.equal(qcow2Alias.isAlias('filename.alias.qcow2'), true)
|
||||
})
|
||||
|
||||
await t.test('resolve() returns the path in argument for a non alias file', async () => {
|
||||
const vhdAlias = new DiskAlias('vhd')
|
||||
assert.equal(await vhdAlias.resolve(undefined as any, 'filename.vhd'), 'filename.vhd')
|
||||
})
|
||||
})
|
||||
@@ -31,15 +31,11 @@ export class DiskLargerBlock extends RandomAccessDisk {
|
||||
throw new Error('Method not implemented.')
|
||||
}
|
||||
async readBlock(index: number): Promise<DiskBlock> {
|
||||
if (!this.hasBlock(index)) {
|
||||
throw new Error(`Block ${index} not present in this disk`)
|
||||
}
|
||||
// @todo handle partial block at the end
|
||||
const source = this.source
|
||||
const destinationBlockData = Buffer.alloc(this.getBlockSize(), 0)
|
||||
const destinationBlock = Buffer.alloc(this.getBlockSize(), 0)
|
||||
const blockRatio = this.#blockSize / source.getBlockSize()
|
||||
const firstSourceBlockIndex = index * blockRatio
|
||||
for (let i = firstSourceBlockIndex; i < firstSourceBlockIndex + blockRatio; i++) {
|
||||
for (let i = index * blockRatio; i < (index + 1) * blockRatio; i++) {
|
||||
let data: Buffer | undefined
|
||||
if (source.hasBlock(i)) {
|
||||
data = (await source.readBlock(i)).data
|
||||
@@ -55,12 +51,12 @@ export class DiskLargerBlock extends RandomAccessDisk {
|
||||
}
|
||||
}
|
||||
if (data !== undefined) {
|
||||
data.copy(destinationBlockData, (i - firstSourceBlockIndex) * source.getBlockSize())
|
||||
data.copy(destinationBlock, i * source.getBlockSize())
|
||||
}
|
||||
}
|
||||
return {
|
||||
index,
|
||||
data: destinationBlockData,
|
||||
data: destinationBlock,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -70,24 +66,22 @@ export class DiskLargerBlock extends RandomAccessDisk {
|
||||
|
||||
getBlockIndexes(): Array<number> {
|
||||
const maxBlock = Math.ceil(this.getVirtualSize() / this.getBlockSize())
|
||||
const blockRatio = this.getBlockSize() / this.source.getBlockSize()
|
||||
const indexes = []
|
||||
for (let i = 0; i < maxBlock; i++) {
|
||||
if (this.hasBlock(i)) {
|
||||
indexes.push(i)
|
||||
for (let j = 0; j < blockRatio; j++) {
|
||||
if (this.source.hasBlock(i * blockRatio + j)) {
|
||||
indexes.push(i)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return indexes
|
||||
}
|
||||
|
||||
getBlockIndexesCount(): number {
|
||||
let count = 0
|
||||
const maxBlock = Math.ceil(this.getVirtualSize() / this.getBlockSize())
|
||||
for (let i = 0; i < maxBlock; i++) {
|
||||
if (this.hasBlock(i)) {
|
||||
count++
|
||||
}
|
||||
}
|
||||
return count
|
||||
let blockRatio = this.getBlockSize() / this.source.getBlockSize()
|
||||
return this.#source.getBlockIndexesCount() / blockRatio
|
||||
}
|
||||
|
||||
hasBlock(index: number): boolean {
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import assert, { strictEqual } from 'node:assert'
|
||||
import assert from 'node:assert'
|
||||
import { test } from 'node:test'
|
||||
import { DiskLargerBlock } from './DiskLargerBlock.mjs'
|
||||
import { RandomAccessDisk, DiskBlock, Disk } from './Disk.mjs'
|
||||
@@ -45,7 +45,7 @@ class MockDisk extends RandomAccessDisk {
|
||||
this.closed = true
|
||||
}
|
||||
isDifferencing(): boolean {
|
||||
return this.parentDisk !== null || this.isDiff
|
||||
return this.isDiff
|
||||
}
|
||||
instantiateParent(): RandomAccessDisk {
|
||||
if (!this.parentDisk) throw new Error('No parent disk available')
|
||||
@@ -118,29 +118,6 @@ test('readBlock with simple block mapping', async () => {
|
||||
assert(result.data.subarray(512).equals(block2))
|
||||
})
|
||||
|
||||
test('readBlock at index > 0 places source data at block-relative offsets', async () => {
|
||||
// Regression test: a large block after index 0 must be assembled from its own
|
||||
// source blocks at offsets relative to the start of that large block.
|
||||
// With distinct, non-zero patterns this catches the case where copy() targets an
|
||||
// absolute (disk-wide) offset and silently produces a zeroed block.
|
||||
const blockC = createPatternBuffer(512, 'C')
|
||||
const blockD = createPatternBuffer(512, 'D')
|
||||
const source = new MockDisk(512, 4096, [
|
||||
[2, blockC],
|
||||
[3, blockD],
|
||||
])
|
||||
await source.init()
|
||||
|
||||
const disk = new DiskLargerBlock(source, 1024) // blockRatio = 2, so large block 1 = source blocks 2 & 3
|
||||
await disk.init()
|
||||
|
||||
const result = await disk.readBlock(1)
|
||||
assert.strictEqual(result.index, 1)
|
||||
assert.strictEqual(result.data.length, 1024)
|
||||
assert(result.data.subarray(0, 512).equals(blockC))
|
||||
assert(result.data.subarray(512).equals(blockD))
|
||||
})
|
||||
|
||||
test('hasBlock behavior', async () => {
|
||||
const source = new MockDisk(512, 2048, [
|
||||
[0, Buffer.alloc(512)],
|
||||
@@ -237,34 +214,6 @@ test('close propagation', async () => {
|
||||
await disk.close()
|
||||
assert.strictEqual(source.closed, true)
|
||||
})
|
||||
test('getBlockIndexesCount', async () => {
|
||||
const block = createPatternBuffer(512, 'BLOCK')
|
||||
let source = new MockDisk(512, 4096, [
|
||||
[2, block],
|
||||
[3, block],
|
||||
])
|
||||
await source.init()
|
||||
|
||||
let disk = new DiskLargerBlock(source, 1024)
|
||||
await disk.init()
|
||||
assert.strictEqual(disk.getBlockIndexesCount(), 1)
|
||||
assert.strictEqual(disk.getBlockIndexesCount(), disk.getBlockIndexes().length)
|
||||
|
||||
await disk.close()
|
||||
|
||||
source = new MockDisk(512, 4096, [
|
||||
[0, block],
|
||||
[3, block],
|
||||
])
|
||||
await source.init()
|
||||
|
||||
disk = new DiskLargerBlock(source, 1024)
|
||||
await disk.init()
|
||||
assert.strictEqual(disk.getBlockIndexesCount(), 2)
|
||||
assert.strictEqual(disk.getBlockIndexesCount(), disk.getBlockIndexes().length)
|
||||
|
||||
await disk.close()
|
||||
})
|
||||
|
||||
test('generator', async () => {
|
||||
const source = new MockDisk(512, 1024)
|
||||
@@ -276,29 +225,3 @@ test('generator', async () => {
|
||||
assert.strictEqual(block.data.length, 1024)
|
||||
}
|
||||
})
|
||||
|
||||
test('readblock missing block throws', async () => {
|
||||
const parentBlock = createPatternBuffer(512, 'PARENT')
|
||||
const childBlock = createPatternBuffer(512, 'CHILD')
|
||||
const sourceParent = new MockDisk(512, 2048, [
|
||||
[0, parentBlock],
|
||||
[1, parentBlock],
|
||||
[2, parentBlock],
|
||||
[3, parentBlock],
|
||||
])
|
||||
await sourceParent.init()
|
||||
const source = new MockDisk(512, 2048, [[2, childBlock]])
|
||||
source.parentDisk = sourceParent
|
||||
await source.init()
|
||||
|
||||
const disk = new DiskLargerBlock(source, 1024)
|
||||
await disk.init()
|
||||
assert.strictEqual(disk.getBlockIndexesCount(), 1)
|
||||
for await (const block of disk.diskBlocks()) {
|
||||
assert.strictEqual(block.index, 1)
|
||||
assert.ok(block.data.slice(0, 512).equals(childBlock), 'missing child data ')
|
||||
assert.ok(block.data.slice(512, 1024).equals(parentBlock), 'missing parent data')
|
||||
}
|
||||
|
||||
await assert.rejects(() => disk.readBlock(0))
|
||||
})
|
||||
|
||||
@@ -1,6 +1,11 @@
|
||||
import type { Readable } from 'node:stream'
|
||||
|
||||
export type FileDescriptor = number
|
||||
/** A file descriptor as returned by openFile() - implementation-defined (e.g. a number on local fs) */
|
||||
export interface FileArg {
|
||||
fd: unknown
|
||||
path: string
|
||||
}
|
||||
export type FileDescriptor = number | string | FileArg
|
||||
|
||||
/**
|
||||
* a base interface is defined to be able to add other accessor ,
|
||||
@@ -13,10 +18,10 @@ export type FileDescriptor = number
|
||||
export interface FileAccessor {
|
||||
isEncrypted: boolean
|
||||
list(path: string, opts?: unknown): Promise<string[]>
|
||||
closeFile(filehandle: number): Promise<void>
|
||||
openFile(path: string, opts?: unknown): Promise<number>
|
||||
closeFile(filehandle: FileDescriptor): Promise<void>
|
||||
openFile(path: string, opts?: unknown): Promise<FileDescriptor>
|
||||
read(
|
||||
file: string | number,
|
||||
file: FileDescriptor,
|
||||
buffer: Buffer | DataView,
|
||||
position: number
|
||||
): Promise<{ bytesRead: number; buffer: Buffer | DataView }>
|
||||
@@ -26,6 +31,6 @@ export interface FileAccessor {
|
||||
mktree(path: string): Promise<void>
|
||||
rmtree(path: string): Promise<void>
|
||||
unlink(path: string): Promise<void>
|
||||
outputStream(stream: Readable): Promise<void>
|
||||
outputStream(path: string, input: Readable, opts?: unknown): Promise<void>
|
||||
rename(path: string, newPath: string): Promise<void>
|
||||
}
|
||||
|
||||
@@ -1,63 +1,60 @@
|
||||
import { DiskBlock, RandomAccessDisk } from "./Disk.mjs";
|
||||
import { FileAccessor } from "./FileAccessor.mjs";
|
||||
import { DiskBlock, RandomAccessDisk } from './Disk.mjs'
|
||||
import { FileAccessor, FileDescriptor } from './FileAccessor.mjs'
|
||||
|
||||
export class RawDisk extends RandomAccessDisk {
|
||||
#accessor
|
||||
#path
|
||||
#descriptor: FileDescriptor | undefined
|
||||
#blockSize: number
|
||||
#size: number | undefined
|
||||
|
||||
export class RawDisk extends RandomAccessDisk{
|
||||
#accessor
|
||||
#path
|
||||
#descriptor:number|undefined
|
||||
#blockSize:number
|
||||
#size: number|undefined
|
||||
|
||||
|
||||
constructor(accessor: FileAccessor, path: string, blockSize:number){
|
||||
super()
|
||||
this.#accessor= accessor
|
||||
this.#path = path
|
||||
this.#blockSize = blockSize
|
||||
constructor(accessor: FileAccessor, path: string, blockSize: number) {
|
||||
super()
|
||||
this.#accessor = accessor
|
||||
this.#path = path
|
||||
this.#blockSize = blockSize
|
||||
}
|
||||
async readBlock(index: number): Promise<DiskBlock> {
|
||||
if (this.#descriptor === undefined) {
|
||||
throw new Error("Can't call readBlock before init")
|
||||
}
|
||||
async readBlock(index: number): Promise<DiskBlock> {
|
||||
if(this.#descriptor === undefined){
|
||||
throw new Error("Can't call readBlock before init");
|
||||
}
|
||||
const data = Buffer.alloc(this.getBlockSize(), 0)
|
||||
await this.#accessor.read(this.#descriptor, data, index*this.getBlockSize())
|
||||
return {
|
||||
index,
|
||||
data
|
||||
}
|
||||
const data = Buffer.alloc(this.getBlockSize(), 0)
|
||||
await this.#accessor.read(this.#descriptor, data, index * this.getBlockSize())
|
||||
return {
|
||||
index,
|
||||
data,
|
||||
}
|
||||
getVirtualSize(): number {
|
||||
if(this.#size === undefined){
|
||||
throw new Error("Can't call getVirtualsize before init");
|
||||
}
|
||||
return this.#size
|
||||
}
|
||||
getVirtualSize(): number {
|
||||
if (this.#size === undefined) {
|
||||
throw new Error("Can't call getVirtualsize before init")
|
||||
}
|
||||
getBlockSize(): number {
|
||||
return this.#blockSize
|
||||
return this.#size
|
||||
}
|
||||
getBlockSize(): number {
|
||||
return this.#blockSize
|
||||
}
|
||||
async init(): Promise<void> {
|
||||
this.#descriptor = await this.#accessor.openFile(this.#path)
|
||||
this.#size = await this.#accessor.getSize(this.#path)
|
||||
}
|
||||
async close(): Promise<void> {
|
||||
this.#descriptor && (await this.#accessor.closeFile(this.#descriptor))
|
||||
this.#descriptor = undefined
|
||||
this.#size = undefined
|
||||
}
|
||||
isDifferencing(): boolean {
|
||||
return false
|
||||
}
|
||||
getBlockIndexes(): Array<number> {
|
||||
const nbBlocks = Math.ceil(this.getVirtualSize() / this.getBlockSize())
|
||||
const index = []
|
||||
for (let i = 0; i < nbBlocks; i++) {
|
||||
index.push(i)
|
||||
}
|
||||
async init(): Promise<void> {
|
||||
this.#descriptor = await this.#accessor.openFile(this.#path)
|
||||
this.#size = await this.#accessor.getSize(this.#path)
|
||||
}
|
||||
async close(): Promise<void> {
|
||||
this.#descriptor && await this.#accessor.closeFile(this.#descriptor)
|
||||
this.#descriptor = undefined
|
||||
this.#size = undefined
|
||||
}
|
||||
isDifferencing(): boolean {
|
||||
return false
|
||||
}
|
||||
getBlockIndexes(): Array<number> {
|
||||
const nbBlocks = Math.ceil(this.getVirtualSize()/ this.getBlockSize())
|
||||
const index =[]
|
||||
for(let i=0; i < nbBlocks; i ++){
|
||||
index.push(i)
|
||||
}
|
||||
return index
|
||||
}
|
||||
hasBlock(index: number): boolean {
|
||||
return index * this.getBlockSize() < this.getVirtualSize()
|
||||
}
|
||||
|
||||
}
|
||||
return index
|
||||
}
|
||||
hasBlock(index: number): boolean {
|
||||
return index * this.getBlockSize() < this.getVirtualSize()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,18 @@
|
||||
export { Disk, DiskBlock, RandomAccessDisk } from './Disk.mjs'
|
||||
export {
|
||||
DiskAlias,
|
||||
DiskAliasError,
|
||||
AliasMissingError,
|
||||
AliasIsDirectoryError,
|
||||
AliasChainError,
|
||||
AliasTooLongError,
|
||||
ALIAS_MAX_PATH_LENGTH,
|
||||
} from './DiskAlias.mjs'
|
||||
export { DiskChain } from './DiskChain.mjs'
|
||||
export { DiskLargerBlock } from './DiskLargerBlock.mjs'
|
||||
export { DiskSmallerBlock } from './DiskSmallerBlock.mjs'
|
||||
export { NegativeDisk } from './NegativeDisk.mjs'
|
||||
export { FileAccessor } from './FileAccessor.mjs'
|
||||
export { FileAccessor, FileArg, FileDescriptor } from './FileAccessor.mjs'
|
||||
export { DiskPassthrough, RandomDiskPassthrough } from './DiskPassthrough.mjs'
|
||||
export { RawDisk } from './RawDisk.mjs'
|
||||
export { ReadAhead } from './ReadAhead.mjs'
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"private": false,
|
||||
"name": "@xen-orchestra/fs",
|
||||
"version": "4.9.3",
|
||||
"version": "4.9.2",
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"description": "The File System for Xen Orchestra backups.",
|
||||
"homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/fs",
|
||||
|
||||
@@ -441,11 +441,7 @@ export default class S3Handler extends RemoteHandlerAbstract {
|
||||
new DeleteObjectsCommand({
|
||||
Bucket: this.#bucket,
|
||||
Delete: {
|
||||
// only keep the key: `ETag` and `Size` are also part of `ObjectIdentifier`, where they
|
||||
// mean "delete only if it still matches", and passing the whole listed object would
|
||||
// serialize them in the request. Beyond making the deletion conditional, some
|
||||
// providers reject these elements with a `MalformedXML` error.
|
||||
Objects: (result.Contents ?? []).map(({ Key }) => ({ Key })),
|
||||
Objects: result.Contents ?? [],
|
||||
},
|
||||
})
|
||||
)
|
||||
|
||||
@@ -164,3 +164,13 @@ export abstract class RemoteHandlerAbstract {
|
||||
abstract useVhdDirectory(): boolean
|
||||
abstract addPrefix(prefix: string): RemoteHandlerAbstract
|
||||
}
|
||||
|
||||
// ─── Handler factories ───────────────────────────────────────────────────────
|
||||
|
||||
export interface SyncedHandler {
|
||||
dispose: () => Promise<void>
|
||||
value: RemoteHandlerAbstract
|
||||
}
|
||||
|
||||
export declare function getHandler(remote: RemoteInfo, ...rest: unknown[]): RemoteHandlerAbstract
|
||||
export declare function getSyncedHandler(remote: RemoteInfo, ...rest: unknown[]): Promise<SyncedHandler>
|
||||
|
||||
@@ -38,7 +38,8 @@ immutabilityDuration = "7d"
|
||||
|
||||
## CLI commands
|
||||
|
||||
- **`xo-immutable-remote`**: Start the watching daemon. Must be kept running to protect new backups reliably. It lifts expired immutability on startup, then every `liftEvery`.
|
||||
- **`xo-immutable-remote`**: Start the watching daemon. Must be kept running to protect new backups reliably.
|
||||
- **`xo-lift-remote-immutability`**: Manually trigger a lifting pass. If `liftEvery` is set in the config, the process continues running and repeats the check on that interval.
|
||||
|
||||
## How protection works
|
||||
|
||||
@@ -85,8 +86,6 @@ The expiry reference is the **datetime in the filename**, not the file's `mtime`
|
||||
|
||||
On the **first lift run after startup**, all backup files are scanned unconditionally (full scan). This catches orphaned immutable files left by a previous partial or interrupted lock. Subsequent runs use a fast-path: only backups whose `.json` sentinel is currently immutable are processed.
|
||||
|
||||
The first run also walks the disk directories (`xo-vm-backups/<vmUUID>/vdis/<jobId>/<vdiId>/`) directly and lifts any expired disk found there, still using the datetime in its own filename. Both the locking and the regular lifting name a backup's disks from its `<datetime>.json`, so a disk stops being reachable that way once XO's retention has deleted that json — or once a merge has renamed the disk, since the surviving `data/<datetime>.vhd` then carries the datetime of the older backup its blocks came from. Such a disk would otherwise stay immutable forever, and an immutable disk prevents XO from ever merging or deleting the backups of that VDI.
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Some files are still immutable after the duration expired
|
||||
@@ -114,10 +113,8 @@ If one or a few VM had an issue and need manual cleanup, you can manually lift t
|
||||
4. As root on the file server, run:
|
||||
```bash
|
||||
chattr +i /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/*.json
|
||||
chattr +i -R /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/vdis/*/*/*.vhd
|
||||
chattr +i -R /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/vdis/*/*/data/*.vhd
|
||||
chattr +i -R /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/vdis/
|
||||
```
|
||||
Lock the disks, **not** the directories that hold them: `chattr +i -R …/vdis/` also locks `vdis`, the job and VDI directories and `data`, and an immutable directory rejects the files of the next backup, so every later run of that VM would fail. Depending on whether the remote uses VHD directories, one of the two commands above may report that it matched nothing.
|
||||
|
||||
Note that this VM will be mutable between step 2 and 4, it's up to you to document and test the backup after.
|
||||
|
||||
@@ -127,7 +124,7 @@ Change the setting. The next lift cycle will use the new duration; files already
|
||||
|
||||
### Reducing the immutability duration
|
||||
|
||||
Change the setting, then restart `xo-immutable-remote` to apply immediately, or wait for the next scheduled `liftEvery` cycle.
|
||||
Change the setting, then run `xo-lift-remote-immutability` to apply immediately, or wait for the next scheduled `liftEvery` cycle.
|
||||
|
||||
### Why are my incremental backups not marked as protected in XO?
|
||||
|
||||
|
||||
@@ -54,7 +54,8 @@ immutabilityDuration = "7d"
|
||||
|
||||
## CLI commands
|
||||
|
||||
- **`xo-immutable-remote`**: Start the watching daemon. Must be kept running to protect new backups reliably. It lifts expired immutability on startup, then every `liftEvery`.
|
||||
- **`xo-immutable-remote`**: Start the watching daemon. Must be kept running to protect new backups reliably.
|
||||
- **`xo-lift-remote-immutability`**: Manually trigger a lifting pass. If `liftEvery` is set in the config, the process continues running and repeats the check on that interval.
|
||||
|
||||
## How protection works
|
||||
|
||||
@@ -101,8 +102,6 @@ The expiry reference is the **datetime in the filename**, not the file's `mtime`
|
||||
|
||||
On the **first lift run after startup**, all backup files are scanned unconditionally (full scan). This catches orphaned immutable files left by a previous partial or interrupted lock. Subsequent runs use a fast-path: only backups whose `.json` sentinel is currently immutable are processed.
|
||||
|
||||
The first run also walks the disk directories (`xo-vm-backups/<vmUUID>/vdis/<jobId>/<vdiId>/`) directly and lifts any expired disk found there, still using the datetime in its own filename. Both the locking and the regular lifting name a backup's disks from its `<datetime>.json`, so a disk stops being reachable that way once XO's retention has deleted that json — or once a merge has renamed the disk, since the surviving `data/<datetime>.vhd` then carries the datetime of the older backup its blocks came from. Such a disk would otherwise stay immutable forever, and an immutable disk prevents XO from ever merging or deleting the backups of that VDI.
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Some files are still immutable after the duration expired
|
||||
@@ -117,7 +116,7 @@ Restart `xo-immutable-remote`. The first lift run after startup always performs
|
||||
chattr -i -R /path/to/remote/on/fileserver/
|
||||
```
|
||||
|
||||
### Make one VM temporarily mutable again
|
||||
### Make one VM mutable again temporarly
|
||||
|
||||
If one or a few VM had an issue and need manual cleanup, you can manually lift the immutability for one VM.
|
||||
|
||||
@@ -126,16 +125,14 @@ If one or a few VM had an issue and need manual cleanup, you can manually lift t
|
||||
```bash
|
||||
chattr -i -R /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>
|
||||
```
|
||||
3. Run the backup job, it will fix what is repairable and purge the non recoverable backups
|
||||
3. run the backup job, it will fix what is reparable and purge the non recoverable backups
|
||||
4. As root on the file server, run:
|
||||
```bash
|
||||
chattr +i /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/*.json
|
||||
chattr +i -R /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/vdis/*/*/*.vhd
|
||||
chattr +i -R /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/vdis/*/*/data/*.vhd
|
||||
chattr +i -R /path/to/remote/on/fileserver/xo-vm-backups/<vm uuid>/vdis/
|
||||
```
|
||||
Lock the disks, **not** the directories that hold them: `chattr +i -R …/vdis/` also locks `vdis`, the job and VDI directories and `data`, and an immutable directory rejects the files of the next backup, so every later run of that VM would fail. Depending on whether the remote uses VHD directories, one of the two commands above may report that it matched nothing.
|
||||
|
||||
Note that this VM will be mutable between step 2 and 4, it's up to you to document and test the backup after.
|
||||
Note that this VM will be mutable between step 2 and 4, it's up to you to document and test the backup after
|
||||
|
||||
### Increasing the immutability duration
|
||||
|
||||
@@ -143,7 +140,7 @@ Change the setting. The next lift cycle will use the new duration; files already
|
||||
|
||||
### Reducing the immutability duration
|
||||
|
||||
Change the setting, then restart `xo-immutable-remote` to apply immediately, or wait for the next scheduled `liftEvery` cycle.
|
||||
Change the setting, then run `xo-lift-remote-immutability` to apply immediately, or wait for the next scheduled `liftEvery` cycle.
|
||||
|
||||
### Why are my incremental backups not marked as protected in XO?
|
||||
|
||||
|
||||
@@ -16,13 +16,13 @@
|
||||
"xo-immutable-remote": "./dist/protectRemotes.mjs"
|
||||
},
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"version": "3.0.5",
|
||||
"version": "3.0.3",
|
||||
"engines": {
|
||||
"node": ">=20.0.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@xen-orchestra/backups": "^0.74.2",
|
||||
"@xen-orchestra/backups": "^0.73.7",
|
||||
"@xen-orchestra/log": "^0.7.2",
|
||||
"app-conf": "^3.0.0",
|
||||
"execa": "^5.0.0",
|
||||
|
||||
@@ -8,18 +8,17 @@ export async function makeImmutable(dirPath: string): Promise<void> {
|
||||
// chattr processes all paths even when some are missing (it does not abort on the first
|
||||
// error), so every existing path is correctly lifted.
|
||||
//
|
||||
// Per-path "while trying to stat" messages (ENOENT) are silently ignored — these are always
|
||||
// expected for optional paths (.xva, .alias.vhd, …) that are absent in delta backups. chattr
|
||||
// translates that whole message, so it is run under `LC_ALL=C`: without it, every batch
|
||||
// containing an optional missing path fails on a localised system, which means no backup ever
|
||||
// gets locked there.
|
||||
// Per-path "while trying to stat" messages (ENOENT) are silently ignored regardless of
|
||||
// locale — these are always expected for optional paths (.xva, .alias.vhd, …) that are
|
||||
// absent in delta backups. chattr localises the error description but "while trying to
|
||||
// stat" is always emitted in English, so we match on that suffix only.
|
||||
//
|
||||
// Any other error (e.g. EAGAIN on NFS when the file is still open, permission denied) is
|
||||
// retried up to 3 times with a 1 s delay before being re-thrown.
|
||||
async function execChattrWithMissingFiles(args: string[]): Promise<void> {
|
||||
for (let attempt = 0; ; attempt++) {
|
||||
try {
|
||||
await execa('chattr', args, { env: { LC_ALL: 'C' } })
|
||||
await execa('chattr', args)
|
||||
return
|
||||
} catch (err) {
|
||||
const stderr = (err as ExecaError).stderr ?? ''
|
||||
|
||||
@@ -1,177 +0,0 @@
|
||||
import { describe, it } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import fs from 'node:fs/promises'
|
||||
import path from 'node:path'
|
||||
import { tmpdir } from 'node:os'
|
||||
import { rimraf } from 'rimraf'
|
||||
import execa from 'execa'
|
||||
|
||||
import * as Directory from './directory.mjs'
|
||||
import { liftRemoteImmutability } from './liftProtection.mjs'
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Constants
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const ONE_DAY_MS = 24 * 60 * 60 * 1000
|
||||
|
||||
const VM_UUID = 'aaaaaaaa-0000-0000-0000-000000000001'
|
||||
const JOB_UUID = 'bbbbbbbb-0000-0000-0000-000000000001'
|
||||
const VDI_UUID = 'cccccccc-0000-0000-0000-000000000001'
|
||||
|
||||
/** Well past any reasonable immutabilityDuration. */
|
||||
const EXPIRED_DATE = '20240115T120000Z'
|
||||
/** Inside the window: the expiry reference is the datetime in the name, not the file's dates. */
|
||||
const RECENT_DATE = new Date().toISOString().replace(/[-:.]/g, '').slice(0, 15) + 'Z'
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// Recursively lift all immutable flags inside `root`, then delete the tree.
|
||||
// Must be run as root since chattr requires elevated privileges.
|
||||
async function cleanupRoot(root: string): Promise<void> {
|
||||
try {
|
||||
await execa('chattr', ['-i', '-R', root])
|
||||
} catch (_err) {}
|
||||
await rimraf(root)
|
||||
}
|
||||
|
||||
async function makeRoot(): Promise<string> {
|
||||
return await fs.mkdtemp(path.join(tmpdir(), 'immut-lift-test-'))
|
||||
}
|
||||
|
||||
function vmDirOf(root: string): string {
|
||||
return path.join(root, 'xo-vm-backups', VM_UUID)
|
||||
}
|
||||
|
||||
function vdiDirOf(root: string): string {
|
||||
return path.join(vmDirOf(root), 'vdis', JOB_UUID, VDI_UUID)
|
||||
}
|
||||
|
||||
// Creates `vdis/<jobId>/<vdiId>/<datetime>.alias.vhd` plus the VHD directory it points at, the way
|
||||
// XO lays them out, and returns both paths along with one block file inside the VHD directory.
|
||||
async function writeDisk(root: string, datetime: string) {
|
||||
const vdiDir = vdiDirOf(root)
|
||||
const dataDir = path.join(vdiDir, 'data')
|
||||
const vhdDir = path.join(dataDir, `${datetime}.vhd`)
|
||||
const blockFile = path.join(vhdDir, 'blocks', '0', '0')
|
||||
|
||||
await fs.mkdir(path.dirname(blockFile), { recursive: true })
|
||||
await fs.writeFile(blockFile, 'block')
|
||||
await fs.writeFile(path.join(vhdDir, 'footer'), 'footer')
|
||||
|
||||
const alias = path.join(vdiDir, `${datetime}.alias.vhd`)
|
||||
await fs.writeFile(alias, path.relative(vdiDir, vhdDir))
|
||||
|
||||
return { alias, vhdDir, blockFile }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('liftProtection/liftRemoteImmutability', async () => {
|
||||
it('lifts expired disks that no metadata json names any more', async () => {
|
||||
const root = await makeRoot()
|
||||
try {
|
||||
// Retention deletes the json first and leaves the disks to the next cleanVm, so nothing names
|
||||
// them: this is the state the sentinel-driven pass cannot reach.
|
||||
const { alias, vhdDir, blockFile } = await writeDisk(root, EXPIRED_DATE)
|
||||
await Directory.makeImmutableBatch([alias, vhdDir])
|
||||
|
||||
assert.strictEqual(await Directory.isImmutable(alias), true, 'alias should start immutable')
|
||||
assert.strictEqual(await Directory.isImmutable(vhdDir), true, 'VHD directory should start immutable')
|
||||
|
||||
await liftRemoteImmutability(root, ONE_DAY_MS, true)
|
||||
|
||||
assert.strictEqual(await Directory.isImmutable(alias), false, 'alias should be lifted')
|
||||
assert.strictEqual(await Directory.isImmutable(vhdDir), false, 'VHD directory should be lifted')
|
||||
// A VHD directory is useless to XO unless its blocks are writable too: the merge moves block
|
||||
// files out of it.
|
||||
assert.strictEqual(await Directory.isImmutable(blockFile), false, 'blocks should be lifted too')
|
||||
|
||||
// and the files are really usable again
|
||||
await fs.unlink(blockFile)
|
||||
await fs.unlink(alias)
|
||||
} finally {
|
||||
await cleanupRoot(root)
|
||||
}
|
||||
})
|
||||
|
||||
it('keeps disks inside the immutability window locked', async () => {
|
||||
const root = await makeRoot()
|
||||
try {
|
||||
const { alias, vhdDir, blockFile } = await writeDisk(root, RECENT_DATE)
|
||||
await Directory.makeImmutableBatch([alias, vhdDir])
|
||||
|
||||
await liftRemoteImmutability(root, ONE_DAY_MS, true)
|
||||
|
||||
assert.strictEqual(await Directory.isImmutable(alias), true, 'recent alias must stay immutable')
|
||||
assert.strictEqual(await Directory.isImmutable(vhdDir), true, 'recent VHD directory must stay immutable')
|
||||
assert.strictEqual(await Directory.isImmutable(blockFile), true, 'recent blocks must stay immutable')
|
||||
|
||||
await assert.rejects(fs.unlink(alias), { code: 'EPERM' })
|
||||
} finally {
|
||||
await cleanupRoot(root)
|
||||
}
|
||||
})
|
||||
|
||||
it('does not sweep the disk directories outside of a full scan', async () => {
|
||||
const root = await makeRoot()
|
||||
try {
|
||||
const { alias, vhdDir } = await writeDisk(root, EXPIRED_DATE)
|
||||
await Directory.makeImmutableBatch([alias, vhdDir])
|
||||
|
||||
await liftRemoteImmutability(root, ONE_DAY_MS, false)
|
||||
|
||||
assert.strictEqual(await Directory.isImmutable(alias), true, 'alias should be untouched')
|
||||
assert.strictEqual(await Directory.isImmutable(vhdDir), true, 'VHD directory should be untouched')
|
||||
} finally {
|
||||
await cleanupRoot(root)
|
||||
}
|
||||
})
|
||||
|
||||
it('lifts a disk whose name does not match the datetime of the backup referencing it', async () => {
|
||||
const root = await makeRoot()
|
||||
try {
|
||||
// Shape left by a merge: the alias of the recent backup points at the VHD directory of the
|
||||
// older one, whose blocks it now holds.
|
||||
const { vhdDir, blockFile } = await writeDisk(root, EXPIRED_DATE)
|
||||
const alias = path.join(vdiDirOf(root), `${RECENT_DATE}.alias.vhd`)
|
||||
await fs.writeFile(alias, path.relative(vdiDirOf(root), vhdDir))
|
||||
await fs.unlink(path.join(vdiDirOf(root), `${EXPIRED_DATE}.alias.vhd`))
|
||||
await Directory.makeImmutableBatch([alias, vhdDir])
|
||||
|
||||
await liftRemoteImmutability(root, ONE_DAY_MS, true)
|
||||
|
||||
// The VHD directory carries an expired datetime, so it is released and stays mergeable — the
|
||||
// reason mtime cannot be the reference: every merge would push it forward and it would never
|
||||
// expire.
|
||||
assert.strictEqual(await Directory.isImmutable(vhdDir), false, 'merged VHD directory should be lifted')
|
||||
assert.strictEqual(await Directory.isImmutable(blockFile), false, 'its blocks should be lifted')
|
||||
assert.strictEqual(await Directory.isImmutable(alias), true, 'the recent alias keeps its lock')
|
||||
} finally {
|
||||
await cleanupRoot(root)
|
||||
}
|
||||
})
|
||||
|
||||
it('still lifts through the metadata json when it is present', async () => {
|
||||
const root = await makeRoot()
|
||||
try {
|
||||
const { alias, vhdDir } = await writeDisk(root, EXPIRED_DATE)
|
||||
const json = path.join(vmDirOf(root), `${EXPIRED_DATE}.json`)
|
||||
await fs.writeFile(json, '{}')
|
||||
await Directory.makeImmutableBatch([json, alias, vhdDir])
|
||||
|
||||
// not a full scan: the fast path applies, and the json is immutable so it is picked up
|
||||
await liftRemoteImmutability(root, ONE_DAY_MS, false)
|
||||
|
||||
assert.strictEqual(await Directory.isImmutable(json), false, 'json should be lifted')
|
||||
assert.strictEqual(await Directory.isImmutable(alias), false, 'alias should be lifted')
|
||||
assert.strictEqual(await Directory.isImmutable(vhdDir), false, 'VHD directory should be lifted')
|
||||
} finally {
|
||||
await cleanupRoot(root)
|
||||
}
|
||||
})
|
||||
})
|
||||
@@ -118,68 +118,6 @@ async function liftExpiredVmBackups(root: string, immutabilityDuration: number,
|
||||
})
|
||||
}
|
||||
|
||||
// `liftExpiredVmBackups` names the files of a backup from the datetime of its `<datetime>.json`,
|
||||
// like the watcher does when locking them. A disk can outlive that name:
|
||||
//
|
||||
// - retention deletes the metadata json first and leaves the disks to the next `cleanVm`, so
|
||||
// nothing names them any more;
|
||||
// - a merge renames a disk, and the surviving `data/<datetime>.vhd` keeps the name of the older
|
||||
// backup its blocks came from.
|
||||
//
|
||||
// Such a disk would stay immutable forever — a full scan does not help, it only bypasses the
|
||||
// `isImmutable` fast-path — and an immutable disk blocks every future merge and deletion in its VDI
|
||||
// directory. So walk the VDI directories themselves and lift what is expired, using the datetime in
|
||||
// each entry's own name, which is the reference the other passes use too.
|
||||
//
|
||||
// Only runs on the first pass after startup: it recovers states that should not happen, and looking
|
||||
// hourly would not make it more effective.
|
||||
async function liftExpiredOrphanDisks(root: string, immutabilityDuration: number): Promise<void> {
|
||||
const threshold = Date.now() - immutabilityDuration
|
||||
const vmDirs = await listDirs(join(root, 'xo-vm-backups'))
|
||||
debug('scanning VDI directories for expired disks', { count: vmDirs.length })
|
||||
await asyncEach(vmDirs, async vmDir => {
|
||||
// disks live under `vdis/<jobId>/<vdiId>/`, so two levels of directories to walk first
|
||||
const jobDirs = await listDirs(join(vmDir, 'vdis'))
|
||||
const vdiDirs = (await Promise.all(jobDirs.map(jobDir => listDirs(jobDir)))).flat()
|
||||
|
||||
await asyncEach(vdiDirs, async vdiDir => {
|
||||
try {
|
||||
// `<datetime>.vhd` (flat VHD or alias) and `<datetime>.alias.vhd`
|
||||
const entries = await fsp.readdir(vdiDir, { withFileTypes: true })
|
||||
const candidates = entries.map(entry => join(vdiDir, entry.name))
|
||||
|
||||
// `data/<datetime>.vhd` VHD directories. They are locked recursively, but the attribute is
|
||||
// set on the directory itself too, so its own entry is enough to decide — no need to look
|
||||
// at the blocks inside.
|
||||
if (entries.some(entry => entry.name === 'data' && entry.isDirectory())) {
|
||||
const dataDir = join(vdiDir, 'data')
|
||||
candidates.push(...(await fsp.readdir(dataDir)).map(name => join(dataDir, name)))
|
||||
}
|
||||
|
||||
const expired: string[] = []
|
||||
for (const path of candidates) {
|
||||
// Entries without a datetime — `data` itself, merge state files — are left alone: there
|
||||
// is nothing to compare them to.
|
||||
const datetime = extractDatetime(basename(path))
|
||||
if (datetime === undefined) continue
|
||||
const backupTimestamp = parseDatetime(datetime)
|
||||
if (backupTimestamp === undefined || backupTimestamp > threshold) continue
|
||||
expired.push(path)
|
||||
}
|
||||
|
||||
if (expired.length === 0) return
|
||||
debug('lifting expired disks', { vdiDir, count: expired.length })
|
||||
// Recursive: a VHD directory must be released together with its blocks, and `-R` is a no-op
|
||||
// on the flat VHDs and aliases sharing the batch.
|
||||
await Directory.liftImmutabilityBatch(expired)
|
||||
} catch (err) {
|
||||
// `cleanVm` may be merging or deleting these files at the same time
|
||||
if (err.code !== 'ENOENT') warn('error lifting expired disks', { err, vdiDir })
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// Walk `xo-config-backups/<scheduleId>/<datetime>/metadata.json` files and
|
||||
// lift immutability on any backup directory whose metadata mtime is expired.
|
||||
async function liftExpiredConfigBackups(root: string, immutabilityDuration: number, fullScan: boolean): Promise<void> {
|
||||
@@ -242,12 +180,6 @@ export async function liftRemoteImmutability(
|
||||
liftExpiredConfigBackups(root, immutabilityDuration, fullScan),
|
||||
liftExpiredPoolBackups(root, immutabilityDuration, fullScan),
|
||||
])
|
||||
|
||||
// after the passes above: every disk still named by a metadata json has been handled, so this one
|
||||
// only has the leftovers to look at
|
||||
if (fullScan) {
|
||||
await liftExpiredOrphanDisks(root, immutabilityDuration)
|
||||
}
|
||||
}
|
||||
|
||||
// Lift immutability on all expired backups across every configured remote.
|
||||
|
||||
@@ -13,7 +13,6 @@ for (const [remoteId, remote] of Object.entries(remotes)) {
|
||||
}
|
||||
|
||||
info('setup watcher for immutability lifting')
|
||||
await liftImmutability(remotes).catch(error => warn('error while lifting immutability', error))
|
||||
setInterval(async () => {
|
||||
await liftImmutability(remotes).catch(error => warn('error while lifting immutability', error))
|
||||
}, liftEvery)
|
||||
|
||||
@@ -1,22 +1,10 @@
|
||||
# ChangeLog
|
||||
|
||||
## **0.25.0** (2026-08-31)
|
||||
|
||||
- [Treeview] Add VM tree actions (PR [#10304](https://github.com/vatesfr/xen-orchestra/pull/10304))
|
||||
- [Pool/networks] Add the possibility to create new network or bonded network (PR [#10145](https://github.com/vatesfr/xen-orchestra/pull/10145))
|
||||
- [VM] Add VDIs page with table and side panel (PR [#10269](https://github.com/vatesfr/xen-orchestra/pull/10269))
|
||||
- [Host/Network] Add ability to rescan physical network interfaces (PIFs) (PR [#10147](https://github.com/vatesfr/xen-orchestra/pull/10147))
|
||||
- Fix inconsistent spacing in side panel cards (PR [#10279](https://github.com/vatesfr/xen-orchestra/pull/10279))
|
||||
- Fix missing collapse buttons on pools and hosts in the tree sidebar (added `hasChildren` prop) (PR [#10244](https://github.com/vatesfr/xen-orchestra/pull/10244))
|
||||
- [Pool/networks] Add the possibility to create new internal network (PR [#10235](https://github.com/vatesfr/xen-orchestra/pull/10235))
|
||||
|
||||
## **0.24.0** (2026-07-30)
|
||||
## **next**
|
||||
|
||||
- [Host/dashboard] Switch CPU and RAM panels order to match Pool dashboard layout (PR [#10059](https://github.com/vatesfr/xen-orchestra/pull/10059))
|
||||
- Remove all "coming soon" disabled button placeholders from network, VM, and pool components (PR [#10068](https://github.com/vatesfr/xen-orchestra/pull/10068))
|
||||
- [VM/Network] add possibility to “connect/disconnect” a VIF on a VM (PR [#10080](https://github.com/vatesfr/xen-orchestra/pull/10080))
|
||||
- [Pool/networks] Add the possibility to copy information from one or more networks in JSON format (PR [#10083](https://github.com/vatesfr/xen-orchestra/pull/10083))
|
||||
- Fix some design inconsistency between pages (PR [#10109](https://github.com/vatesfr/xen-orchestra/pull/10109))
|
||||
|
||||
## **0.23.0** (2026-06-30)
|
||||
|
||||
@@ -30,7 +18,6 @@
|
||||
- [SidePanels] Add and use new `VtsCardObjectTitle` component to display object title and ID in side panels (PR [#9755](https://github.com/vatesfr/xen-orchestra/pull/9755))
|
||||
- Replacement of the UiSpinner component with UiLoader from web-core (PR [#10023](https://github.com/vatesfr/xen-orchestra/pull/10023))
|
||||
- [Pool,Host/Storage] Add Storage tabs (PR [#10005](https://github.com/vatesfr/xen-orchestra/pull/10005))
|
||||
- [Pool,Host/Storage] Storage repositories can now be connected, disconnected and deleted from the Storage tabs (PR [#10006](https://github.com/vatesfr/xen-orchestra/pull/10006))
|
||||
|
||||
## **0.22.0** (2026-05-28)
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@xen-orchestra/lite",
|
||||
"version": "0.25.0",
|
||||
"version": "0.23.0",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"dev": "GIT_HEAD=$(git rev-parse HEAD) vite",
|
||||
@@ -23,21 +23,18 @@
|
||||
"@fortawesome/vue-fontawesome": "^3.0.8",
|
||||
"@intlify/unplugin-vue-i18n": "^6.0.3",
|
||||
"@novnc/novnc": "~1.5.0",
|
||||
"@regle/core": "^1.26.0",
|
||||
"@regle/rules": "^1.26.0",
|
||||
"@regle/schemas": "^1.20.2",
|
||||
"@tsconfig/node18": "^18.2.4",
|
||||
"@types/d3-time-format": "^4.0.3",
|
||||
"@types/file-saver": "^2.0.7",
|
||||
"@types/lodash-es": "^4.17.12",
|
||||
"@types/node": "^18.19.80",
|
||||
"@vates/types": "^2.0.1",
|
||||
"@vates/types": "^1.28.0",
|
||||
"@vitejs/plugin-vue": "^6.0.0",
|
||||
"@vue/tsconfig": "^0.9.0",
|
||||
"@vueuse/core": "^14.0.0",
|
||||
"@vueuse/math": "^14.0.0",
|
||||
"@vueuse/shared": "^14.0.0",
|
||||
"@xen-orchestra/web-core": "^0.60.0",
|
||||
"@xen-orchestra/web-core": "^0.56.0",
|
||||
"complex-matcher": "^1.1.1",
|
||||
"d3-time-format": "^4.1.0",
|
||||
"decorator-synchronized": "^0.6.0",
|
||||
|
||||
@@ -11,7 +11,8 @@
|
||||
</main>
|
||||
</div>
|
||||
</div>
|
||||
<VtsOverlayList />
|
||||
<VtsModalList />
|
||||
<VtsDrawerList />
|
||||
<VtsTooltipList />
|
||||
</template>
|
||||
|
||||
@@ -19,13 +20,14 @@
|
||||
import AppHeader from '@/components/AppHeader.vue'
|
||||
import AppLogin from '@/components/AppLogin.vue'
|
||||
import AppNavigation from '@/components/AppNavigation.vue'
|
||||
import { useUnreachableHosts } from '@/composables/unreachable-hosts.composable.ts'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store.ts'
|
||||
import { useXenApiStore } from '@/stores/xen-api.store.ts'
|
||||
import VtsOverlayList from '@core/components/overlay/VtsOverlayList.vue'
|
||||
import { useUnreachableHosts } from '@/composables/unreachable-hosts.composable'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store'
|
||||
import { useXenApiStore } from '@/stores/xen-api.store'
|
||||
import VtsDrawerList from '@core/components/drawer/VtsDrawerList.vue'
|
||||
import VtsModalList from '@core/components/modal/VtsModalList.vue'
|
||||
import VtsTooltipList from '@core/components/tooltip-list/VtsTooltipList.vue'
|
||||
import { useChartTheme } from '@core/composables/chart-theme.composable.ts'
|
||||
import { useUiStore } from '@core/stores/ui.store.ts'
|
||||
import { useChartTheme } from '@core/composables/chart-theme.composable'
|
||||
import { useUiStore } from '@core/stores/ui.store'
|
||||
import { useActiveElement, useMagicKeys, whenever } from '@vueuse/core'
|
||||
import { logicAnd } from '@vueuse/math'
|
||||
import { computed } from 'vue'
|
||||
|
||||
@@ -26,11 +26,11 @@
|
||||
import AccountMenu from '@/components/account-menu/AccountMenu.vue'
|
||||
import PoolOverrideWarning from '@/components/PoolOverrideWarning.vue'
|
||||
import XoaButton from '@/components/XoaButton.vue'
|
||||
import { useNavigationStore } from '@/stores/navigation.store.ts'
|
||||
import { useNavigationStore } from '@/stores/navigation.store'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store.ts'
|
||||
import UiButtonIcon from '@core/components/ui/button-icon/UiButtonIcon.vue'
|
||||
import UiLogoText from '@core/components/ui/logo-text/UiLogoText.vue'
|
||||
import { useUiStore } from '@core/stores/ui.store.ts'
|
||||
import { useUiStore } from '@core/stores/ui.store'
|
||||
import { storeToRefs } from 'pinia'
|
||||
import { computed } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
@@ -42,9 +42,9 @@
|
||||
import FormInput from '@/components/form/FormInput.vue'
|
||||
import LoginError from '@/components/LoginError.vue'
|
||||
import PoolOverrideWarning from '@/components/PoolOverrideWarning.vue'
|
||||
import type { XenApiError } from '@/libs/xen-api/xen-api.types.ts'
|
||||
import { usePageTitleStore } from '@/stores/page-title.store.ts'
|
||||
import { useXenApiStore } from '@/stores/xen-api.store.ts'
|
||||
import type { XenApiError } from '@/libs/xen-api/xen-api.types'
|
||||
import { usePageTitleStore } from '@/stores/page-title.store'
|
||||
import { useXenApiStore } from '@/stores/xen-api.store'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import VtsInputWrapper from '@core/components/input-wrapper/VtsInputWrapper.vue'
|
||||
import UiButton from '@core/components/ui/button/UiButton.vue'
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import markdown from '@/libs/markdown.ts'
|
||||
import markdown from '@/libs/markdown'
|
||||
import { useEventListener } from '@vueuse/core'
|
||||
import { computed, type Ref, ref } from 'vue'
|
||||
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
<script lang="ts" setup>
|
||||
import StoryMenu from '@/components/component-story/StoryMenu.vue'
|
||||
import InfraPoolList from '@/components/infra/InfraPoolList.vue'
|
||||
import { useNavigationStore } from '@/stores/navigation.store.ts'
|
||||
import { useNavigationStore } from '@/stores/navigation.store'
|
||||
import { onClickOutside, tryOnMounted, useTimeoutFn, watchImmediate } from '@vueuse/core'
|
||||
import { storeToRefs } from 'pinia'
|
||||
import { ref, watch } from 'vue'
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import { type AcceptedLanguage, highlight } from '@/libs/highlight.ts'
|
||||
import { type AcceptedLanguage, highlight } from '@/libs/highlight'
|
||||
import { computed } from 'vue'
|
||||
|
||||
const props = withDefaults(
|
||||
|
||||
@@ -19,8 +19,9 @@
|
||||
import UiActionButton from '@/components/ui/UiActionButton.vue'
|
||||
import UiFilter from '@/components/ui/UiFilter.vue'
|
||||
import UiFilterGroup from '@/components/ui/UiFilterGroup.vue'
|
||||
import type { Filters } from '@/types/filter.ts'
|
||||
import { useOverlay } from '@core/packages/overlay/use-overlay.ts'
|
||||
import type { Filters } from '@/types/filter'
|
||||
import { useModal } from '@core/packages/modal/use-modal.ts'
|
||||
import { computed } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
const { availableFilters } = defineProps<{
|
||||
@@ -35,25 +36,18 @@ const emit = defineEmits<{
|
||||
|
||||
const { t } = useI18n()
|
||||
|
||||
const { open } = useOverlay({
|
||||
component: () => import('@/components/modals/CollectionFilterModal.vue'),
|
||||
events: {
|
||||
onCancel: true,
|
||||
const openFilterModal = useModal((editedFilter?: string) => ({
|
||||
component: import('@/components/modals/CollectionFilterModal.vue'),
|
||||
props: {
|
||||
editedFilter,
|
||||
availableFilters: computed(() => availableFilters),
|
||||
},
|
||||
})
|
||||
onConfirm: async newFilter => {
|
||||
if (editedFilter !== undefined) {
|
||||
emit('removeFilter', editedFilter)
|
||||
}
|
||||
|
||||
function openFilterModal(editedFilter?: string) {
|
||||
return open({
|
||||
props: { editedFilter, availableFilters },
|
||||
events: {
|
||||
onConfirm: newFilter => {
|
||||
if (editedFilter !== undefined) {
|
||||
emit('removeFilter', editedFilter)
|
||||
}
|
||||
|
||||
emit('addFilter', newFilter)
|
||||
},
|
||||
},
|
||||
})
|
||||
}
|
||||
emit('addFilter', newFilter)
|
||||
},
|
||||
}))
|
||||
</script>
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
<div class="inputs">
|
||||
<UiInput v-if="newFilter.isAdvanced" v-model="filterContent" accent="brand" class="advanced-input" />
|
||||
<template v-else>
|
||||
<VtsSelect :id="builderPropertySelectId" accent="brand" />
|
||||
<VtsSelect :id="builderPropertySelectId" accent="brand" :icon="currentFilterIcon" />
|
||||
<VtsSelect v-if="hasComparisonSelect" :id="builderComparisonSelectId" accent="brand" />
|
||||
<VtsSelect v-if="currentFilter?.type === 'enum'" :id="builderValueSelectId" accent="brand" />
|
||||
<UiInput v-else-if="hasValueInput" v-model="newFilter.builder.value" accent="brand" />
|
||||
@@ -19,8 +19,9 @@
|
||||
|
||||
<script lang="ts" setup>
|
||||
import UiActionButton from '@/components/ui/UiActionButton.vue'
|
||||
import { buildComplexMatcherNode } from '@/libs/complex-matcher.utils.ts'
|
||||
import type { Filter, FilterComparisons, FilterComparisonType, Filters, FilterType, NewFilter } from '@/types/filter.ts'
|
||||
import { buildComplexMatcherNode } from '@/libs/complex-matcher.utils'
|
||||
import { getFilterIcon } from '@/libs/utils'
|
||||
import type { Filter, FilterComparisons, FilterComparisonType, Filters, FilterType, NewFilter } from '@/types/filter'
|
||||
import VtsSelect from '@core/components/select/VtsSelect.vue'
|
||||
import UiInput from '@core/components/ui/input/UiInput.vue'
|
||||
import { useFormSelect } from '@core/packages/form-select'
|
||||
@@ -103,6 +104,8 @@ function getDefaultComparisonType(property: string) {
|
||||
|
||||
const currentFilter = computed<Filter | undefined>(() => availableFilters[builderProperty.value])
|
||||
|
||||
const currentFilterIcon = computed(() => getFilterIcon(currentFilter.value))
|
||||
|
||||
const hasValueInput = computed(() =>
|
||||
currentFilter.value ? ['string', 'number'].includes(currentFilter.value?.type) : false
|
||||
)
|
||||
|
||||
@@ -22,9 +22,10 @@
|
||||
import UiActionButton from '@/components/ui/UiActionButton.vue'
|
||||
import UiFilter from '@/components/ui/UiFilter.vue'
|
||||
import UiFilterGroup from '@/components/ui/UiFilterGroup.vue'
|
||||
import type { ActiveSorts, Sorts } from '@/types/sort.ts'
|
||||
import type { ActiveSorts, Sorts } from '@/types/sort'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import { useOverlay } from '@core/packages/overlay/use-overlay.ts'
|
||||
import { useModal } from '@core/packages/modal/use-modal.ts'
|
||||
import { computed } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
const { availableSorts } = defineProps<{
|
||||
@@ -40,17 +41,11 @@ const emit = defineEmits<{
|
||||
|
||||
const { t } = useI18n()
|
||||
|
||||
const { open } = useOverlay({
|
||||
component: () => import('@/components/modals/CollectionSorterModal.vue'),
|
||||
events: {
|
||||
onConfirm: ({ property, isAscending }) => emit('addSort', property as TProperty, isAscending),
|
||||
onCancel: true,
|
||||
},
|
||||
const openFormModal = useModal({
|
||||
component: import('@/components/modals/CollectionSorterModal.vue'),
|
||||
props: { availableSorts: computed(() => availableSorts) },
|
||||
onConfirm: ({ property, isAscending }) => emit('addSort', property as TProperty, isAscending),
|
||||
})
|
||||
|
||||
function openFormModal() {
|
||||
return open({ props: { availableSorts } })
|
||||
}
|
||||
</script>
|
||||
|
||||
<style lang="postcss" scoped>
|
||||
|
||||
@@ -14,12 +14,12 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import type { XenApiPatchWithHostRefs } from '@/composables/host-patches.composable.ts'
|
||||
import type { XenApiPatchWithHostRefs } from '@/composables/host-patches.composable'
|
||||
import VtsRow from '@core/components/table/VtsRow.vue'
|
||||
import VtsTable from '@core/components/table/VtsTable.vue'
|
||||
import { useTableState } from '@core/composables/table-state.composable.ts'
|
||||
import { useUiStore } from '@core/stores/ui.store.ts'
|
||||
import { usePatchColumns } from '@core/tables/column-sets/patch-columns.ts'
|
||||
import { useTableState } from '@core/composables/table-state.composable'
|
||||
import { useUiStore } from '@core/stores/ui.store'
|
||||
import { usePatchColumns } from '@core/tables/column-sets/patch-columns'
|
||||
import { computed } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import type { XenApiError } from '@/libs/xen-api/xen-api.types.ts'
|
||||
import type { XenApiError } from '@/libs/xen-api/xen-api.types'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
|
||||
@@ -10,12 +10,12 @@
|
||||
</template>
|
||||
|
||||
<script generic="T extends ObjectType" lang="ts" setup>
|
||||
import type { ObjectType, ObjectTypeToRecord } from '@/libs/xen-api/xen-api.types.ts'
|
||||
import type { XapiContext } from '@/stores/xen-api/create-xapi-store-config.ts'
|
||||
import { useHostStore } from '@/stores/xen-api/host.store.ts'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store.ts'
|
||||
import { useSrStore } from '@/stores/xen-api/sr.store.ts'
|
||||
import { useVmStore } from '@/stores/xen-api/vm.store.ts'
|
||||
import type { ObjectType, ObjectTypeToRecord } from '@/libs/xen-api/xen-api.types'
|
||||
import type { XapiContext } from '@/stores/xen-api/create-xapi-store-config'
|
||||
import { useHostStore } from '@/stores/xen-api/host.store'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store'
|
||||
import { useSrStore } from '@/stores/xen-api/sr.store'
|
||||
import { useVmStore } from '@/stores/xen-api/vm.store'
|
||||
import UiLoader from '@core/components/ui/loader/UiLoader.vue'
|
||||
import { computed, watch } from 'vue'
|
||||
import { type RouteLocationTyped, type RouteRecordName } from 'vue-router'
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
</template>
|
||||
|
||||
<script generic="T extends XenApiRecord<ObjectType>, I extends T['uuid']" lang="ts" setup>
|
||||
import type { ObjectType, XenApiRecord } from '@/libs/xen-api/xen-api.types.ts'
|
||||
import type { ObjectType, XenApiRecord } from '@/libs/xen-api/xen-api.types'
|
||||
import ObjectNotFoundView from '@/pages/object-not-found.vue'
|
||||
import UiLoader from '@core/components/ui/loader/UiLoader.vue'
|
||||
import { computed } from 'vue'
|
||||
|
||||
@@ -27,9 +27,9 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import { useXenApiStore } from '@/stores/xen-api.store.ts'
|
||||
import { useXenApiStore } from '@/stores/xen-api.store'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive.ts'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive'
|
||||
import { useSessionStorage } from '@vueuse/core'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import { VM_POWER_STATE } from '@/libs/xen-api/xen-api.enums.ts'
|
||||
import { VM_POWER_STATE } from '@/libs/xen-api/xen-api.enums'
|
||||
import type { IconName } from '@core/icons'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import { computed } from 'vue'
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
|
||||
<script lang="ts" setup>
|
||||
import TabItem from '@core/components/tab/TabItem.vue'
|
||||
import { useDisabled } from '@core/composables/disabled.composable.ts'
|
||||
import { useDisabled } from '@core/composables/disabled.composable'
|
||||
import type { RouteLocationRaw } from 'vue-router'
|
||||
|
||||
const props = defineProps<{
|
||||
|
||||
@@ -24,8 +24,8 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import type { PRIMARY_ADDRESS_TYPE } from '@/libs/xen-api/xen-api.enums.ts'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store.ts'
|
||||
import type { PRIMARY_ADDRESS_TYPE } from '@/libs/xen-api/xen-api.enums'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store'
|
||||
import UiButton from '@core/components/ui/button/UiButton.vue'
|
||||
import { computed } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
@@ -31,11 +31,11 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import { useXenApiStore } from '@/stores/xen-api.store.ts'
|
||||
import { useXenApiStore } from '@/stores/xen-api.store'
|
||||
import MenuItem from '@core/components/menu/MenuItem.vue'
|
||||
import MenuList from '@core/components/menu/MenuList.vue'
|
||||
import UiAccountMenuButton from '@core/components/ui/account-menu-button/UiAccountMenuButton.vue'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive.ts'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive'
|
||||
import { nextTick } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
import { useRouter } from 'vue-router'
|
||||
|
||||
@@ -87,7 +87,7 @@ import {
|
||||
isSlotParam,
|
||||
ModelParam,
|
||||
type Param,
|
||||
} from '@/libs/story/story-param.ts'
|
||||
} from '@/libs/story/story-param'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import MenuItem from '@core/components/menu/MenuItem.vue'
|
||||
import MenuList from '@core/components/menu/MenuList.vue'
|
||||
|
||||
@@ -26,7 +26,7 @@
|
||||
<script lang="ts" setup>
|
||||
import CodeHighlight from '@/components/CodeHighlight.vue'
|
||||
import StoryParamsTable from '@/components/component-story/StoryParamsTable.vue'
|
||||
import type { EventParam } from '@/libs/story/story-param.ts'
|
||||
import type { EventParam } from '@/libs/story/story-param'
|
||||
|
||||
defineProps<{
|
||||
params: EventParam[]
|
||||
|
||||
@@ -83,11 +83,11 @@
|
||||
import CodeHighlight from '@/components/CodeHighlight.vue'
|
||||
import StoryParamsTable from '@/components/component-story/StoryParamsTable.vue'
|
||||
import StoryWidget from '@/components/component-story/StoryWidget.vue'
|
||||
import useSortedCollection from '@/composables/sorted-collection.composable.ts'
|
||||
import type { PropParam } from '@/libs/story/story-param.ts'
|
||||
import useSortedCollection from '@/composables/sorted-collection.composable'
|
||||
import type { PropParam } from '@/libs/story/story-param'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive.ts'
|
||||
import { useOverlay } from '@core/packages/overlay/use-overlay.ts'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive'
|
||||
import { useModal } from '@core/packages/modal/use-modal.ts'
|
||||
import { useVModel } from '@vueuse/core'
|
||||
import { toRef } from 'vue'
|
||||
|
||||
@@ -111,16 +111,10 @@ const params = useSortedCollection(toRef(props, 'params'), (p1, p2) => {
|
||||
|
||||
const model = useVModel(props, 'modelValue', emit)
|
||||
|
||||
const { open } = useOverlay({
|
||||
component: () => import('@/components/modals/CodeHighlightModal.vue'),
|
||||
events: {
|
||||
onClose: true,
|
||||
},
|
||||
})
|
||||
|
||||
function openRawValueModal(code: string) {
|
||||
return open({ props: { code } })
|
||||
}
|
||||
const openRawValueModal = useModal((code: string) => ({
|
||||
component: import('@/components/modals/CodeHighlightModal.vue'),
|
||||
props: { code },
|
||||
}))
|
||||
</script>
|
||||
|
||||
<style lang="postcss" scoped>
|
||||
|
||||
@@ -37,7 +37,7 @@
|
||||
<script lang="ts" setup>
|
||||
import StoryParamsTable from '@/components/component-story/StoryParamsTable.vue'
|
||||
import StoryWidget from '@/components/component-story/StoryWidget.vue'
|
||||
import type { SettingParam } from '@/libs/story/story-param.ts'
|
||||
import type { SettingParam } from '@/libs/story/story-param'
|
||||
import { useVModel } from '@vueuse/core'
|
||||
|
||||
const props = defineProps<{
|
||||
|
||||
@@ -27,7 +27,7 @@
|
||||
<script lang="ts" setup>
|
||||
import CodeHighlight from '@/components/CodeHighlight.vue'
|
||||
import StoryParamsTable from '@/components/component-story/StoryParamsTable.vue'
|
||||
import type { SlotParam } from '@/libs/story/story-param.ts'
|
||||
import type { SlotParam } from '@/libs/story/story-param'
|
||||
|
||||
defineProps<{
|
||||
params: SlotParam[]
|
||||
|
||||
@@ -28,7 +28,7 @@ import {
|
||||
isSelectWidget,
|
||||
isTextWidget,
|
||||
type Widget,
|
||||
} from '@/libs/story/story-widget.ts'
|
||||
} from '@/libs/story/story-widget'
|
||||
import { useFormSelect } from '@core/packages/form-select'
|
||||
import { computed, defineAsyncComponent } from 'vue'
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user