mirror of
https://github.com/vatesfr/xen-orchestra.git
synced 2026-11-15 19:42:26 -06:00
Compare commits
1 Commits
debug_time
...
feat_test_
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
48ac95b98c |
@@ -4,4 +4,3 @@
|
||||
|
||||
# Generated files
|
||||
/@xen-orchestra/web/src/route-map.d.ts
|
||||
/@xen-orchestra/lite/src/route-map.d.ts
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@vates/fuse-vhd",
|
||||
"version": "2.1.3",
|
||||
"version": "2.1.2",
|
||||
"license": "ISC",
|
||||
"private": false,
|
||||
"homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/fuse-vhd",
|
||||
@@ -19,12 +19,12 @@
|
||||
},
|
||||
"main": "./index.mjs",
|
||||
"dependencies": {
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/fs": "^4.9.0",
|
||||
"@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"
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@vates/generator-toolbox",
|
||||
"version": "1.1.3",
|
||||
"version": "1.1.2",
|
||||
"main": "dist/index.mjs",
|
||||
"license": "MIT",
|
||||
"private": false,
|
||||
@@ -10,7 +10,7 @@
|
||||
"rimraf": "^6.0.1",
|
||||
"@types/node": "^20.6",
|
||||
"typescript": "~5.6",
|
||||
"typescript-eslint": "^8.61.0"
|
||||
"typescript-eslint": "^8.23.0"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -13,7 +13,7 @@
|
||||
"url": "https://vates.fr"
|
||||
},
|
||||
"license": "ISC",
|
||||
"version": "3.5.0",
|
||||
"version": "3.4.0",
|
||||
"engines": {
|
||||
"node": ">=14.0"
|
||||
},
|
||||
@@ -22,10 +22,10 @@
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@vates/read-chunk": "^1.2.1",
|
||||
"@xen-orchestra/async-map": "^0.1.3",
|
||||
"@xen-orchestra/disk-transform": "^1.3.3",
|
||||
"@xen-orchestra/disk-transform": "^1.3.0",
|
||||
"@xen-orchestra/log": "^0.7.2",
|
||||
"promise-toolbox": "^0.21.0",
|
||||
"xen-api": "^4.8.0"
|
||||
"xen-api": "^4.7.7"
|
||||
},
|
||||
"devDependencies": {
|
||||
"tap": "^18.7.0",
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "@vates/types",
|
||||
"private": false,
|
||||
"version": "1.30.1",
|
||||
"version": "1.26.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.23.0"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
|
||||
@@ -744,8 +744,6 @@ export type XapiPoolStats = Record<XoHost['id'], XapiHostStats | { error: Record
|
||||
export type TrafficRuleProtocol = (typeof TRAFFIC_RULE_PROTOCOLS)[number]
|
||||
|
||||
export const SDN_CONTROLLER_OF_RULES_KEY = 'xo:sdn-controller:of-rules'
|
||||
export const SDN_CONTROLLER_OF_METHOD_KEY = 'xo:sdn-controller:of-method'
|
||||
export const SDN_CONTROLLER_OF_FORMAT_KEY = 'xo:sdn-controller:of-format'
|
||||
export const TRAFFIC_RULE_PROTOCOLS = ['ARP', 'ICMP', 'IP', 'TCP', 'UDP'] as const
|
||||
export const TRAFFIC_RULE_PROTOCOLS_WITH_PORT: readonly TrafficRuleProtocol[] = ['TCP', 'UDP']
|
||||
|
||||
|
||||
@@ -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,102 +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 =
|
||||
| {
|
||||
type: 'string'
|
||||
example?: string
|
||||
optional?: boolean
|
||||
}
|
||||
| {
|
||||
type: 'boolean'
|
||||
example?: boolean
|
||||
optional?: boolean
|
||||
}
|
||||
| {
|
||||
type: 'number'
|
||||
example?: number
|
||||
optional?: boolean
|
||||
}
|
||||
| {
|
||||
type: 'enum'
|
||||
enum: string[]
|
||||
example?: string
|
||||
optional?: boolean
|
||||
}
|
||||
| {
|
||||
type: 'object'
|
||||
fields: Record<string, FieldDefinition>
|
||||
optional?: boolean
|
||||
}
|
||||
| {
|
||||
type: 'array'
|
||||
items: FieldDefinition
|
||||
example?: unknown[]
|
||||
optional?: boolean
|
||||
}
|
||||
|
||||
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>
|
||||
|
||||
@@ -89,16 +89,6 @@ export interface EditVmProps {
|
||||
xenStoreData?: Record<string, string | null>
|
||||
}
|
||||
|
||||
/** Properties accepted by {@link Xapi.editVif}. */
|
||||
export interface EditVifProps {
|
||||
ipv4Allowed?: string[]
|
||||
ipv6Allowed?: string[]
|
||||
lockingMode?: VIF_LOCKING_MODE
|
||||
// in kB/s, `null` removes the limit
|
||||
rateLimit?: number | null
|
||||
txChecksumming?: boolean
|
||||
}
|
||||
|
||||
export type XcpPatches = {
|
||||
changelog?: {
|
||||
author: string
|
||||
@@ -179,13 +169,6 @@ export interface Xapi {
|
||||
deleteVif(vifId: XoVif['id']): Promise<void>
|
||||
disconnectVif(vifId: XoVif['id']): Promise<void>
|
||||
exportVmOva(vmRef: XenApiVm['$ref']): Promise<PassThrough>
|
||||
emergencyShutdownHost(hostId: XoHost['id']): Promise<void>
|
||||
ejectHostFromPool(hostId: XoHost['id']): Promise<void>
|
||||
host_smartReboot(
|
||||
hostRef: XenApiHost['$ref'],
|
||||
bypassBlockedSuspend?: boolean,
|
||||
bypassCurrentVmCheck?: boolean
|
||||
): Promise<void>
|
||||
migrateVm(
|
||||
vmId: XoVm['id'],
|
||||
hostXapi: Xapi,
|
||||
@@ -229,40 +212,6 @@ export interface Xapi {
|
||||
}
|
||||
): Promise<{ vm: XenApiVmWrapped }>
|
||||
forgetSr(id: XoSr['id']): Promise<void>
|
||||
forgetHost(hostId: XoHost['id']): Promise<void>
|
||||
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,
|
||||
@@ -286,7 +235,6 @@ export interface Xapi {
|
||||
props: EditVmProps,
|
||||
checkLimits?: (limits: Record<string, number>, vm: XenApiVmWrapped) => Promise<void>
|
||||
): Promise<void>
|
||||
editVif(id: XoVif['id'], props: EditVifProps): Promise<void>
|
||||
startVm(
|
||||
id: XoVm['id'],
|
||||
opts?: {
|
||||
@@ -358,7 +306,6 @@ export interface Xapi {
|
||||
vgpuType?: XoVgpuType['id']
|
||||
gpuGroup?: XoGpuGroup['id']
|
||||
copyHostBiosStrings?: boolean
|
||||
highAvailability?: XoVm['high_availability']
|
||||
hvmBootFirmware?: 'uefi' | 'bios'
|
||||
secureBoot?: boolean
|
||||
},
|
||||
@@ -411,7 +358,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(
|
||||
@@ -450,12 +397,8 @@ export interface Xapi {
|
||||
pathname: string,
|
||||
params?: { host?: XenApiHost; query?: Record<string, unknown>; task?: boolean | XenApiTask['$ref'] }
|
||||
): Promise<{ body: Readable }>
|
||||
clearHost(
|
||||
host: Pick<XenApiHostWrapped, '$ref' | '$pool'>,
|
||||
force?: boolean,
|
||||
opts?: { transient?: boolean }
|
||||
): Promise<void>
|
||||
disableHost(hostId: XoHost['id'], opts?: { transient?: boolean }): Promise<void>
|
||||
clearHost(host: Pick<XenApiHostWrapped, '$ref' | '$pool'>, force?: boolean): Promise<void>
|
||||
disableHost(hostId: XoHost['id']): Promise<void>
|
||||
enableHost(hostId: XoHost['id']): Promise<void>
|
||||
getRecordByUuid<
|
||||
Type extends WrappedXenApiRecord['$type'],
|
||||
|
||||
@@ -493,7 +493,7 @@ export interface XenApiDrTask {
|
||||
}
|
||||
|
||||
type XenApiHostCallMethods = TagCallMethods & {
|
||||
<T>(method: 'call_plugin', plugin: string, fn: string, args: Record<string, string>): Promise<T>
|
||||
<T>(method: 'call_plugin',plugin:string, fn: string, args: Record<string, string>): Promise<T>
|
||||
}
|
||||
export interface XenApiHost {
|
||||
$ref: Branded<'host'>
|
||||
@@ -571,9 +571,7 @@ export interface XenApiHost {
|
||||
uuid: string
|
||||
virtual_hardware_platform_versions: number[]
|
||||
}
|
||||
export interface XenApiHostWrapped extends WrapperXenApi<XenApiHost, 'host', XenApiHostCallMethods> {
|
||||
$restartAgent(): Promise<void>
|
||||
}
|
||||
export type XenApiHostWrapped = WrapperXenApi<XenApiHost, 'host', XenApiHostCallMethods>
|
||||
|
||||
export interface XenApiHostCrashdump {
|
||||
$ref: Branded<'host_crashdump'>
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import { EventEmitter } from 'node:stream'
|
||||
import type {
|
||||
AnyXoBackupJob,
|
||||
AnyXoJob,
|
||||
AnyXoLog,
|
||||
XapiXoRecord,
|
||||
@@ -15,12 +16,10 @@ import type {
|
||||
XoServer,
|
||||
XoTask,
|
||||
XoUser,
|
||||
XoVif,
|
||||
XoVm,
|
||||
XoVmBackupArchive,
|
||||
} from './xo.mjs'
|
||||
import { VatesTask } from './lib/vates-task.mjs'
|
||||
import type { PluginRestRouteDefinition } from './lib/rest-api.mjs'
|
||||
import {
|
||||
Xapi,
|
||||
XapiHostStats,
|
||||
@@ -68,7 +67,6 @@ type FeatureCode =
|
||||
| 'RBAC'
|
||||
| 'ROLLING_POOL_UPDATE'
|
||||
| 'ROLLING_POOL_REBOOT'
|
||||
| 'SMART_REBOOT'
|
||||
| 'WARM_MIGRATION'
|
||||
| 'PLUGIN.OPENMETRICS'
|
||||
|
||||
@@ -182,7 +180,6 @@ export type XoApp = {
|
||||
}
|
||||
|
||||
// methods ------------
|
||||
allocIpAddresses(vifId: XoVif['id'], addAddresses?: string[], removeAddresses?: string[]): Promise<void>
|
||||
addAclV2GroupRole(groupId: XoGroup['id'], roleId: XoAclRole['id']): Promise<XoGroupRole>
|
||||
addAclV2UserRole(userId: XoUser['id'], roleId: XoAclRole['id']): Promise<XoUserRole>
|
||||
addUserToGroup: (userId: XoUser['id'], groupId: XoGroup['id']) => Promise<void>
|
||||
@@ -195,13 +192,11 @@ 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 },
|
||||
opts?: { bypassOtp?: boolean; bypassTaskCreation?: boolean }
|
||||
) => Promise<{ bypassOtp: boolean; expiration: number; user: XoUser }>
|
||||
backupGuard(poolId: XoPool['id']): Promise<void>
|
||||
/* Throw if no authorization */
|
||||
checkFeatureAuthorization(featureCode: FeatureCode): Promise<void>
|
||||
/* connect a server (XCP-ng/XenServer) */
|
||||
@@ -234,42 +229,24 @@ 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>
|
||||
deleteUser(id: XoUser['id']): Promise<void>
|
||||
detachHostFromPool(hostId: XoHost['id']): Promise<void>
|
||||
createGroup(params: { name: string; provider?: string; providerGroup?: string }): Promise<XoGroup>
|
||||
/* disconnect a server (XCP-ng/XenServer) */
|
||||
disconnectXenServer(id: XoServer['id']): Promise<void>
|
||||
findEnabledScheduleSequenceFromSchedule(id: XoSchedule['id']): Promise<XoSchedule | undefined>
|
||||
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 }>[]>
|
||||
getAllJobs<T extends AnyXoBackupJob['type']>(type: T): Promise<Extract<AnyXoBackupJob, { type: T }>[]>
|
||||
getAllJobs(type?: string): Promise<AnyXoJob[]>
|
||||
getProxy(id: XoProxy['id']): Promise<XoProxy>
|
||||
getRemote(id: XoBackupRepository['id']): Promise<XoBackupRepository>
|
||||
@@ -332,7 +309,6 @@ export type XoApp = {
|
||||
backupRepositoryIds: XoBackupRepository['id'][],
|
||||
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(
|
||||
body: Pick<XoServer, 'host' | 'httpProxy' | 'label' | 'username'> & {
|
||||
@@ -341,22 +317,13 @@ 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>
|
||||
runJob(job: AnyXoJob, schedule: XoSchedule): void
|
||||
runWithApiContext: (user: XoUser | undefined, fn: () => void) => Promise<unknown>
|
||||
testRemote(
|
||||
id: XoBackupRepository['id']
|
||||
): Promise<
|
||||
| { success: true; readRate: number; writeRate: number }
|
||||
| { success: false; step: string; file: string; error: unknown }
|
||||
>
|
||||
/** Remove a server from the DB (XCP-ng/XenServer) */
|
||||
unregisterXenServer(id: XoServer['id']): Promise<void>
|
||||
updateUser(
|
||||
|
||||
@@ -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 & {
|
||||
@@ -566,18 +565,6 @@ export type XoMirrorBackupJob = BaseXoJob & {
|
||||
|
||||
export type XoJob = BaseXoJob & {
|
||||
type: 'call'
|
||||
method: string
|
||||
paramsVector?: {
|
||||
type: string
|
||||
items: {
|
||||
type?: string
|
||||
values?: {
|
||||
schedules?: XoSchedule['id'][]
|
||||
[key: string]: unknown
|
||||
}[]
|
||||
[key: string]: unknown
|
||||
}[]
|
||||
}
|
||||
}
|
||||
|
||||
export type XoSchedule = {
|
||||
@@ -614,7 +601,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 +612,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
|
||||
|
||||
@@ -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.5.0",
|
||||
"version": "1.2.0",
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"private": false,
|
||||
"type": "module",
|
||||
@@ -30,10 +30,10 @@
|
||||
},
|
||||
"devDependencies": {
|
||||
"@eslint/js": "^9.19.0",
|
||||
"@vates/types": "^1.30.1",
|
||||
"@vates/types": "^1.26.0",
|
||||
"rimraf": "^6.0.1",
|
||||
"typescript": "~5.6",
|
||||
"typescript-eslint": "^8.61.0"
|
||||
"typescript-eslint": "^8.23.0"
|
||||
},
|
||||
"bugs": "https://github.com/vatesfr/xen-orchestra/issues",
|
||||
"repository": {
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
export default {
|
||||
benchmark: true,
|
||||
create: true,
|
||||
read: true,
|
||||
forget: true,
|
||||
|
||||
@@ -1,27 +1,14 @@
|
||||
export default {
|
||||
'allow-vm': true,
|
||||
detach: true,
|
||||
disable: true,
|
||||
'migrate-receive': true,
|
||||
enable: true,
|
||||
evacuate: true,
|
||||
export: {
|
||||
logs: true,
|
||||
},
|
||||
forget: true,
|
||||
'join-pool': true,
|
||||
'migrate-receive': true,
|
||||
read: true,
|
||||
reboot: {
|
||||
clean: true,
|
||||
smart: true,
|
||||
},
|
||||
'restart-toolstack': true,
|
||||
'scan-pifs': true,
|
||||
shutdown: {
|
||||
clean: true,
|
||||
emergency: true,
|
||||
},
|
||||
start: true,
|
||||
update: {
|
||||
tags: true,
|
||||
},
|
||||
|
||||
@@ -4,6 +4,5 @@ export default {
|
||||
read: true,
|
||||
update: {
|
||||
tags: true,
|
||||
other_config: true,
|
||||
},
|
||||
}
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
export default {
|
||||
create: true,
|
||||
delete: true,
|
||||
forget: true,
|
||||
import: {
|
||||
|
||||
@@ -7,9 +7,6 @@ export default {
|
||||
'migrate-send': true,
|
||||
read: true,
|
||||
update: {
|
||||
name_description: true,
|
||||
name_label: true,
|
||||
size: true,
|
||||
tags: true,
|
||||
},
|
||||
}
|
||||
|
||||
@@ -4,12 +4,4 @@ export default {
|
||||
delete: true,
|
||||
disconnect: true,
|
||||
read: true,
|
||||
update: {
|
||||
allowedIpv4Addresses: true,
|
||||
allowedIpv6Addresses: true,
|
||||
lockingMode: true,
|
||||
rateLimit: true,
|
||||
txChecksumming: true,
|
||||
other_config: true,
|
||||
},
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@xen-orchestra/backup-archive",
|
||||
"version": "1.1.1",
|
||||
"version": "1.0.1",
|
||||
"description": "Helper to handle generic backup archives",
|
||||
"license": "ISC",
|
||||
"author": "",
|
||||
@@ -15,30 +15,29 @@
|
||||
"rimraf": "^6.0.1",
|
||||
"@types/node": "^22.3.0",
|
||||
"typescript": "~5.6",
|
||||
"typescript-eslint": "^8.61.0",
|
||||
"typescript-eslint": "^8.23.0",
|
||||
"fs-extra": "^11.1.0",
|
||||
"sinon": "^18.0.0",
|
||||
"tar-stream": "^3.1.8",
|
||||
"@types/tar-stream": "^3.1.4",
|
||||
"tmp": "^0.2.1",
|
||||
"@vates/types": "^1.30.1"
|
||||
"@vates/types": "^1.26.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.0",
|
||||
"@xen-orchestra/disk-transform": "^1.3.0",
|
||||
"@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/"
|
||||
},
|
||||
|
||||
@@ -21,7 +21,6 @@ import { limitConcurrency } from 'limit-concurrency-decorator'
|
||||
import assert from 'node:assert/strict'
|
||||
|
||||
const defaultMergeLimiter = limitConcurrency(1)
|
||||
const MERGE_STATE_FILE_RE = /^\.(.+)\.merge\.json$/
|
||||
/**
|
||||
* Tracks the disk chain for a single VDI across all backup snapshots.
|
||||
* Owns merge and deletion decisions for its chain given which disks are still
|
||||
@@ -85,23 +84,11 @@ export class RemoteDiskLineage {
|
||||
}
|
||||
}
|
||||
|
||||
const mergeParentPaths = new Set<string>()
|
||||
for (const filePath of files) {
|
||||
const match = MERGE_STATE_FILE_RE.exec(basename(filePath))
|
||||
if (match !== null) {
|
||||
mergeParentPaths.add(normalize(this.#vdiDir + '/' + match[1]))
|
||||
}
|
||||
}
|
||||
|
||||
const uuidToPath = new Map<string, string>()
|
||||
for (const diskPath of this.#diskPaths) {
|
||||
let disk: RemoteDisk | undefined
|
||||
try {
|
||||
if (mergeParentPaths.has(diskPath)) {
|
||||
disk = await openDisk({ handler: this.#handler, path: diskPath, force: true })
|
||||
} else {
|
||||
disk = await openDisk({ handler: this.#handler, path: diskPath })
|
||||
}
|
||||
disk = await openDisk({ handler: this.#handler, path: diskPath })
|
||||
} catch (error) {
|
||||
if (error?.code === 'NOT_SUPPORTED' && this.#opts.merge) {
|
||||
throw error
|
||||
@@ -309,7 +296,7 @@ export class RemoteDiskLineage {
|
||||
try {
|
||||
const disk = await openDisk({ handler: this.#handler, path, ignoreBlockIndexes: true })
|
||||
await disk.unlink({ force: true })
|
||||
// Remove from tracking so #cleanOrphanDataFiles skips this now-deleted path
|
||||
// Remove from tracking so #cleanOrphanDataFiles skips this now-deleted path.
|
||||
this.#unregisterDisk(path)
|
||||
} catch (error) {
|
||||
this.#opts.logWarn('failed to delete unused disk', { path, error })
|
||||
@@ -331,15 +318,8 @@ export class RemoteDiskLineage {
|
||||
await asyncEach(
|
||||
toMerge,
|
||||
async ({ chain, isResuming }) => {
|
||||
const { finalDiskSize, mergeTargetPath } = await limitedMergeChain([...chain], isResuming)
|
||||
const { finalDiskSize, mergeTargetPath } = await limitedMergeChain(chain, isResuming)
|
||||
mergedSizes.set(mergeTargetPath, (mergedSizes.get(mergeTargetPath) ?? 0) + finalDiskSize)
|
||||
// parentPath alias deleted by parentDisk.rename(mergeTargetPath)
|
||||
// intermediates deleted by childDisk.unlink() when removeUnused=true
|
||||
// Unregister so #cleanOrphanDataFiles does not read already-deleted aliases
|
||||
// and produce false "missing target of alias" warnings.
|
||||
for (const deletedPath of chain.slice(0, -1)) {
|
||||
this.#unregisterDisk(deletedPath)
|
||||
}
|
||||
},
|
||||
{ concurrency: this.#opts.mergeConcurrency ?? DEFAULT_MERGE_CONCURRENCY }
|
||||
)
|
||||
|
||||
@@ -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 })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -43,19 +43,12 @@ const isValidTar = async (handler: RemoteHandlerAbstract, size: number, fd: File
|
||||
return buf.every(byte => byte === 0)
|
||||
}
|
||||
|
||||
export async function isValidXva(
|
||||
handler: RemoteHandlerAbstract,
|
||||
filePath: string,
|
||||
metadataSize?: number
|
||||
): Promise<boolean> {
|
||||
export async function isValidXva(handler: RemoteHandlerAbstract, filePath: string): Promise<boolean> {
|
||||
// size is longer when encrypted + reading part of an encrypted file is not implemented
|
||||
if (handler.isEncrypted) {
|
||||
const size = await handler.getSizeOnDisk(filePath)
|
||||
return size > 20
|
||||
return true
|
||||
}
|
||||
|
||||
let isValid = true
|
||||
|
||||
const fd = await handler.openFile(filePath, 'r')
|
||||
try {
|
||||
const size = await handler.getSize(filePath)
|
||||
@@ -63,19 +56,13 @@ export async function isValidXva(
|
||||
// neither a valid gzip nor tar
|
||||
return false
|
||||
}
|
||||
let validSize = true
|
||||
if (metadataSize !== undefined) {
|
||||
validSize = metadataSize === size
|
||||
}
|
||||
|
||||
const validDisk = (await isCompressedFile(handler, fd))
|
||||
return (await isCompressedFile(handler, fd))
|
||||
? true // compressed files cannot be validated at this time
|
||||
: await isValidTar(handler, size, fd)
|
||||
isValid = validSize && validDisk
|
||||
} finally {
|
||||
handler.closeFile(fd).catch(noop)
|
||||
}
|
||||
return isValid
|
||||
}
|
||||
|
||||
const noop = (): void => {}
|
||||
@@ -114,22 +101,28 @@ export class VmFullBackupArchive implements VmBackupInterface {
|
||||
*/
|
||||
async check(): Promise<CheckResult> {
|
||||
if (this.isValid === undefined) {
|
||||
let fileSize = 0
|
||||
let validDisk = false
|
||||
let validSize = true
|
||||
try {
|
||||
this.isValid = await isValidXva(this.handler, this.xvaPath, this.metadata.size)
|
||||
fileSize = await this.handler.getSize(this.xvaPath)
|
||||
validDisk = await isValidXva(this.handler, this.xvaPath)
|
||||
} catch (error) {
|
||||
this.isValid = false
|
||||
validDisk = false
|
||||
if (error?.code === 'ENOENT') {
|
||||
this.missingDisk = true
|
||||
}
|
||||
this.opts.logWarn('Issue while checking XVA', { error })
|
||||
}
|
||||
if (!this.handler.isEncrypted) {
|
||||
try {
|
||||
await this.handler.getSize(`${this.xvaPath}.checksum`)
|
||||
} catch (error) {
|
||||
this.opts.logWarn('Checksum file not valid, not blocking', { error })
|
||||
}
|
||||
try {
|
||||
await this.handler.getSize(`${this.xvaPath}.checksum`)
|
||||
} catch (error) {
|
||||
this.opts.logWarn('Checksum file not valid, not blocking', { error })
|
||||
}
|
||||
if (this.metadata.size !== undefined) {
|
||||
validSize = this.metadata.size === fileSize
|
||||
}
|
||||
this.isValid = fileSize > 0 && validSize && validDisk
|
||||
}
|
||||
if (!this.isValid) {
|
||||
if (this.missingDisk) {
|
||||
|
||||
@@ -8,19 +8,13 @@ import { getHandler } from '@xen-orchestra/fs'
|
||||
import { pFromCallback } from 'promise-toolbox'
|
||||
// eslint-disable-next-line n/no-missing-import
|
||||
import { VmBackupDirectory } from '../dist/VmBackupDirectory.mjs'
|
||||
import { RemoteVhdDisk } from '../dist/disks/RemoteVhdDisk.mjs'
|
||||
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/'
|
||||
|
||||
@@ -418,118 +412,6 @@ test('it merges a chain of multiple consecutive orphan ancestors in one pass', a
|
||||
assert.equal(remainingVhds.includes('child.vhd'), false)
|
||||
})
|
||||
|
||||
test('it resumes, through cleanVm, an interrupted merge whose ancestor lost its footer', async () => {
|
||||
// Reproduces the production "footer1 !== footer2" failure end-to-end via the full cleanVm
|
||||
// pipeline. ancestor (full) <- child (differencing, the active backup).
|
||||
const ancestor = await generateVhd(`${basePath}/ancestor.vhd`, { blocks: [0, 1] })
|
||||
await generateVhd(`${basePath}/child.vhd`, {
|
||||
header: { parentUnicodeName: 'ancestor.vhd', parentUuid: ancestor.footer.uuid },
|
||||
blocks: [2, 3, 4, 5],
|
||||
})
|
||||
await handler.writeFile(
|
||||
`${rootPath}/metadata.json`,
|
||||
JSON.stringify({ mode: 'delta', size: 12000, vhds: [`${relativePath}/child.vhd`] })
|
||||
)
|
||||
|
||||
// Simulate a merge killed mid-transfer: write 2 of the 4 child blocks into the ancestor
|
||||
// (which overwrites its end footer) then throw before mergeMetadata() rewrites the footer.
|
||||
// This leaves the ancestor footerless AND a `.merge.json` state file — the exact post-crash
|
||||
// state that makes cleanVm take the resume path.
|
||||
const parent = new RemoteVhdDisk({ handler, path: `${basePath}/ancestor.vhd` })
|
||||
const child = new RemoteVhdDisk({ handler, path: `${basePath}/child.vhd` })
|
||||
await parent.init({ force: false })
|
||||
await child.init({ force: false })
|
||||
const merger = new MergeRemoteDisk(handler, { removeUnused: true, writeStateDelay: 0 })
|
||||
let written = 0
|
||||
const realWriteBlock = parent.writeBlock.bind(parent)
|
||||
parent.writeBlock = async diskBlock => {
|
||||
if (written === 2) {
|
||||
throw new Error('simulated interruption')
|
||||
}
|
||||
written++
|
||||
return realWriteBlock(diskBlock)
|
||||
}
|
||||
await assert.rejects(merger.merge(parent, child), /simulated interruption/)
|
||||
|
||||
assert.ok(
|
||||
(await handler.list(basePath)).includes('.ancestor.vhd.merge.json'),
|
||||
'an interrupted-merge state file should remain'
|
||||
)
|
||||
|
||||
// Full pipeline: cleanVm must recognize the interrupted merge and resume it — opening the
|
||||
// footerless ancestor through the chain without throwing "footer1 !== footer2".
|
||||
await VmBackupDirectory.cleanVm(handler, rootPath, {
|
||||
remove: true,
|
||||
merge: true,
|
||||
logInfo: () => {},
|
||||
logWarn: () => {},
|
||||
})
|
||||
|
||||
// The merge completed: the ancestor was consolidated into child.vhd and the state file is gone.
|
||||
const remaining = await handler.list(basePath)
|
||||
assert.equal(remaining.includes('.ancestor.vhd.merge.json'), false, 'state file removed after successful resume')
|
||||
assert.equal(remaining.includes('ancestor.vhd'), false, 'ancestor consolidated into the merge target')
|
||||
assert.equal(remaining.includes('child.vhd'), true, 'merge target remains')
|
||||
|
||||
// No blocks lost: the resumed merge wrote the blocks (4, 5) that were never written before
|
||||
// the crash, so the consolidated disk holds the full set.
|
||||
const merged = new RemoteVhdDisk({ handler, path: `${basePath}/child.vhd` })
|
||||
await merged.init({ force: false })
|
||||
try {
|
||||
assert.deepEqual(merged.getBlockIndexes(), [0, 1, 2, 3, 4, 5], 'all blocks present after resumed merge')
|
||||
} finally {
|
||||
await merged.close()
|
||||
}
|
||||
|
||||
// The backup is consistent, so its metadata is preserved.
|
||||
assert.ok((await handler.list(rootPath)).includes('metadata.json'), 'metadata should be preserved')
|
||||
})
|
||||
|
||||
test('it does not warn "missing target of alias" for aliases deleted by merge', async () => {
|
||||
// Regression: RemoteDiskLineage.#cleanOrphanDataFiles iterated #diskPaths entries just
|
||||
// deleted during the same clean() call's merge phase, producing false "missing target of
|
||||
// alias" warnings
|
||||
const orphan = await generateVhd(`${basePath}/orphan.vhd`, {
|
||||
useAlias: true,
|
||||
blocks: [0],
|
||||
})
|
||||
await generateVhd(`${basePath}/child.vhd`, {
|
||||
useAlias: true,
|
||||
header: {
|
||||
parentUnicodeName: 'orphan.vhd.alias.vhd',
|
||||
parentUuid: orphan.footer.uuid,
|
||||
},
|
||||
blocks: [1],
|
||||
})
|
||||
|
||||
await handler.writeFile(
|
||||
`${rootPath}/metadata.json`,
|
||||
JSON.stringify({
|
||||
mode: 'delta',
|
||||
vhds: [`${relativePath}/child.vhd.alias.vhd`],
|
||||
})
|
||||
)
|
||||
|
||||
const warnings = []
|
||||
await VmBackupDirectory.cleanVm(handler, rootPath, {
|
||||
remove: true,
|
||||
merge: true,
|
||||
logWarn: (message, data) => warnings.push({ message, data }),
|
||||
logInfo: () => {},
|
||||
})
|
||||
|
||||
const missingTargetWarnings = warnings.filter(w => w.message === 'missing target of alias')
|
||||
assert.equal(
|
||||
missingTargetWarnings.length,
|
||||
0,
|
||||
`"missing target of alias" must not fire after merge; got: ${JSON.stringify(missingTargetWarnings)}`
|
||||
)
|
||||
|
||||
const remaining = await handler.list(basePath)
|
||||
assert.ok(!remaining.includes('orphan.vhd.alias.vhd'), 'orphan alias must be deleted after merge')
|
||||
assert.ok(remaining.includes('child.vhd.alias.vhd'), 'child alias must survive as merge target')
|
||||
})
|
||||
|
||||
test('it resumes an interrupted merge with chain field', async () => {
|
||||
await handler.writeFile(
|
||||
`${rootPath}/metadata.json`,
|
||||
@@ -832,28 +714,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')
|
||||
})
|
||||
|
||||
299
@xen-orchestra/backup-archive/src/disks/RemoteRawDisk.mjs
Normal file
299
@xen-orchestra/backup-archive/src/disks/RemoteRawDisk.mjs
Normal file
@@ -0,0 +1,299 @@
|
||||
// @ts-check
|
||||
|
||||
/**
|
||||
* @typedef {import('@xen-orchestra/disk-transform').DiskBlock} DiskBlock
|
||||
* @typedef {import('@xen-orchestra/fs').RemoteHandlerAbstract} RemoteHandlerAbstract
|
||||
*/
|
||||
|
||||
import { RemoteDisk } from './RemoteDisk.mjs'
|
||||
|
||||
const BLOCK_SIZE = 2 * 1024 * 1024 // 2 MiB
|
||||
|
||||
/**
|
||||
* Raw flat-file disk implementation for dedup-capable storage.
|
||||
*
|
||||
* Layout (both files at the same level in the VDI directory):
|
||||
* <uuid>.raw – JSON metadata: { uuid, virtualSize, blockSize }
|
||||
* <uuid>.raw.data – binary data file: ceil(virtualSize / blockSize) * blockSize bytes
|
||||
* block N starts at offset N * blockSize
|
||||
*
|
||||
* There is no BAT in V1: hasBlock() always returns true.
|
||||
* Non-allocated blocks are filled with zeros; dedup storage deduplicates them.
|
||||
* Writes are expected sequentially (blocks 0…N-1 in order) for optimal streaming.
|
||||
* The data file is pre-allocated on create() as a sparse file; all block-level reads
|
||||
* are therefore safe (sparse holes read back as zeros).
|
||||
*/
|
||||
export class RemoteRawDisk extends RemoteDisk {
|
||||
/** @type {string} */
|
||||
#path
|
||||
|
||||
/** @type {string} */
|
||||
#dataPath
|
||||
|
||||
/** @type {RemoteHandlerAbstract} */
|
||||
#handler
|
||||
|
||||
/** @type {string | undefined} */
|
||||
#uuid
|
||||
|
||||
/** @type {number | undefined} */
|
||||
#virtualSize
|
||||
|
||||
/**
|
||||
* @param {Object} params
|
||||
* @param {RemoteHandlerAbstract} params.handler
|
||||
* @param {string} params.path path to the <uuid>.raw JSON file
|
||||
*/
|
||||
constructor({ handler, path }) {
|
||||
super()
|
||||
this.#path = path
|
||||
this.#dataPath = path + '.data'
|
||||
this.#handler = handler
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Static factory
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Creates a new raw disk on the remote storage.
|
||||
* Writes the JSON metadata and pre-allocates the data file as a sparse file.
|
||||
*
|
||||
* @param {Object} params
|
||||
* @param {RemoteHandlerAbstract} params.handler
|
||||
* @param {string} params.path path for the <uuid>.raw JSON file
|
||||
* @param {number} params.virtualSize exact virtual disk size in bytes
|
||||
* @param {string} params.uuid
|
||||
* @returns {Promise<RemoteRawDisk>}
|
||||
*/
|
||||
static async create({ handler, path, virtualSize, uuid }) {
|
||||
const blockCount = Math.ceil(virtualSize / BLOCK_SIZE)
|
||||
const fileSize = blockCount * BLOCK_SIZE
|
||||
|
||||
const metadata = JSON.stringify({ uuid, virtualSize, blockSize: BLOCK_SIZE })
|
||||
await handler.outputFile(path, metadata, { flags: 'wx' })
|
||||
|
||||
// Create the data file then extend it to fileSize bytes via a sparse write.
|
||||
// We open a FileDescriptor to satisfy handler.write()'s FileArg type.
|
||||
// On local/NFS/ZFS this produces a sparse file; the hole reads back as zeros.
|
||||
const dataPath = path + '.data'
|
||||
await handler.outputFile(dataPath, Buffer.alloc(0), { flags: 'wx' })
|
||||
const fd = await handler.openFile(dataPath, 'r+')
|
||||
try {
|
||||
await handler.write(/** @type {any} */ (fd), Buffer.alloc(1, 0), fileSize - 1)
|
||||
} finally {
|
||||
await handler.closeFile(fd)
|
||||
}
|
||||
|
||||
const disk = new RemoteRawDisk({ handler, path })
|
||||
disk.#uuid = uuid
|
||||
disk.#virtualSize = virtualSize
|
||||
return disk
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Object} [options]
|
||||
* @param {boolean} [options.force]
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async init(_options = {}) {
|
||||
const raw = await this.#handler.readFile(this.#path)
|
||||
const meta = JSON.parse(raw)
|
||||
this.#uuid = meta.uuid
|
||||
this.#virtualSize = meta.virtualSize
|
||||
}
|
||||
|
||||
async close() {
|
||||
// No persistent file handles to release.
|
||||
}
|
||||
|
||||
getVirtualSize() {
|
||||
if (this.#virtualSize === undefined) throw new Error('RemoteRawDisk not initialized')
|
||||
return this.#virtualSize
|
||||
}
|
||||
|
||||
getSizeOnDisk() {
|
||||
return this.getMaxBlockCount() * BLOCK_SIZE
|
||||
}
|
||||
|
||||
getBlockSize() {
|
||||
return BLOCK_SIZE
|
||||
}
|
||||
|
||||
getPath() {
|
||||
return this.#path
|
||||
}
|
||||
|
||||
getPaths() {
|
||||
return [this.#path, this.#dataPath]
|
||||
}
|
||||
|
||||
getUuid() {
|
||||
if (this.#uuid === undefined) throw new Error('RemoteRawDisk not initialized')
|
||||
return this.#uuid
|
||||
}
|
||||
|
||||
/** @returns {string} */
|
||||
getParentUuid() {
|
||||
throw new Error('RemoteRawDisk has no parent')
|
||||
}
|
||||
|
||||
/** @returns {string} */
|
||||
getParentPath() {
|
||||
throw new Error('RemoteRawDisk has no parent')
|
||||
}
|
||||
|
||||
getMetadata() {
|
||||
return {
|
||||
uuid: this.getUuid(),
|
||||
virtualSize: this.getVirtualSize(),
|
||||
blockSize: BLOCK_SIZE,
|
||||
}
|
||||
}
|
||||
|
||||
isDifferencing() {
|
||||
return false
|
||||
}
|
||||
|
||||
/** V1: all blocks are considered present. */
|
||||
hasBlock(_index) {
|
||||
return true
|
||||
}
|
||||
|
||||
getBlockIndexes() {
|
||||
const count = this.getMaxBlockCount()
|
||||
return Array.from({ length: count }, (_, i) => i)
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {DiskBlock} diskBlock
|
||||
* @returns {Promise<number>} blockSize
|
||||
*/
|
||||
async writeBlock(diskBlock) {
|
||||
const offset = diskBlock.index * BLOCK_SIZE
|
||||
const fd = await this.#handler.openFile(this.#dataPath, 'r+')
|
||||
try {
|
||||
await this.#handler.write(/** @type {any} */ (fd), diskBlock.data, offset)
|
||||
} finally {
|
||||
await this.#handler.closeFile(fd)
|
||||
}
|
||||
return BLOCK_SIZE
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} index
|
||||
* @returns {Promise<DiskBlock>}
|
||||
*/
|
||||
async readBlock(index) {
|
||||
const offset = index * BLOCK_SIZE
|
||||
const data = Buffer.alloc(BLOCK_SIZE, 0)
|
||||
// handler.read() accepts FileDescriptor which includes strings
|
||||
await this.#handler.read(this.#dataPath, data, offset)
|
||||
return { index, data }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Operations not applicable to raw / always-full disks
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** @returns {RemoteDisk} */
|
||||
instantiateParent() {
|
||||
throw new Error('RemoteRawDisk has no parent')
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {RemoteDisk} _childDisk
|
||||
* @param {number} _index
|
||||
* @param {boolean} _isResumingMerge
|
||||
* @returns {Promise<number>}
|
||||
*/
|
||||
async mergeBlock(_childDisk, _index, _isResumingMerge) {
|
||||
throw new Error('RemoteRawDisk does not support merge')
|
||||
}
|
||||
|
||||
async canMergeConcurently() {
|
||||
return false
|
||||
}
|
||||
|
||||
/** No-op: BAT not used in V1. */
|
||||
async setAllocatedBlocks(_blockIds) {}
|
||||
|
||||
/** No-op: no BAT to flush. */
|
||||
async flushMetadata(_childDisk) {}
|
||||
|
||||
/**
|
||||
* @param {RemoteDisk} _childDisk
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async mergeMetadata(_childDisk) {
|
||||
throw new Error('RemoteRawDisk does not support merge')
|
||||
}
|
||||
|
||||
/**
|
||||
* Extends the data file and updates virtualSize in the JSON metadata.
|
||||
* @param {number} newBlockCount
|
||||
*/
|
||||
async resize(newBlockCount) {
|
||||
const newVirtualSize = newBlockCount * BLOCK_SIZE
|
||||
const fd = await this.#handler.openFile(this.#dataPath, 'r+')
|
||||
try {
|
||||
await this.#handler.write(/** @type {any} */ (fd), Buffer.alloc(1, 0), newVirtualSize - 1)
|
||||
} finally {
|
||||
await this.#handler.closeFile(fd)
|
||||
}
|
||||
const metadata = JSON.stringify({ uuid: this.getUuid(), virtualSize: newVirtualSize, blockSize: BLOCK_SIZE })
|
||||
await this.#handler.outputFile(this.#path, metadata, { flags: 'w' })
|
||||
this.#virtualSize = newVirtualSize
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} newPath new path for the <uuid>.raw JSON file
|
||||
*/
|
||||
async rename(newPath) {
|
||||
await this.#handler.rename(this.#dataPath, newPath + '.data')
|
||||
await this.#handler.rename(this.#path, newPath)
|
||||
this.#path = newPath
|
||||
this.#dataPath = newPath + '.data'
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Object} [options]
|
||||
* @param {boolean} [options.force]
|
||||
*/
|
||||
async unlink({ force = false } = {}) {
|
||||
const del = p =>
|
||||
this.#handler.unlink(p).catch(err => {
|
||||
if (force && err?.code === 'ENOENT') return
|
||||
throw err
|
||||
})
|
||||
await del(this.#dataPath)
|
||||
await del(this.#path)
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies both files are accessible.
|
||||
* @param {Object} [opts]
|
||||
* @param {Function} [opts.logWarn]
|
||||
* @returns {Promise<string | undefined>}
|
||||
*/
|
||||
async clean({ logWarn } = {}) {
|
||||
try {
|
||||
await this.#handler.readFile(this.#path)
|
||||
await this.#handler.getSize(this.#dataPath)
|
||||
return this.#path
|
||||
} catch (error) {
|
||||
logWarn?.('RemoteRawDisk integrity check failed', { path: this.#path, error })
|
||||
return undefined
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns both files that belong to this disk.
|
||||
* Both are siblings in the same vdiDir, so #cleanOrphanDataFiles skips them (by design in V1).
|
||||
* @param {string} _dir
|
||||
* @returns {Promise<string[]>}
|
||||
*/
|
||||
async listAssociatedFiles(_dir) {
|
||||
return [this.#path, this.#dataPath]
|
||||
}
|
||||
}
|
||||
244
@xen-orchestra/backup-archive/src/disks/RemoteRawDisk.test.mjs
Normal file
244
@xen-orchestra/backup-archive/src/disks/RemoteRawDisk.test.mjs
Normal file
@@ -0,0 +1,244 @@
|
||||
import { test } from 'node:test'
|
||||
import { strict as assert } from 'node:assert'
|
||||
|
||||
import tmp from 'tmp'
|
||||
import fs from 'fs-extra'
|
||||
import * as uuid from 'uuid'
|
||||
import { getHandler } from '@xen-orchestra/fs'
|
||||
import { pFromCallback } from 'promise-toolbox'
|
||||
import { rimraf } from 'rimraf'
|
||||
|
||||
import { RemoteRawDisk } from './RemoteRawDisk.mjs'
|
||||
|
||||
const { beforeEach, afterEach, describe } = test
|
||||
|
||||
const BLOCK_SIZE = 2 * 1024 * 1024 // 2 MiB
|
||||
const VIRTUAL_SIZE = 10 * BLOCK_SIZE // 10 blocks = 20 MiB
|
||||
|
||||
let tempDir, handler, basePath
|
||||
|
||||
const rootPath = 'xo-vm-backups/VMUUID'
|
||||
const uniqueId = () => uuid.v1()
|
||||
|
||||
beforeEach(async () => {
|
||||
tempDir = await pFromCallback(cb => tmp.dir(cb))
|
||||
handler = getHandler({ url: `file://${tempDir}` })
|
||||
await handler.sync()
|
||||
const jobId = uniqueId()
|
||||
const vdiId = uniqueId()
|
||||
basePath = `${rootPath}/vdis/${jobId}/${vdiId}`
|
||||
await fs.mkdirp(`${tempDir}/${basePath}`)
|
||||
})
|
||||
|
||||
afterEach(async () => {
|
||||
await rimraf(tempDir)
|
||||
await handler.forget()
|
||||
})
|
||||
|
||||
describe('RemoteRawDisk', { concurrency: 1 }, () => {
|
||||
test('create initializes JSON and data file', async () => {
|
||||
const diskUuid = uniqueId()
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
await RemoteRawDisk.create({ handler, path: diskPath, virtualSize: VIRTUAL_SIZE, uuid: diskUuid })
|
||||
|
||||
// JSON metadata must exist
|
||||
const meta = JSON.parse(await handler.readFile(diskPath))
|
||||
assert.equal(meta.uuid, diskUuid)
|
||||
assert.equal(meta.virtualSize, VIRTUAL_SIZE)
|
||||
assert.equal(meta.blockSize, BLOCK_SIZE)
|
||||
|
||||
// Data file must exist with size = maxBlockCount * BLOCK_SIZE
|
||||
const expectedFileSize = Math.ceil(VIRTUAL_SIZE / BLOCK_SIZE) * BLOCK_SIZE
|
||||
const actualSize = await handler.getSize(diskPath + '.data')
|
||||
assert.equal(actualSize, expectedFileSize)
|
||||
})
|
||||
|
||||
test('init reads JSON metadata', async () => {
|
||||
const diskUuid = uniqueId()
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
await RemoteRawDisk.create({ handler, path: diskPath, virtualSize: VIRTUAL_SIZE, uuid: diskUuid })
|
||||
|
||||
const disk = new RemoteRawDisk({ handler, path: diskPath })
|
||||
await disk.init()
|
||||
|
||||
assert.equal(disk.getUuid(), diskUuid)
|
||||
assert.equal(disk.getVirtualSize(), VIRTUAL_SIZE)
|
||||
assert.equal(disk.getBlockSize(), BLOCK_SIZE)
|
||||
assert.equal(disk.isDifferencing(), false)
|
||||
})
|
||||
|
||||
test('writeBlock and readBlock round-trip', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
const blockIndex = 3
|
||||
const written = Buffer.alloc(BLOCK_SIZE, blockIndex)
|
||||
await disk.writeBlock({ index: blockIndex, data: written })
|
||||
|
||||
const { index, data } = await disk.readBlock(blockIndex)
|
||||
assert.equal(index, blockIndex)
|
||||
assert.equal(data.length, BLOCK_SIZE)
|
||||
assert.ok(data.equals(written), 'read data must equal written data')
|
||||
})
|
||||
|
||||
test('unwritten blocks read back as zeros', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
const { data } = await disk.readBlock(0)
|
||||
assert.ok(data.equals(Buffer.alloc(BLOCK_SIZE, 0)), 'unwritten block must read as zeros')
|
||||
})
|
||||
|
||||
test('hasBlock always returns true (V1)', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
const blockCount = disk.getMaxBlockCount()
|
||||
for (let i = 0; i < blockCount; i++) {
|
||||
assert.equal(disk.hasBlock(i), true)
|
||||
}
|
||||
})
|
||||
|
||||
test('getBlockIndexes covers all blocks', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
const indexes = disk.getBlockIndexes()
|
||||
const expected = Array.from({ length: disk.getMaxBlockCount() }, (_, i) => i)
|
||||
assert.deepEqual(indexes, expected)
|
||||
})
|
||||
|
||||
test('resize extends data file and updates JSON', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
const newBlockCount = disk.getMaxBlockCount() + 5
|
||||
await disk.resize(newBlockCount)
|
||||
|
||||
const newVirtualSize = newBlockCount * BLOCK_SIZE
|
||||
assert.equal(disk.getVirtualSize(), newVirtualSize)
|
||||
|
||||
const meta = JSON.parse(await handler.readFile(diskPath))
|
||||
assert.equal(meta.virtualSize, newVirtualSize)
|
||||
|
||||
const actualSize = await handler.getSize(diskPath + '.data')
|
||||
assert.equal(actualSize, newVirtualSize)
|
||||
})
|
||||
|
||||
test('listAssociatedFiles returns JSON and data paths', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
const files = await disk.listAssociatedFiles(basePath)
|
||||
assert.ok(files.includes(diskPath), 'must include JSON path')
|
||||
assert.ok(files.includes(diskPath + '.data'), 'must include data path')
|
||||
assert.equal(files.length, 2)
|
||||
})
|
||||
|
||||
test('unlink removes both JSON and data files', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
await disk.unlink()
|
||||
|
||||
const files = await handler.list(basePath)
|
||||
assert.ok(!files.includes('snap.raw'), 'JSON file must be deleted')
|
||||
assert.ok(!files.includes('snap.raw.data'), 'data file must be deleted')
|
||||
})
|
||||
|
||||
test('rename moves both files', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
const newPath = `${basePath}/snap2.raw`
|
||||
await disk.rename(newPath)
|
||||
|
||||
const files = await handler.list(basePath)
|
||||
assert.ok(files.includes('snap2.raw'), 'renamed JSON file must exist')
|
||||
assert.ok(files.includes('snap2.raw.data'), 'renamed data file must exist')
|
||||
assert.ok(!files.includes('snap.raw'), 'old JSON file must be gone')
|
||||
assert.ok(!files.includes('snap.raw.data'), 'old data file must be gone')
|
||||
|
||||
assert.equal(disk.getPath(), newPath)
|
||||
})
|
||||
|
||||
test('isDifferencing returns false', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
assert.equal(disk.isDifferencing(), false)
|
||||
})
|
||||
|
||||
test('getParentPath throws', async () => {
|
||||
const diskPath = `${basePath}/snap.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: VIRTUAL_SIZE,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
assert.throws(() => disk.getParentPath(), /no parent/)
|
||||
})
|
||||
|
||||
test('last block alignment: virtualSize not a multiple of blockSize', async () => {
|
||||
// 10 MiB + 1 byte → 6 blocks needed, file size = 6 * BLOCK_SIZE
|
||||
const unalignedSize = 5 * BLOCK_SIZE + 1
|
||||
const diskPath = `${basePath}/unaligned.raw`
|
||||
const disk = await RemoteRawDisk.create({
|
||||
handler,
|
||||
path: diskPath,
|
||||
virtualSize: unalignedSize,
|
||||
uuid: uniqueId(),
|
||||
})
|
||||
|
||||
assert.equal(disk.getMaxBlockCount(), 6)
|
||||
const actualSize = await handler.getSize(diskPath + '.data')
|
||||
assert.equal(actualSize, 6 * BLOCK_SIZE)
|
||||
// virtualSize in JSON is the exact (unaligned) value
|
||||
assert.equal(disk.getVirtualSize(), unalignedSize)
|
||||
})
|
||||
})
|
||||
@@ -471,12 +471,10 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
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 })
|
||||
} catch (_err) {
|
||||
// Alias resolution failed (broken, too big, missing target, directory, …).
|
||||
// With force=true we still want to be able to delete the file, so fall
|
||||
// back to the alias path itself; the unlink below will clean it up.
|
||||
}
|
||||
try {
|
||||
await this.#handler.unlink(resolved)
|
||||
@@ -598,7 +596,12 @@ export class RemoteVhdDisk extends RemoteDisk {
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
logWarn('unhandled error while checking alias', { alias: this.#path, err })
|
||||
// Alias file is corrupt or malformed (e.g. raw data written at this path).
|
||||
logWarn('corrupt alias file', { alias: this.#path, err })
|
||||
if (remove) {
|
||||
logInfo('removing corrupt alias file', { alias: this.#path })
|
||||
await this.#handler.unlink(this.#path)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
|
||||
@@ -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]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,11 +1,13 @@
|
||||
import { RemoteVhdDisk } from './RemoteVhdDisk.mjs'
|
||||
import { RemoteRawDisk } from './RemoteRawDisk.mjs'
|
||||
|
||||
export { RemoteDisk } from './RemoteDisk.mjs'
|
||||
export { RemoteVhdDisk } from './RemoteVhdDisk.mjs'
|
||||
export { RemoteRawDisk } from './RemoteRawDisk.mjs'
|
||||
export { openDiskChain } from './openDiskChain.mjs'
|
||||
export { MergeRemoteDisk } from './MergeRemoteDisk.mjs'
|
||||
|
||||
const DISK_EXTENSIONS = ['.vhd']
|
||||
const DISK_EXTENSIONS = ['.vhd', '.raw']
|
||||
|
||||
/**
|
||||
* @typedef {import('@xen-orchestra/fs').RemoteHandlerAbstract} RemoteHandlerAbstract
|
||||
@@ -27,7 +29,7 @@ export function isDisk(path) {
|
||||
* @returns {Promise<Disposable<RemoteDisk>>}
|
||||
*/
|
||||
export async function openDisposableDisk({ handler, path, force = false, ignoreBlockIndexes = false }) {
|
||||
const disk = new RemoteVhdDisk({ handler, path })
|
||||
const disk = path.endsWith('.raw') ? new RemoteRawDisk({ handler, path }) : new RemoteVhdDisk({ handler, path })
|
||||
if (ignoreBlockIndexes) {
|
||||
// Best-effort init: return the disk even if init fails so that callers
|
||||
// can still use operations that work without a fully-opened VHD (e.g. unlink, checkAlias).
|
||||
@@ -50,7 +52,7 @@ export async function openDisposableDisk({ handler, path, force = false, ignoreB
|
||||
* @returns {Promise<RemoteDisk>}
|
||||
*/
|
||||
export async function openDisk({ handler, path, force = false, ignoreBlockIndexes = false }) {
|
||||
const disk = new RemoteVhdDisk({ handler, path })
|
||||
const disk = path.endsWith('.raw') ? new RemoteRawDisk({ handler, path }) : new RemoteVhdDisk({ handler, path })
|
||||
if (ignoreBlockIndexes) {
|
||||
// Best-effort init: return the disk even if init fails so that callers
|
||||
// can still use operations that work without a fully-opened VHD (e.g. unlink, checkAlias).
|
||||
|
||||
@@ -5,6 +5,7 @@
|
||||
* @typedef {import('./RemoteDisk.mjs').RemoteDisk} RemoteDisk
|
||||
*/
|
||||
import { RemoteVhdDisk } from './RemoteVhdDisk.mjs'
|
||||
import { RemoteRawDisk } from './RemoteRawDisk.mjs'
|
||||
import { defer } from 'golike-defer'
|
||||
import { RemoteVhdDiskChain } from './RemoteVhdDiskChain.mjs'
|
||||
|
||||
@@ -15,10 +16,16 @@ import { RemoteVhdDiskChain } from './RemoteVhdDiskChain.mjs'
|
||||
* @param {string} params.path
|
||||
* @param {string | undefined} params.until
|
||||
* @param {boolean} [params.force]
|
||||
* @param {boolean} [params.ignoreBlockIndexes] - skip reading the block allocation table of each disk (cheaper, but blocks can't be read)
|
||||
* @returns {Promise<RemoteDisk>}
|
||||
*/
|
||||
async function _openDiskChain($defer, { handler, path, until, force = false, ignoreBlockIndexes = false }) {
|
||||
async function _openDiskChain($defer, { handler, path, until, force = false }) {
|
||||
if (path.endsWith('.raw')) {
|
||||
// Raw disks are always full — no chain to traverse.
|
||||
const disk = new RemoteRawDisk({ handler, path })
|
||||
await disk.init({ force })
|
||||
return disk
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {RemoteVhdDisk}
|
||||
*/
|
||||
@@ -30,18 +37,16 @@ async function _openDiskChain($defer, { handler, path, until, force = false, ign
|
||||
$defer.onFailure(() => Promise.all(disks.map(disk => disk.close())))
|
||||
disk = new RemoteVhdDisk({ handler, path })
|
||||
|
||||
await disk.init({ force, ignoreBlockIndexes })
|
||||
await disk.init({ force })
|
||||
disks.push(disk)
|
||||
let foundRootDisk = until === undefined
|
||||
while (disk.isDifferencing()) {
|
||||
if (disk.getParentPath() === until) {
|
||||
disk = await disk.openParent()
|
||||
if (disk.getPath() === until) {
|
||||
foundRootDisk = true
|
||||
await disk.close()
|
||||
break
|
||||
}
|
||||
// Instantiate + init the parent directly (instead of openParent()) so the
|
||||
// block allocation table read can be skipped when ignoreBlockIndexes is set.
|
||||
disk = /** @type {RemoteVhdDisk} */ (disk.instantiateParent())
|
||||
await disk.init({ force, ignoreBlockIndexes })
|
||||
disks.unshift(disk)
|
||||
}
|
||||
if (!foundRootDisk) {
|
||||
@@ -52,6 +57,6 @@ async function _openDiskChain($defer, { handler, path, until, force = false, ign
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {(params: { handler: RemoteHandlerAbstract, path: string, until?: string, force?: boolean, ignoreBlockIndexes?: boolean }) => Promise<RemoteDisk>}
|
||||
* @type {(params: { handler: RemoteHandlerAbstract, path: string, until?: string, force?: boolean }) => Promise<RemoteDisk>}
|
||||
*/
|
||||
export const openDiskChain = defer(_openDiskChain)
|
||||
|
||||
@@ -8,8 +8,8 @@
|
||||
"dependencies": {
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@xen-orchestra/async-map": "^0.1.3",
|
||||
"@xen-orchestra/backups": "^0.73.10",
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/backups": "^0.73.2",
|
||||
"@xen-orchestra/fs": "^4.9.0",
|
||||
"filenamify": "^6.0.0",
|
||||
"getopts": "^2.2.5",
|
||||
"lodash": "^4.18.0",
|
||||
|
||||
@@ -20,9 +20,10 @@ import { isMetadataFile } from './_backupType.mjs'
|
||||
import { isValidXva } from './_isValidXva.mjs'
|
||||
import { watchStreamSize } from './_watchStreamSize.mjs'
|
||||
|
||||
import { RemoteVhdDisk, openDiskChain } from '@xen-orchestra/backup-archive/disks'
|
||||
import { toVhdStream, writeToVhdDirectory } from 'vhd-lib/disk-consumer/index.mjs'
|
||||
import { RemoteVhdDisk, RemoteRawDisk, openDiskChain } from '@xen-orchestra/backup-archive/disks'
|
||||
import { DiskConsumerRawStream } from 'vhd-lib/disk-consumer/index.mjs'
|
||||
import { ReadAhead } from '@xen-orchestra/disk-transform'
|
||||
import { randomUUID } from 'node:crypto'
|
||||
|
||||
export const DIR_XO_CONFIG_BACKUPS = 'xo-config-backups'
|
||||
|
||||
@@ -225,6 +226,10 @@ export class RemoteAdapter {
|
||||
return `${baseName}.vhd`
|
||||
}
|
||||
|
||||
getDiskFileName(baseName) {
|
||||
return `${baseName}.raw`
|
||||
}
|
||||
|
||||
async listAllVms() {
|
||||
const handler = this._handler
|
||||
const vmsUuids = []
|
||||
@@ -315,11 +320,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 +388,8 @@ export class RemoteAdapter {
|
||||
return
|
||||
}
|
||||
|
||||
await this._writeCache(path, backups)
|
||||
// detached async action, will not reject
|
||||
this._writeCache(path, backups)
|
||||
|
||||
return backups
|
||||
}
|
||||
@@ -453,34 +454,19 @@ export class RemoteAdapter {
|
||||
return path
|
||||
}
|
||||
|
||||
async writeVhd(path, disk, { validator = noop, writeBlockConcurrency, uuid, parentUuid, parentPath } = {}) {
|
||||
const handler = this._handler
|
||||
async writeVhd(path, disk, { validator = noop, writeBlockConcurrency = 4 } = {}) {
|
||||
const BLOCK_SIZE = 2 * 1024 * 1024
|
||||
const virtualSize = disk.getVirtualSize()
|
||||
|
||||
if (this.useVhdDirectory()) {
|
||||
return await writeToVhdDirectory({
|
||||
disk,
|
||||
target: {
|
||||
handler,
|
||||
path,
|
||||
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,
|
||||
})
|
||||
await validator(path)
|
||||
return size
|
||||
}
|
||||
// Write JSON metadata to <path> (the .raw file recognised by RemoteRawDisk)
|
||||
const metadata = JSON.stringify({ uuid: randomUUID(), virtualSize, blockSize: BLOCK_SIZE })
|
||||
await this._handler.outputFile(path, metadata, { flags: 'wx' })
|
||||
|
||||
// Write binary data to <path>.data using sparse pwrite with ReadAhead pipelining
|
||||
const consumer = new DiskConsumerRawStream(disk)
|
||||
const stream = await consumer.toStream()
|
||||
const size = await this.outputStream(path + '.data', stream, { checksum: false })
|
||||
return size
|
||||
}
|
||||
|
||||
async outputStream(
|
||||
@@ -505,7 +491,11 @@ export class RemoteAdapter {
|
||||
// open the hierarchy of ancestors until we find a full one
|
||||
async _createVhdDisk(handler, path, { useChain }) {
|
||||
let disk
|
||||
if (useChain) {
|
||||
if (path.endsWith('.raw')) {
|
||||
// Raw disks are always full — no chain to open
|
||||
disk = new RemoteRawDisk({ handler, path })
|
||||
await disk.init()
|
||||
} else if (useChain) {
|
||||
disk = await openDiskChain({ handler, path })
|
||||
} else {
|
||||
disk = new RemoteVhdDisk({ handler, path })
|
||||
|
||||
@@ -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,44 +16,6 @@ import { toQcow2Stream } from '@xen-orchestra/qcow2'
|
||||
|
||||
const ensureArray = value => (value === undefined ? [] : Array.isArray(value) ? value : [value])
|
||||
|
||||
const orderedMemoryLimits = ['memory_static_min', 'memory_dynamic_min', 'memory_dynamic_max', 'memory_static_max']
|
||||
|
||||
// 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(
|
||||
vm,
|
||||
baseVdis = {},
|
||||
@@ -198,9 +160,6 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
|
||||
let vmRef
|
||||
if (isUpdate) {
|
||||
vmRef = targetRef
|
||||
|
||||
await updateMemoryFields(xapi, targetVm, vmRecord)
|
||||
|
||||
await Promise.all([
|
||||
xapi.setFields('VM', vmRef, {
|
||||
actions_after_crash: vmRecord.actions_after_crash,
|
||||
@@ -212,6 +171,10 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
|
||||
HVM_boot_params: vmRecord.HVM_boot_params,
|
||||
HVM_boot_policy: vmRecord.HVM_boot_policy,
|
||||
HVM_shadow_multiplier: vmRecord.HVM_shadow_multiplier,
|
||||
memory_dynamic_max: vmRecord.memory_dynamic_max,
|
||||
memory_dynamic_min: vmRecord.memory_dynamic_min,
|
||||
memory_static_max: vmRecord.memory_static_max,
|
||||
memory_static_min: vmRecord.memory_static_min,
|
||||
name_label: vmRecord.name_label,
|
||||
name_description: vmRecord.name_description,
|
||||
order: vmRecord.order,
|
||||
|
||||
@@ -1,122 +0,0 @@
|
||||
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,
|
||||
|
||||
@@ -137,7 +137,6 @@ export const VmsRemote = class RemoteVmsBackupRunner extends Abstract {
|
||||
task.warning(`Retry the VM mirror backup due to an error`, {
|
||||
attempt: nTriesByVmId[vmUuid],
|
||||
error: taskError.message,
|
||||
isRetry: true,
|
||||
})
|
||||
queue.add(vmUuid)
|
||||
})
|
||||
|
||||
@@ -101,14 +101,10 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
|
||||
|
||||
const handleVm = vmUuid => {
|
||||
const getVmTask = () => {
|
||||
const started = taskByVmId[vmUuid] !== undefined
|
||||
if (!started) {
|
||||
if (taskByVmId[vmUuid] === undefined) {
|
||||
taskByVmId[vmUuid] = new Task(taskStart)
|
||||
}
|
||||
return {
|
||||
task: taskByVmId[vmUuid],
|
||||
started,
|
||||
}
|
||||
return taskByVmId[vmUuid]
|
||||
}
|
||||
const vmBackupFailed = async (error, task) => {
|
||||
if (isLastRun) {
|
||||
@@ -118,7 +114,6 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
|
||||
task.warning(`Retry the VM backup due to an error`, {
|
||||
attempt: nTriesByVmId[vmUuid],
|
||||
error: error.message,
|
||||
isRetry: true,
|
||||
})
|
||||
queue.add(vmUuid)
|
||||
}
|
||||
@@ -140,7 +135,7 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
|
||||
taskStart.properties.name_label = vm.name_label
|
||||
}
|
||||
|
||||
const { task } = getVmTask()
|
||||
const task = getVmTask()
|
||||
// error has to be caught in the task to prevent its failure, but handled outside the task to execute another task.run()
|
||||
let taskError
|
||||
return task
|
||||
@@ -179,19 +174,12 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
|
||||
task.success(result)
|
||||
} else {
|
||||
// ending the task with error or not ending the task
|
||||
return vmBackupFailed(taskError, task)
|
||||
vmBackupFailed(taskError, task)
|
||||
}
|
||||
})
|
||||
.catch(noop) // errors are handled by logs
|
||||
}),
|
||||
error => {
|
||||
const { task: vmTask, started } = getVmTask()
|
||||
if (!started) {
|
||||
// the task is not started (except if it's a retry), and an unstarted task can't be failed
|
||||
vmTask.start()
|
||||
}
|
||||
return vmBackupFailed(error, vmTask)
|
||||
}
|
||||
error => vmBackupFailed(error, getVmTask())
|
||||
)
|
||||
}
|
||||
const { concurrency } = settings
|
||||
|
||||
@@ -1,13 +1,10 @@
|
||||
import { asyncMap } from '@xen-orchestra/async-map'
|
||||
import { createLogger } from '@xen-orchestra/log'
|
||||
import { Task } from '@vates/task'
|
||||
|
||||
import { DIR_XO_POOL_METADATA_BACKUPS } from '../RemoteAdapter.mjs'
|
||||
import { forkStreamUnpipe } from './_forkStreamUnpipe.mjs'
|
||||
import { formatFilenameDate } from '../_filenameDate.mjs'
|
||||
|
||||
const { debug } = createLogger('xo:backups:PoolMetadataBackup')
|
||||
|
||||
export const PATH_DB_DUMP = '/pool/xmldbdump'
|
||||
|
||||
export class PoolMetadataBackup {
|
||||
@@ -34,22 +31,7 @@ export class PoolMetadataBackup {
|
||||
const poolDir = `${DIR_XO_POOL_METADATA_BACKUPS}/${schedule.id}/${pool.$id}`
|
||||
const dir = `${poolDir}/${formatFilenameDate(timestamp)}`
|
||||
|
||||
const tasks = Object.values(pool.$xapi.objects.indexes.type.task ?? {})
|
||||
const pendingTasks = tasks.filter(task => task.status === 'pending')
|
||||
debug('pool tasks before export', {
|
||||
total: tasks.length,
|
||||
pending: pendingTasks.length,
|
||||
oldestPendingCreated: pendingTasks.map(task => task.created).sort()[0],
|
||||
})
|
||||
|
||||
const stream = (await this._exportPoolMetadata()).body
|
||||
const startedAt = Date.now()
|
||||
let bytes = 0
|
||||
stream.once('data', () => debug('first byte received', { afterMs: Date.now() - startedAt }))
|
||||
stream.on('data', chunk => (bytes += chunk.length))
|
||||
stream.once('end', () => debug('stream ended', { bytes, durationMs: Date.now() - startedAt }))
|
||||
stream.once('error', error => debug('stream errored', { error, bytes, durationMs: Date.now() - startedAt }))
|
||||
|
||||
const fileName = `${dir}/data`
|
||||
|
||||
const metadata = JSON.stringify(
|
||||
|
||||
@@ -10,9 +10,6 @@ export default function createStreamThrottle(rate) {
|
||||
}
|
||||
const group = new ThrottleGroup({ rate })
|
||||
return function throttleStream(stream) {
|
||||
const throttled = pipeline(stream, group.createThrottle(), noop)
|
||||
throttled.length = stream.length
|
||||
throttled.maxStreamLength = stream.maxStreamLength
|
||||
return throttled
|
||||
return pipeline(stream, group.createThrottle(), noop)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,58 +0,0 @@
|
||||
import assert from 'node:assert/strict'
|
||||
import { describe, it } from 'node:test'
|
||||
import { Readable } from 'node:stream'
|
||||
|
||||
import createStreamThrottle from './_createStreamThrottle.mjs'
|
||||
|
||||
const makeStream = (chunks, props = {}) => {
|
||||
const stream = Readable.from(chunks)
|
||||
Object.assign(stream, props)
|
||||
return stream
|
||||
}
|
||||
|
||||
const readAll = async stream => {
|
||||
const chunks = []
|
||||
for await (const chunk of stream) {
|
||||
chunks.push(chunk)
|
||||
}
|
||||
return Buffer.concat(chunks.map(c => (typeof c === 'string' ? Buffer.from(c) : c))).toString()
|
||||
}
|
||||
|
||||
describe('createStreamThrottle', () => {
|
||||
it('rate=0 returns identity, stream data and props intact', async () => {
|
||||
const throttleStream = createStreamThrottle(0)
|
||||
const stream = makeStream(['hello world'], { length: 11, maxStreamLength: 20 })
|
||||
const throttled = throttleStream(stream)
|
||||
assert.strictEqual(throttled, stream)
|
||||
assert.strictEqual(throttled.length, 11)
|
||||
assert.strictEqual(throttled.maxStreamLength, 20)
|
||||
assert.strictEqual(await readAll(throttled), 'hello world')
|
||||
})
|
||||
|
||||
it('rate>0 passes data through and preserves length and maxStreamLength', async () => {
|
||||
const throttleStream = createStreamThrottle(1024 * 1024)
|
||||
const stream = makeStream(['hello world'], { length: 11, maxStreamLength: 20 })
|
||||
const throttled = throttleStream(stream)
|
||||
assert.strictEqual(throttled.length, 11)
|
||||
assert.strictEqual(throttled.maxStreamLength, 20)
|
||||
assert.strictEqual(await readAll(throttled), 'hello world')
|
||||
})
|
||||
|
||||
it('rate>0 handles undefined length and maxStreamLength', async () => {
|
||||
const throttleStream = createStreamThrottle(1024 * 1024)
|
||||
const stream = makeStream(['hello world'])
|
||||
const throttled = throttleStream(stream)
|
||||
assert.strictEqual(throttled.length, undefined)
|
||||
assert.strictEqual(throttled.maxStreamLength, undefined)
|
||||
assert.strictEqual(await readAll(throttled), 'hello world')
|
||||
})
|
||||
|
||||
// regression: maxStreamLength was lost after throttling, causing S3 to ignore it and cap at 50GB
|
||||
it('rate>0 preserves maxStreamLength so S3 can compute correct partSize', async () => {
|
||||
const throttleStream = createStreamThrottle(1024 * 1024)
|
||||
const stream = makeStream(['hello world'], { maxStreamLength: 11 })
|
||||
const throttled = throttleStream(stream)
|
||||
assert.strictEqual(throttled.maxStreamLength, 11)
|
||||
assert.strictEqual(await readAll(throttled), 'hello world')
|
||||
})
|
||||
})
|
||||
@@ -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
|
||||
|
||||
@@ -73,10 +73,6 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
|
||||
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,
|
||||
vm,
|
||||
@@ -84,6 +80,15 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
|
||||
}),
|
||||
'writer.transfer()'
|
||||
)
|
||||
await this._callWriters(
|
||||
writer =>
|
||||
writer.updateUuidAndChain({
|
||||
isVhdDifferencing,
|
||||
timestamp,
|
||||
vdis: deltaExport.vdis,
|
||||
}),
|
||||
'writer.updateUuidAndChain()'
|
||||
)
|
||||
|
||||
if (isFull) {
|
||||
await setVmDeltaChainLength(this._xapi, exportedVm.$ref, 0)
|
||||
|
||||
@@ -213,35 +213,6 @@ export const AbstractXapi = class AbstractXapiVmBackupRunner extends Abstract {
|
||||
vmUuid: vm.uuid,
|
||||
})
|
||||
await setVmSnapshotContentKeys(xapi, snapshotRef)
|
||||
|
||||
// Verify that setVmOtherConfig actually tagged every disk we expected.
|
||||
// If the snapshot exposes fewer 'Disk' VBDs than the live VM has, the
|
||||
// tagging call silently skipped some VDIs and the resulting snapshot
|
||||
// will be invisible to retention/cleanup on the next run.
|
||||
const liveDisks = await xapi.VM_getDisks(vm.$ref)
|
||||
const snapshotDisks = await xapi.VM_getDisks(snapshotRef)
|
||||
if (liveDisks.length !== snapshotDisks.length) {
|
||||
const snapshotVbdRefs = await xapi.getField('VM', snapshotRef, 'VBDs')
|
||||
const snapshotVbds = await xapi.getRecords('VBD', snapshotVbdRefs)
|
||||
warn('inconsistent snapshot tagging detected', {
|
||||
vmUuid: vm.uuid,
|
||||
vmName: vm.name_label,
|
||||
snapshotRef,
|
||||
jobId: this._jobId,
|
||||
timestamp: this.timestamp,
|
||||
expectedDiskCount: liveDisks.length,
|
||||
actualDiskCount: snapshotDisks.length,
|
||||
liveDisks,
|
||||
snapshotDisks,
|
||||
snapshotVbds: snapshotVbds.map(vbd => ({
|
||||
uuid: vbd.uuid,
|
||||
type: vbd.type,
|
||||
VDI: vbd.VDI,
|
||||
currently_attached: vbd.currently_attached,
|
||||
})),
|
||||
})
|
||||
}
|
||||
|
||||
const snapshot = await xapi.getRecord('VM', snapshotRef)
|
||||
await snapshot.set_name_label(this._getSnapshotNameLabel(vm))
|
||||
// reload data to ensure it is up to date with the new name label
|
||||
|
||||
@@ -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,54 @@ 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)
|
||||
}
|
||||
|
||||
// UUID chaining is only needed for differencing VHDs.
|
||||
// Raw disk already have their UUID set at creation time.
|
||||
if (path.endsWith('raw')) {
|
||||
return
|
||||
}
|
||||
|
||||
// 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 +184,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 +192,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 +204,8 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
|
||||
// don't do delta for it
|
||||
vdi.uuid
|
||||
: vdi.$snapshot_of$uuid
|
||||
}/${adapter.getVhdFileName(filenameDate)}`
|
||||
)
|
||||
}/${adapter.getDiskFileName(basename)}`
|
||||
))
|
||||
|
||||
let metadataContent = await this._isAlreadyTransferred(timestamp)
|
||||
if (metadataContent !== undefined) {
|
||||
@@ -236,11 +215,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 +235,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
|
||||
@@ -313,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({
|
||||
@@ -418,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.73.10",
|
||||
"version": "0.73.2",
|
||||
"engines": {
|
||||
"node": ">=14.18"
|
||||
},
|
||||
@@ -25,19 +25,19 @@
|
||||
"@vates/compose": "^2.1.0",
|
||||
"@vates/decorate-with": "^2.1.0",
|
||||
"@vates/disposable": "^0.1.6",
|
||||
"@vates/fuse-vhd": "^2.1.3",
|
||||
"@vates/generator-toolbox": "^1.1.3",
|
||||
"@vates/nbd-client": "^3.5.0",
|
||||
"@vates/fuse-vhd": "^2.1.2",
|
||||
"@vates/generator-toolbox": "^1.1.2",
|
||||
"@vates/nbd-client": "^3.4.0",
|
||||
"@vates/parse-duration": "^0.1.1",
|
||||
"@vates/task": "^0.7.0",
|
||||
"@vates/types": "^1.30.1",
|
||||
"@vates/types": "^1.26.0",
|
||||
"@xen-orchestra/async-map": "^0.1.3",
|
||||
"@xen-orchestra/disk-transform": "^1.3.3",
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/disk-transform": "^1.3.0",
|
||||
"@xen-orchestra/fs": "^4.9.0",
|
||||
"@xen-orchestra/log": "^0.7.2",
|
||||
"@xen-orchestra/qcow2": "^1.3.1",
|
||||
"@xen-orchestra/qcow2": "^1.3.0",
|
||||
"@xen-orchestra/template": "^0.1.1",
|
||||
"@xen-orchestra/backup-archive": "^1.1.1",
|
||||
"@xen-orchestra/backup-archive": "^1.0.1",
|
||||
"app-conf": "^3.0.0",
|
||||
"compare-versions": "^6.0.0",
|
||||
"d3-time-format": "^4.1.0",
|
||||
@@ -55,8 +55,8 @@
|
||||
"tar": "^7.5.3",
|
||||
"uuid": "^9.0.0",
|
||||
"value-matcher": "^0.2.0",
|
||||
"vhd-lib": "^4.16.1",
|
||||
"xen-api": "^4.8.0",
|
||||
"vhd-lib": "^4.16.0",
|
||||
"xen-api": "^4.7.7",
|
||||
"yazl": "^2.5.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
@@ -67,7 +67,7 @@
|
||||
"typescript": "^5.9.3"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@xen-orchestra/xapi": "^8.10.2"
|
||||
"@xen-orchestra/xapi": "^8.8.0"
|
||||
},
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"author": {
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
"preferGlobal": true,
|
||||
"dependencies": {
|
||||
"golike-defer": "^0.5.1",
|
||||
"xen-api": "^4.8.0"
|
||||
"xen-api": "^4.7.7"
|
||||
},
|
||||
"scripts": {
|
||||
"postversion": "npm publish"
|
||||
|
||||
@@ -3,8 +3,8 @@ $ xo-disk-cli --help
|
||||
Usage: xo-disk-cli <command> <handler-url> <path> [options]
|
||||
|
||||
Commands:
|
||||
info Show disk info (virtual size, uid, parent uid, block size); --chain shows the full parent chain, --size adds the size on disk
|
||||
list List all disks at a path and display their properties in a table; --size adds the size on disk
|
||||
info Show disk info (virtual size, uid, parent uid, block size)
|
||||
list List all disks at a path and display their properties in a table
|
||||
transform Convert a disk to another format and write to stdout (raw | vhd | qcow2)
|
||||
```
|
||||
|
||||
@@ -15,7 +15,7 @@ Commands:
|
||||
Display metadata for a single disk file.
|
||||
|
||||
```
|
||||
xo-disk-cli info <handler-url> <disk-path> [--chain] [--size]
|
||||
xo-disk-cli info <handler-url> <disk-path>
|
||||
```
|
||||
|
||||
Output includes: UID, parent UID (for differencing disks), virtual size, and block size.
|
||||
@@ -29,66 +29,16 @@ Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
```
|
||||
|
||||
By default the disk is opened without reading its block allocation table, which
|
||||
is cheap but does not allow computing the size on disk. Pass `--size` to read
|
||||
the block allocation table and print the size on disk as an extra line:
|
||||
|
||||
```
|
||||
$ xo-disk-cli info file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd --size
|
||||
Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd
|
||||
UID: <uuid>
|
||||
Parent UID: <parent-uuid>
|
||||
Virtual size: 8.00 GiB (8589934592 bytes)
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
Size on disk: 128.00 MiB (134217728 bytes)
|
||||
```
|
||||
|
||||
With `--chain`, the disk's full parent chain is opened and each disk is printed
|
||||
from the root (base) disk down to the given leaf disk. `--chain` and `--size`
|
||||
can be combined:
|
||||
|
||||
```
|
||||
$ xo-disk-cli info file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd --chain
|
||||
Disk chain: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd (2 disks, root → leaf)
|
||||
|
||||
Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/base.vhd
|
||||
UID: <base-uuid>
|
||||
Parent UID: (none)
|
||||
Virtual size: 8.00 GiB (8589934592 bytes)
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
|
||||
Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd
|
||||
UID: <uuid>
|
||||
Parent UID: <base-uuid>
|
||||
Virtual size: 8.00 GiB (8589934592 bytes)
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
```
|
||||
|
||||
### `list`
|
||||
|
||||
List all disk files found at a directory path and display their properties in a table. Disks are sorted so that each child appears directly after its parent. When a disk's parent is the row immediately above, the parent UID column shows `↑` for quick chain health assessment.
|
||||
|
||||
```
|
||||
xo-disk-cli list <handler-url> <dir-path> [--size]
|
||||
xo-disk-cli list <handler-url> <dir-path>
|
||||
```
|
||||
|
||||
By default disks are opened without reading their block allocation table (cheap),
|
||||
so the "Size on disk" column is omitted:
|
||||
|
||||
```
|
||||
$ xo-disk-cli list file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/
|
||||
┌──────────────┬──────────────────────────────────────┬──────────────┬─────────────┬──────────────────────────────────────┐
|
||||
│ File │ UID │ Virtual size │ Differencing │ Parent UID │
|
||||
├──────────────┼──────────────────────────────────────┼──────────────┼─────────────┼──────────────────────────────────────┤
|
||||
│ base.vhd │ xxxxxxxx-... │ 8.00 GiB │ no │ (none) │
|
||||
│ snapshot.vhd │ yyyyyyyy-... │ 8.00 GiB │ yes │ ↑ │
|
||||
└──────────────┴──────────────────────────────────────┴──────────────┴─────────────┴──────────────────────────────────────┘
|
||||
```
|
||||
|
||||
Pass `--size` to read each disk's block allocation table and add the "Size on disk" column:
|
||||
|
||||
```
|
||||
$ xo-disk-cli list file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/ --size
|
||||
┌──────────────┬──────────────────────────────────────┬─────────────┬──────────────┬─────────────┬──────────────────────────────────────┐
|
||||
│ File │ UID │ Size on disk│ Virtual size │ Differencing │ Parent UID │
|
||||
├──────────────┼──────────────────────────────────────┼─────────────┼──────────────┼─────────────┼──────────────────────────────────────┤
|
||||
|
||||
@@ -21,8 +21,8 @@ $ xo-disk-cli --help
|
||||
Usage: xo-disk-cli <command> <handler-url> <path> [options]
|
||||
|
||||
Commands:
|
||||
info Show disk info (virtual size, uid, parent uid, block size); --chain shows the full parent chain, --size adds the size on disk
|
||||
list List all disks at a path and display their properties in a table; --size adds the size on disk
|
||||
info Show disk info (virtual size, uid, parent uid, block size)
|
||||
list List all disks at a path and display their properties in a table
|
||||
transform Convert a disk to another format and write to stdout (raw | vhd | qcow2)
|
||||
```
|
||||
|
||||
@@ -33,7 +33,7 @@ Commands:
|
||||
Display metadata for a single disk file.
|
||||
|
||||
```
|
||||
xo-disk-cli info <handler-url> <disk-path> [--chain] [--size]
|
||||
xo-disk-cli info <handler-url> <disk-path>
|
||||
```
|
||||
|
||||
Output includes: UID, parent UID (for differencing disks), virtual size, and block size.
|
||||
@@ -47,66 +47,16 @@ Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
```
|
||||
|
||||
By default the disk is opened without reading its block allocation table, which
|
||||
is cheap but does not allow computing the size on disk. Pass `--size` to read
|
||||
the block allocation table and print the size on disk as an extra line:
|
||||
|
||||
```
|
||||
$ xo-disk-cli info file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd --size
|
||||
Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd
|
||||
UID: <uuid>
|
||||
Parent UID: <parent-uuid>
|
||||
Virtual size: 8.00 GiB (8589934592 bytes)
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
Size on disk: 128.00 MiB (134217728 bytes)
|
||||
```
|
||||
|
||||
With `--chain`, the disk's full parent chain is opened and each disk is printed
|
||||
from the root (base) disk down to the given leaf disk. `--chain` and `--size`
|
||||
can be combined:
|
||||
|
||||
```
|
||||
$ xo-disk-cli info file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd --chain
|
||||
Disk chain: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd (2 disks, root → leaf)
|
||||
|
||||
Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/base.vhd
|
||||
UID: <base-uuid>
|
||||
Parent UID: (none)
|
||||
Virtual size: 8.00 GiB (8589934592 bytes)
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
|
||||
Disk info: /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/snapshot.vhd
|
||||
UID: <uuid>
|
||||
Parent UID: <base-uuid>
|
||||
Virtual size: 8.00 GiB (8589934592 bytes)
|
||||
Block size: 2.00 MiB (2097152 bytes)
|
||||
```
|
||||
|
||||
### `list`
|
||||
|
||||
List all disk files found at a directory path and display their properties in a table. Disks are sorted so that each child appears directly after its parent. When a disk's parent is the row immediately above, the parent UID column shows `↑` for quick chain health assessment.
|
||||
|
||||
```
|
||||
xo-disk-cli list <handler-url> <dir-path> [--size]
|
||||
xo-disk-cli list <handler-url> <dir-path>
|
||||
```
|
||||
|
||||
By default disks are opened without reading their block allocation table (cheap),
|
||||
so the "Size on disk" column is omitted:
|
||||
|
||||
```
|
||||
$ xo-disk-cli list file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/
|
||||
┌──────────────┬──────────────────────────────────────┬──────────────┬─────────────┬──────────────────────────────────────┐
|
||||
│ File │ UID │ Virtual size │ Differencing │ Parent UID │
|
||||
├──────────────┼──────────────────────────────────────┼──────────────┼─────────────┼──────────────────────────────────────┤
|
||||
│ base.vhd │ xxxxxxxx-... │ 8.00 GiB │ no │ (none) │
|
||||
│ snapshot.vhd │ yyyyyyyy-... │ 8.00 GiB │ yes │ ↑ │
|
||||
└──────────────┴──────────────────────────────────────┴──────────────┴─────────────┴──────────────────────────────────────┘
|
||||
```
|
||||
|
||||
Pass `--size` to read each disk's block allocation table and add the "Size on disk" column:
|
||||
|
||||
```
|
||||
$ xo-disk-cli list file:///mnt/backups /xo-vm-backups/<vm-uuid>/vdis/<vdi-uuid>/ --size
|
||||
┌──────────────┬──────────────────────────────────────┬─────────────┬──────────────┬─────────────┬──────────────────────────────────────┐
|
||||
│ File │ UID │ Size on disk│ Virtual size │ Differencing │ Parent UID │
|
||||
├──────────────┼──────────────────────────────────────┼─────────────┼──────────────┼─────────────┼──────────────────────────────────────┤
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"private": false,
|
||||
"name": "@xen-orchestra/disk-cli",
|
||||
"version": "2.2.0",
|
||||
"version": "2.1.1",
|
||||
"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.73.10",
|
||||
"@xen-orchestra/backup-archive": "^1.1.1",
|
||||
"@xen-orchestra/disk-transform": "^1.3.3",
|
||||
"@xen-orchestra/fs": "^4.9.3",
|
||||
"@xen-orchestra/qcow2": "^1.3.1",
|
||||
"@xen-orchestra/backups": "^0.73.2",
|
||||
"@xen-orchestra/backup-archive": "^1.0.1",
|
||||
"@xen-orchestra/disk-transform": "^1.3.0",
|
||||
"@xen-orchestra/fs": "^4.9.0",
|
||||
"@xen-orchestra/qcow2": "^1.3.0",
|
||||
"promise-toolbox": "^0.21.0",
|
||||
"vhd-lib": "^4.16.1"
|
||||
"vhd-lib": "^4.16.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.3.0",
|
||||
|
||||
@@ -1,84 +1,22 @@
|
||||
import Disposable from 'promise-toolbox/Disposable'
|
||||
import { getSyncedHandler, type RemoteHandler } from '@xen-orchestra/fs'
|
||||
import { openDisposableDisk, openDiskChain, RemoteDisk, DiskDisposable } from '@xen-orchestra/backup-archive/disks'
|
||||
import { getSyncedHandler } from '@xen-orchestra/fs'
|
||||
import { openDisposableDisk, RemoteDisk } from '@xen-orchestra/backup-archive/disks'
|
||||
import { formatBytes } from '../utils.mjs'
|
||||
|
||||
type DiskInfoLine = {
|
||||
path: string
|
||||
uid: string
|
||||
parentUid: string | null
|
||||
virtualSize: number
|
||||
blockSize: number
|
||||
// Only computed with --size; requires reading the block allocation table.
|
||||
sizeOnDisk?: number
|
||||
}
|
||||
|
||||
function readDiskInfo(disk: RemoteDisk, path: string, showSize: boolean): DiskInfoLine {
|
||||
const isDifferencing = disk.isDifferencing()
|
||||
return {
|
||||
path,
|
||||
uid: disk.getUuid(),
|
||||
parentUid: isDifferencing ? disk.getParentUuid() : null,
|
||||
virtualSize: disk.getVirtualSize(),
|
||||
blockSize: disk.getBlockSize(),
|
||||
sizeOnDisk: showSize ? disk.getSizeOnDisk() : undefined,
|
||||
}
|
||||
}
|
||||
|
||||
function printDiskInfo(info: DiskInfoLine): void {
|
||||
console.log(`Disk info: ${info.path}`)
|
||||
console.log(` UID: ${info.uid}`)
|
||||
console.log(` Parent UID: ${info.parentUid ?? '(none)'}`)
|
||||
console.log(` Virtual size: ${formatBytes(info.virtualSize)} (${info.virtualSize} bytes)`)
|
||||
console.log(` Block size: ${formatBytes(info.blockSize)} (${info.blockSize} bytes)`)
|
||||
if (info.sizeOnDisk !== undefined) {
|
||||
console.log(` Size on disk: ${formatBytes(info.sizeOnDisk)} (${info.sizeOnDisk} bytes)`)
|
||||
}
|
||||
}
|
||||
|
||||
// Opens the full chain (root → leaf) as a disposable, reusing the same chain
|
||||
// walker as the `transform` command.
|
||||
async function openDisposableChain(
|
||||
handler: RemoteHandler,
|
||||
path: string,
|
||||
ignoreBlockIndexes: boolean
|
||||
): Promise<DiskDisposable> {
|
||||
const chain = await openDiskChain({ handler, path, ignoreBlockIndexes })
|
||||
return { value: chain, dispose: () => chain.close() }
|
||||
}
|
||||
|
||||
export async function infoCommand(handlerUrl: string, diskPath: string, extraArgs: string[]): Promise<void> {
|
||||
const showChain = extraArgs.includes('--chain')
|
||||
const showSize = extraArgs.includes('--size')
|
||||
// Reading the block allocation table is costly, so only do it when the size on
|
||||
// disk is requested; every other field comes from the footer/header.
|
||||
const ignoreBlockIndexes = !showSize
|
||||
|
||||
export async function infoCommand(handlerUrl: string, diskPath: string, _extraArgs: string[]): Promise<void> {
|
||||
await Disposable.use(getSyncedHandler({ url: handlerUrl }), async handler => {
|
||||
if (!showChain) {
|
||||
const info = await Disposable.use(
|
||||
openDisposableDisk({ handler, path: diskPath, ignoreBlockIndexes }),
|
||||
(disk: RemoteDisk) => readDiskInfo(disk, diskPath, showSize)
|
||||
)
|
||||
printDiskInfo(info)
|
||||
return
|
||||
}
|
||||
await Disposable.use(openDisposableDisk({ handler, path: diskPath }), async (disk: RemoteDisk) => {
|
||||
const isDifferencing = disk.isDifferencing()
|
||||
const virtualSize = disk.getVirtualSize()
|
||||
const blockSize = disk.getBlockSize()
|
||||
const uid = disk.getUuid()
|
||||
const parentUid = isDifferencing ? disk.getParentUuid() : null
|
||||
|
||||
// Resolve the full lineage (root → leaf), then print each disk's info.
|
||||
const paths = await Disposable.use(openDisposableChain(handler, diskPath, ignoreBlockIndexes), chain =>
|
||||
chain.getPaths()
|
||||
)
|
||||
|
||||
console.log(`Disk chain: ${diskPath} (${paths.length} disk${paths.length === 1 ? '' : 's'}, root → leaf)\n`)
|
||||
|
||||
for (const [index, path] of paths.entries()) {
|
||||
const info = await Disposable.use(openDisposableDisk({ handler, path, ignoreBlockIndexes }), (disk: RemoteDisk) =>
|
||||
readDiskInfo(disk, path, showSize)
|
||||
)
|
||||
printDiskInfo(info)
|
||||
if (index < paths.length - 1) {
|
||||
console.log()
|
||||
}
|
||||
}
|
||||
console.log(`Disk info: ${diskPath}`)
|
||||
console.log(` UID: ${uid}`)
|
||||
console.log(` Parent UID: ${parentUid ?? '(none)'}`)
|
||||
console.log(` Virtual size: ${formatBytes(virtualSize)} (${virtualSize} bytes)`)
|
||||
console.log(` Block size: ${formatBytes(blockSize)} (${blockSize} bytes)`)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
@@ -3,18 +3,13 @@ import { getSyncedHandler } from '@xen-orchestra/fs'
|
||||
import { isDisk, openDisposableDisk, RemoteDisk } from '@xen-orchestra/backup-archive/disks'
|
||||
import { formatBytes, renderTable } from '../utils.mjs'
|
||||
import { asyncEach } from '@vates/async-each'
|
||||
|
||||
// The "Size on disk" column is only shown with --size: computing it requires
|
||||
// reading the block allocation table of every disk, which is costly.
|
||||
function buildHeaders(showSize: boolean): string[] {
|
||||
return ['File', 'UID', ...(showSize ? ['Size on disk'] : []), 'Virtual size', 'Differencing', 'Parent UID']
|
||||
}
|
||||
const HEADERS = ['File', 'UID', 'Size on disk', 'Virtual size', 'Differencing', 'Parent UID']
|
||||
|
||||
export type OkDiskInfo = {
|
||||
ok: true
|
||||
filename: string
|
||||
uid: string
|
||||
sizeOnDisk?: string
|
||||
sizeOnDisk: string
|
||||
virtualSize: string
|
||||
differencing: boolean
|
||||
parentUid: string | null
|
||||
@@ -59,10 +54,9 @@ export function sortDisks(disks: DiskInfo[]): DiskInfo[] {
|
||||
return [...sorted, ...errDisks]
|
||||
}
|
||||
|
||||
export function toTableRow(disk: DiskInfo, prevDisk: DiskInfo | undefined, showSize: boolean): string[] {
|
||||
export function toTableRow(disk: DiskInfo, prevDisk: DiskInfo | undefined): string[] {
|
||||
if (!disk.ok) {
|
||||
// filename + error message, then a placeholder for every remaining column.
|
||||
return [disk.filename, `(error: ${disk.error})`, ...Array(showSize ? 4 : 3).fill('-')]
|
||||
return [disk.filename, `(error: ${disk.error})`, '-', '-', '-', '-']
|
||||
}
|
||||
|
||||
const parentIsAbove = disk.differencing && prevDisk?.ok && prevDisk.uid === disk.parentUid
|
||||
@@ -70,19 +64,17 @@ export function toTableRow(disk: DiskInfo, prevDisk: DiskInfo | undefined, showS
|
||||
return [
|
||||
disk.filename,
|
||||
disk.uid,
|
||||
...(showSize ? [disk.sizeOnDisk ?? '-'] : []),
|
||||
disk.sizeOnDisk,
|
||||
disk.virtualSize,
|
||||
disk.differencing ? 'yes' : 'no',
|
||||
disk.differencing ? (parentIsAbove ? '↑' : (disk.parentUid ?? '')) : '(none)',
|
||||
]
|
||||
}
|
||||
|
||||
export async function listCommand(handlerUrl: string, dirPath: string, extraArgs: string[]): Promise<void> {
|
||||
const showSize = extraArgs.includes('--size')
|
||||
|
||||
export async function listCommand(handlerUrl: string, dirPath: string, _extraArgs: string[]): Promise<void> {
|
||||
await Disposable.use(getSyncedHandler({ url: handlerUrl }), async handler => {
|
||||
const entries = await handler.list(dirPath, { prependDir: true })
|
||||
const diskPaths = entries.filter(entry => isDisk(entry))
|
||||
const diskPaths = entries.filter(entry => isDisk(handler, entry))
|
||||
|
||||
if (diskPaths.length === 0) {
|
||||
console.log(`No disks found at ${dirPath}`)
|
||||
@@ -96,14 +88,14 @@ export async function listCommand(handlerUrl: string, dirPath: string, extraArgs
|
||||
const filename = diskPath.slice(diskPath.lastIndexOf('/') + 1)
|
||||
try {
|
||||
const disk = await Disposable.use(
|
||||
openDisposableDisk({ handler, path: diskPath, ignoreBlockIndexes: !showSize }),
|
||||
openDisposableDisk({ handler, path: diskPath }),
|
||||
async (disk: RemoteDisk) => {
|
||||
const differencing = disk.isDifferencing()
|
||||
return {
|
||||
ok: true as const,
|
||||
filename,
|
||||
uid: disk.getUuid(),
|
||||
sizeOnDisk: showSize ? formatBytes(disk.getSizeOnDisk()) : undefined,
|
||||
sizeOnDisk: formatBytes(disk.getSizeOnDisk()),
|
||||
virtualSize: formatBytes(disk.getVirtualSize()),
|
||||
differencing,
|
||||
parentUid: differencing ? disk.getParentUuid() : null,
|
||||
@@ -119,7 +111,7 @@ export async function listCommand(handlerUrl: string, dirPath: string, extraArgs
|
||||
)
|
||||
|
||||
const sorted = sortDisks(disks)
|
||||
const rows = sorted.map((disk, i) => toTableRow(disk, sorted[i - 1], showSize))
|
||||
console.log(renderTable(buildHeaders(showSize), rows))
|
||||
const rows = sorted.map((disk, i) => toTableRow(disk, sorted[i - 1]))
|
||||
console.log(renderTable(HEADERS, rows))
|
||||
})
|
||||
}
|
||||
|
||||
16
@xen-orchestra/disk-cli/src/declarations.d.ts
vendored
16
@xen-orchestra/disk-cli/src/declarations.d.ts
vendored
@@ -42,7 +42,6 @@ declare module '@xen-orchestra/backup-archive/disks/openDiskChain.mjs' {
|
||||
handler: RemoteHandler
|
||||
path: string
|
||||
until?: string
|
||||
ignoreBlockIndexes?: boolean
|
||||
}): Promise<RandomAccessDisk>
|
||||
}
|
||||
|
||||
@@ -53,10 +52,8 @@ declare module '@xen-orchestra/backup-archive/disks' {
|
||||
export interface RemoteDisk extends RandomAccessDisk {
|
||||
getSizeOnDisk(): number
|
||||
getPath(): string
|
||||
getPaths(): string[]
|
||||
getUuid(): string
|
||||
getParentUuid(): string
|
||||
getParentPath(): string
|
||||
getMaxBlockCount(): number
|
||||
}
|
||||
|
||||
@@ -65,20 +62,13 @@ declare module '@xen-orchestra/backup-archive/disks' {
|
||||
dispose: () => Promise<void>
|
||||
}
|
||||
|
||||
export function isDisk(path: string): boolean
|
||||
export function isDisk(handler: RemoteHandler, path: string): boolean
|
||||
|
||||
export function openDisposableDisk(params: {
|
||||
handler: RemoteHandler
|
||||
path: string
|
||||
force?: boolean
|
||||
ignoreBlockIndexes?: boolean
|
||||
}): Promise<DiskDisposable>
|
||||
export function openDisposableDisk(params: { handler: RemoteHandler; path: string }): Promise<DiskDisposable>
|
||||
|
||||
// Returns a RemoteVhdDiskChain, which is a RemoteDisk exposing getPaths() over the whole lineage.
|
||||
export function openDiskChain(params: {
|
||||
handler: RemoteHandler
|
||||
path: string
|
||||
until?: string
|
||||
ignoreBlockIndexes?: boolean
|
||||
}): Promise<RemoteDisk>
|
||||
}): Promise<RandomAccessDisk>
|
||||
}
|
||||
|
||||
@@ -14,8 +14,8 @@ const COMMANDS: Record<string, CommandFn> = {
|
||||
|
||||
function showHelp(exitCode: number): never {
|
||||
const commandDescriptions: Record<string, string> = {
|
||||
info: 'Show disk info (virtual size, uid, parent uid, block size); --chain shows the full parent chain, --size adds the size on disk',
|
||||
list: 'List all disks at a path and display their properties in a table; --size adds the size on disk',
|
||||
info: 'Show disk info (virtual size, uid, parent uid, block size)',
|
||||
list: 'List all disks at a path and display their properties in a table',
|
||||
transform: 'Convert a disk to another format and write to stdout (raw | vhd | qcow2)',
|
||||
}
|
||||
|
||||
@@ -30,9 +30,7 @@ ${commandList}
|
||||
|
||||
Examples:
|
||||
xo-disk-cli info file:///mnt/backups /xo-vm-backups/uuid/disk.alias.vhd
|
||||
xo-disk-cli info file:///mnt/backups /xo-vm-backups/uuid/disk.alias.vhd --chain --size
|
||||
xo-disk-cli list file:///mnt/backups /xo-vm-backups/uuid/
|
||||
xo-disk-cli list file:///mnt/backups /xo-vm-backups/uuid/ --size
|
||||
xo-disk-cli transform file:///mnt/backups /xo-vm-backups/uuid/disk.vhd raw > disk.img
|
||||
xo-disk-cli transform file:///mnt/backups /xo-vm-backups/uuid/disk.vhd qcow2 > disk.qcow2
|
||||
`)
|
||||
|
||||
@@ -4,30 +4,25 @@
|
||||
* Focus:
|
||||
* - Handler and disk are always disposed, even when disk methods throw.
|
||||
* - Errors from broken disks are propagated (not swallowed).
|
||||
* - By default disks are opened with ignoreBlockIndexes: true (cheap); --size
|
||||
* opens with ignoreBlockIndexes: false and prints the size on disk.
|
||||
* - --chain opens the whole lineage and prints each disk.
|
||||
*
|
||||
* Design: mock.module() is called once at the top level. The mocks read mutable
|
||||
* closure variables at call-time so individual tests can inject scenarios simply
|
||||
* by reassigning a variable before calling the command.
|
||||
* Design: mock.module() is called once at the top level. The mock for openDisk
|
||||
* reads `currentDisk` at call-time via closure, so individual tests can inject
|
||||
* failure scenarios simply by reassigning the variable before calling the command.
|
||||
*/
|
||||
import { describe, test, mock, beforeEach } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Spies & mutable state — created once and reused; reset in beforeEach.
|
||||
// Spies — created once and reused; reset in beforeEach.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const handlerDispose = mock.fn(() => Promise.resolve())
|
||||
const diskDispose = mock.fn(() => Promise.resolve())
|
||||
const chainClose = mock.fn(() => Promise.resolve())
|
||||
|
||||
const baseDisk = {
|
||||
isDifferencing: () => false,
|
||||
getVirtualSize: () => 1024 * 1024 * 1024,
|
||||
getBlockSize: () => 2 * 1024 * 1024,
|
||||
getSizeOnDisk: () => 128 * 1024 * 1024,
|
||||
getUuid: () => 'aaaa-bbbb',
|
||||
getParentUuid: () => 'pppp-qqqq',
|
||||
}
|
||||
@@ -35,20 +30,9 @@ const baseDisk = {
|
||||
// Reassigned per-test to inject different disk behaviours.
|
||||
let currentDisk: typeof baseDisk = { ...baseDisk }
|
||||
|
||||
// Paths returned by the chain (root → leaf); reassigned per-test.
|
||||
let chainPaths: string[] = ['/vdis/root.vhd', '/vdis/leaf.vhd']
|
||||
|
||||
// Records the options each openDisposableDisk call received.
|
||||
const openDiskParams: Array<{ path: string; ignoreBlockIndexes?: boolean }> = []
|
||||
const openChainParams: Array<{ path: string; ignoreBlockIndexes?: boolean }> = []
|
||||
|
||||
const openDiskChainSpy = mock.fn((params: { path: string; ignoreBlockIndexes?: boolean }) => {
|
||||
openChainParams.push(params)
|
||||
return Promise.resolve({ getPaths: () => chainPaths, close: chainClose })
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Module mocks — registered once. Implementations read mutable state at call-time.
|
||||
// Module mocks — registered once. openDisk reads `currentDisk` at call-time
|
||||
// so tests only need to reassign the variable, not re-mock the module.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
mock.module('@xen-orchestra/fs', {
|
||||
@@ -59,31 +43,14 @@ mock.module('@xen-orchestra/fs', {
|
||||
|
||||
mock.module('@xen-orchestra/backup-archive/disks', {
|
||||
namedExports: {
|
||||
openDisposableDisk: (params: { path: string; ignoreBlockIndexes?: boolean }) => {
|
||||
openDiskParams.push(params)
|
||||
return Promise.resolve({ value: currentDisk, dispose: diskDispose })
|
||||
},
|
||||
openDiskChain: openDiskChainSpy,
|
||||
openDisposableDisk: () => Promise.resolve({ value: currentDisk, dispose: diskDispose }),
|
||||
},
|
||||
})
|
||||
|
||||
// Import the module under test AFTER mocks are registered so it receives the
|
||||
// mocked implementations.
|
||||
// mocked implementations. The same infoCommand reference is reused for all tests.
|
||||
const { infoCommand } = await import('../../commands/info.mjs')
|
||||
|
||||
// Capture console.log output without polluting test output.
|
||||
async function captureLog(fn: () => Promise<void>): Promise<string> {
|
||||
const lines: string[] = []
|
||||
const orig = console.log
|
||||
console.log = (...args: unknown[]) => lines.push(args.map(String).join(' '))
|
||||
try {
|
||||
await fn()
|
||||
} finally {
|
||||
console.log = orig
|
||||
}
|
||||
return lines.join('\n')
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -92,16 +59,11 @@ describe('info command', () => {
|
||||
beforeEach(() => {
|
||||
handlerDispose.mock.resetCalls()
|
||||
diskDispose.mock.resetCalls()
|
||||
chainClose.mock.resetCalls()
|
||||
openDiskChainSpy.mock.resetCalls()
|
||||
openDiskParams.length = 0
|
||||
openChainParams.length = 0
|
||||
currentDisk = { ...baseDisk }
|
||||
chainPaths = ['/vdis/root.vhd', '/vdis/leaf.vhd']
|
||||
})
|
||||
|
||||
test('disposes handler and disk on success', async () => {
|
||||
await captureLog(() => infoCommand('file:///test', '/vdis/disk.vhd', []))
|
||||
await infoCommand('file:///test', '/vdis/disk.vhd', [])
|
||||
assert.strictEqual(handlerDispose.mock.callCount(), 1, 'handler must be disposed once')
|
||||
assert.strictEqual(diskDispose.mock.callCount(), 1, 'disk must be disposed once')
|
||||
})
|
||||
@@ -127,63 +89,4 @@ describe('info command', () => {
|
||||
}
|
||||
await assert.rejects(() => infoCommand('file:///test', '/vdis/disk.vhd', []), /corrupt header/)
|
||||
})
|
||||
|
||||
test('by default opens the disk with ignoreBlockIndexes: true and hides size on disk', async () => {
|
||||
const output = await captureLog(() => infoCommand('file:///test', '/vdis/disk.vhd', []))
|
||||
assert.strictEqual(openDiskParams.length, 1)
|
||||
assert.strictEqual(openDiskParams[0].ignoreBlockIndexes, true, 'block indexes must be skipped by default')
|
||||
assert.ok(!output.includes('Size on disk'), 'size on disk must not be printed without --size')
|
||||
})
|
||||
|
||||
test('--size opens the disk with ignoreBlockIndexes: false and prints size on disk', async () => {
|
||||
const output = await captureLog(() => infoCommand('file:///test', '/vdis/disk.vhd', ['--size']))
|
||||
assert.strictEqual(openDiskParams[0].ignoreBlockIndexes, false, 'block indexes must be read with --size')
|
||||
assert.ok(output.includes('Size on disk'), 'size on disk must be printed with --size')
|
||||
})
|
||||
|
||||
test('without --chain, openDiskChain is never called', async () => {
|
||||
await captureLog(() => infoCommand('file:///test', '/vdis/disk.vhd', []))
|
||||
assert.strictEqual(openDiskChainSpy.mock.callCount(), 0, 'openDiskChain must not be called without --chain')
|
||||
})
|
||||
|
||||
test('--chain: opens the chain, opens each disk in it, and disposes everything', async () => {
|
||||
await captureLog(() => infoCommand('file:///test', '/vdis/leaf.vhd', ['--chain']))
|
||||
assert.strictEqual(openDiskChainSpy.mock.callCount(), 1, 'openDiskChain must be called once')
|
||||
assert.strictEqual(chainClose.mock.callCount(), 1, 'chain must be closed after enumerating paths')
|
||||
// One openDisposableDisk (and thus one dispose) per disk in the chain.
|
||||
assert.strictEqual(diskDispose.mock.callCount(), chainPaths.length, 'each chain disk must be opened and disposed')
|
||||
assert.strictEqual(handlerDispose.mock.callCount(), 1, 'handler must be disposed once')
|
||||
})
|
||||
|
||||
test('--chain defaults to ignoreBlockIndexes: true for both the chain and each disk', async () => {
|
||||
await captureLog(() => infoCommand('file:///test', '/vdis/leaf.vhd', ['--chain']))
|
||||
assert.strictEqual(openChainParams[0].ignoreBlockIndexes, true, 'chain walk must skip block indexes by default')
|
||||
assert.ok(
|
||||
openDiskParams.every(p => p.ignoreBlockIndexes === true),
|
||||
'each chain disk must be opened with ignoreBlockIndexes: true'
|
||||
)
|
||||
})
|
||||
|
||||
test('--chain --size reads block indexes and prints size on disk for each disk', async () => {
|
||||
const output = await captureLog(() => infoCommand('file:///test', '/vdis/leaf.vhd', ['--chain', '--size']))
|
||||
assert.strictEqual(openChainParams[0].ignoreBlockIndexes, false, 'chain walk must read block indexes with --size')
|
||||
assert.ok(
|
||||
openDiskParams.every(p => p.ignoreBlockIndexes === false),
|
||||
'each chain disk must be opened with ignoreBlockIndexes: false'
|
||||
)
|
||||
const sizeLines = output.split('\n').filter(l => l.includes('Size on disk'))
|
||||
assert.strictEqual(sizeLines.length, chainPaths.length, 'size on disk must be printed for each disk')
|
||||
})
|
||||
|
||||
test('--chain: chain is closed even when opening a disk in it throws', async () => {
|
||||
currentDisk = {
|
||||
...baseDisk,
|
||||
getUuid: () => {
|
||||
throw new Error('corrupt header')
|
||||
},
|
||||
}
|
||||
await assert.rejects(() => infoCommand('file:///test', '/vdis/leaf.vhd', ['--chain']), /corrupt header/)
|
||||
assert.strictEqual(chainClose.mock.callCount(), 1, 'chain must be closed even on error')
|
||||
assert.strictEqual(handlerDispose.mock.callCount(), 1, 'handler must be disposed even on error')
|
||||
})
|
||||
})
|
||||
|
||||
@@ -27,9 +27,6 @@ const baseDisk = {
|
||||
getParentUuid: () => null as unknown as string,
|
||||
}
|
||||
|
||||
// Records the options each openDisposableDisk call received.
|
||||
const openDiskParams: Array<{ path: string; ignoreBlockIndexes?: boolean }> = []
|
||||
|
||||
// Reassigned per-test to control what handler.list() returns (or throws).
|
||||
let currentListImpl: () => Promise<string[]> = async () => []
|
||||
|
||||
@@ -54,10 +51,9 @@ mock.module('@xen-orchestra/fs', {
|
||||
|
||||
mock.module('@xen-orchestra/backup-archive/disks', {
|
||||
namedExports: {
|
||||
isDisk: (p: string) => p.endsWith('.vhd'),
|
||||
openDisposableDisk: (params: { path: string; ignoreBlockIndexes?: boolean }) => {
|
||||
openDiskParams.push(params)
|
||||
if (brokenPaths.has(params.path)) throw new Error('disk header corrupted')
|
||||
isDisk: (_h: unknown, p: string) => p.endsWith('.vhd'),
|
||||
openDisposableDisk: ({ path }: { path: string }) => {
|
||||
if (brokenPaths.has(path)) throw new Error('disk header corrupted')
|
||||
return Promise.resolve({ value: { ...baseDisk }, dispose: diskDispose })
|
||||
},
|
||||
},
|
||||
@@ -90,7 +86,6 @@ describe('list command', () => {
|
||||
handlerDispose.mock.resetCalls()
|
||||
diskDispose.mock.resetCalls()
|
||||
brokenPaths.clear()
|
||||
openDiskParams.length = 0
|
||||
currentListImpl = async () => ['/dir/disk.vhd']
|
||||
})
|
||||
|
||||
@@ -127,22 +122,4 @@ describe('list command', () => {
|
||||
const output = await captureLog(() => listCommand('file:///test', '/dir', []))
|
||||
assert.ok(output.includes('No disks found'))
|
||||
})
|
||||
|
||||
test('by default opens disks with ignoreBlockIndexes: true and hides the size column', async () => {
|
||||
const output = await captureLog(() => listCommand('file:///test', '/dir', []))
|
||||
assert.ok(
|
||||
openDiskParams.every(p => p.ignoreBlockIndexes === true),
|
||||
'disks must be opened with ignoreBlockIndexes: true by default'
|
||||
)
|
||||
assert.ok(!output.includes('Size on disk'), 'the size column must be hidden without --size')
|
||||
})
|
||||
|
||||
test('--size opens disks with ignoreBlockIndexes: false and shows the size column', async () => {
|
||||
const output = await captureLog(() => listCommand('file:///test', '/dir', ['--size']))
|
||||
assert.ok(
|
||||
openDiskParams.every(p => p.ignoreBlockIndexes === false),
|
||||
'disks must be opened with ignoreBlockIndexes: false with --size'
|
||||
)
|
||||
assert.ok(output.includes('Size on disk'), 'the size column must appear with --size')
|
||||
})
|
||||
})
|
||||
|
||||
@@ -2,10 +2,6 @@ import { describe, test } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { sortDisks, toTableRow, type DiskInfo } from '../commands/list.mjs'
|
||||
|
||||
// These tests assert on the full-width row (with the "Size on disk" column), so
|
||||
// they always exercise toTableRow with showSize = true.
|
||||
const toTableRowWithSize = (disk: DiskInfo, prevDisk: DiskInfo | undefined) => toTableRow(disk, prevDisk, true)
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -110,43 +106,43 @@ describe('sortDisks', () => {
|
||||
|
||||
describe('toTableRow', () => {
|
||||
test('base disk shows "(none)" in parent uid column', () => {
|
||||
const row = toTableRowWithSize(ok('a'), undefined)
|
||||
const row = toTableRow(ok('a'), undefined)
|
||||
assert.strictEqual(row[5], '(none)')
|
||||
})
|
||||
|
||||
test('differencing disk with no previous disk shows parentUid', () => {
|
||||
const row = toTableRowWithSize(ok('b', 'a'), undefined)
|
||||
const row = toTableRow(ok('b', 'a'), undefined)
|
||||
assert.strictEqual(row[5], 'a')
|
||||
})
|
||||
|
||||
test('differencing disk whose parent is not the previous row shows parentUid', () => {
|
||||
const row = toTableRowWithSize(ok('b', 'a'), ok('x'))
|
||||
const row = toTableRow(ok('b', 'a'), ok('x'))
|
||||
assert.strictEqual(row[5], 'a')
|
||||
})
|
||||
|
||||
test('differencing disk whose parent is immediately above shows ↑', () => {
|
||||
const row = toTableRowWithSize(ok('b', 'a'), ok('a'))
|
||||
const row = toTableRow(ok('b', 'a'), ok('a'))
|
||||
assert.strictEqual(row[5], '↑')
|
||||
})
|
||||
|
||||
test('error disk shows error message in second column', () => {
|
||||
const row = toTableRowWithSize(err('bad.vhd'), undefined)
|
||||
const row = toTableRow(err('bad.vhd'), undefined)
|
||||
assert.ok(row[1].includes('error'))
|
||||
assert.ok(row[1].includes('disk header corrupted'))
|
||||
})
|
||||
|
||||
test('differencing column shows "yes" for differencing disk', () => {
|
||||
assert.strictEqual(toTableRowWithSize(ok('b', 'a'), undefined)[4], 'yes')
|
||||
assert.strictEqual(toTableRow(ok('b', 'a'), undefined)[4], 'yes')
|
||||
})
|
||||
|
||||
test('differencing column shows "no" for base disk', () => {
|
||||
assert.strictEqual(toTableRowWithSize(ok('a'), undefined)[4], 'no')
|
||||
assert.strictEqual(toTableRow(ok('a'), undefined)[4], 'no')
|
||||
})
|
||||
|
||||
test('parent with multiple children: at least one child shows parent UID instead of ↑', () => {
|
||||
const sorted = sortDisks([ok('c2', 'a'), ok('a'), ok('c1', 'a')])
|
||||
|
||||
const rows = sorted.map((disk, i) => toTableRowWithSize(disk, sorted[i - 1]))
|
||||
const rows = sorted.map((disk, i) => toTableRow(disk, sorted[i - 1]))
|
||||
|
||||
// Find rows for the two children
|
||||
const childRows = rows.filter((_row, i) => {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@xen-orchestra/disk-transform",
|
||||
"version": "1.3.3",
|
||||
"version": "1.3.0",
|
||||
"main": "./dist/index.mjs",
|
||||
"license": "MIT",
|
||||
"private": false,
|
||||
@@ -10,7 +10,7 @@
|
||||
"rimraf": "^6.0.1",
|
||||
"@types/node": "^22.3.0",
|
||||
"typescript": "~5.6",
|
||||
"typescript-eslint": "^8.61.0"
|
||||
"typescript-eslint": "^8.23.0"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
@@ -34,6 +34,6 @@
|
||||
"node": ">=20.17"
|
||||
},
|
||||
"dependencies": {
|
||||
"@vates/generator-toolbox": "^1.1.3"
|
||||
"@vates/generator-toolbox": "^1.1.2"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,26 +66,19 @@ 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
|
||||
}
|
||||
|
||||
hasBlock(index: number): boolean {
|
||||
const source = this.source
|
||||
let maxBlockSource = Math.ceil(source.getVirtualSize() / source.getBlockSize())
|
||||
|
||||
@@ -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))
|
||||
})
|
||||
|
||||
@@ -42,9 +42,6 @@ export class DiskPassthrough extends Disk {
|
||||
getBlockIndexes(): Array<number> {
|
||||
return this.source.getBlockIndexes()
|
||||
}
|
||||
getBlockIndexesCount(): number {
|
||||
return this.source.getBlockIndexesCount()
|
||||
}
|
||||
hasBlock(index: number): boolean {
|
||||
return this.source.hasBlock(index)
|
||||
}
|
||||
@@ -105,9 +102,6 @@ export abstract class RandomDiskPassthrough extends RandomAccessDisk {
|
||||
getBlockIndexes(): Array<number> {
|
||||
return this.source.getBlockIndexes()
|
||||
}
|
||||
getBlockIndexesCount(): number {
|
||||
return this.source.getBlockIndexesCount()
|
||||
}
|
||||
hasBlock(index: number): boolean {
|
||||
return this.source.hasBlock(index)
|
||||
}
|
||||
|
||||
@@ -49,9 +49,6 @@ export class NegativeDisk extends RandomAccessDisk {
|
||||
getBlockIndexes(): Array<number> {
|
||||
return this.#child.getBlockIndexes()
|
||||
}
|
||||
getBlockIndexesCount(): number {
|
||||
return this.#child.getBlockIndexesCount()
|
||||
}
|
||||
hasBlock(index: number): boolean {
|
||||
return this.#child.hasBlock(index)
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"private": false,
|
||||
"name": "@xen-orchestra/fs",
|
||||
"version": "4.9.3",
|
||||
"version": "4.9.0",
|
||||
"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",
|
||||
@@ -21,11 +21,11 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@aws-sdk/abort-controller": "^3.272.0",
|
||||
"@aws-sdk/client-s3": "^3.1065.0",
|
||||
"@aws-sdk/lib-storage": "^3.1065.0",
|
||||
"@aws-sdk/client-s3": "^3.54.0",
|
||||
"@aws-sdk/lib-storage": "^3.54.0",
|
||||
"@aws-sdk/middleware-apply-body-checksum": "^3.58.0",
|
||||
"@aws-sdk/node-http-handler": "^3.54.0",
|
||||
"@azure/storage-blob": "^12.32.0",
|
||||
"@azure/storage-blob": "^12.26.0",
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@vates/coalesce-calls": "^0.1.0",
|
||||
"@vates/decorate-with": "^2.1.0",
|
||||
@@ -45,11 +45,11 @@
|
||||
"xo-remote-parser": "^0.10.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@babel/cli": "^7.29.0",
|
||||
"@babel/core": "^7.29.0",
|
||||
"@babel/plugin-proposal-decorators": "^7.29.0",
|
||||
"@babel/plugin-proposal-function-bind": "^7.29.0",
|
||||
"@babel/preset-env": "^7.29.0",
|
||||
"@babel/cli": "^7.0.0",
|
||||
"@babel/core": "^7.0.0",
|
||||
"@babel/plugin-proposal-decorators": "^7.1.6",
|
||||
"@babel/plugin-proposal-function-bind": "^7.0.0",
|
||||
"@babel/preset-env": "^7.8.0",
|
||||
"cross-env": "^7.0.2",
|
||||
"dotenv": "^16.0.0",
|
||||
"rimraf": "^6.0.1",
|
||||
|
||||
@@ -19,7 +19,6 @@ function getEncryptor(algorithm = DEFAULT_ENCRYPTION_ALGORITHM, key) {
|
||||
algorithm: 'none',
|
||||
key: 'none',
|
||||
ivLength: 0,
|
||||
authTagLength: 0,
|
||||
encryptData: buffer => buffer,
|
||||
encryptStream: stream => stream,
|
||||
decryptData: buffer => buffer,
|
||||
@@ -128,7 +127,6 @@ function getEncryptor(algorithm = DEFAULT_ENCRYPTION_ALGORITHM, key) {
|
||||
id: algorithm,
|
||||
algorithm,
|
||||
key,
|
||||
authTagLength,
|
||||
ivLength,
|
||||
encryptData,
|
||||
encryptStream,
|
||||
|
||||
@@ -292,14 +292,7 @@ export default class RemoteHandlerAbstract {
|
||||
async outputStream(path, input, { checksum = true, dirMode, maxStreamLength, streamLength, validator } = {}) {
|
||||
path = normalizePath(path)
|
||||
let checksumStream
|
||||
info('will output stream ', { path, streamLength, maxStreamLength, isEncrypted: this.isEncrypted })
|
||||
if (this.isEncrypted) {
|
||||
info('stream is encrypted', { path, streamLength, maxStreamLength })
|
||||
const overhead = this.#encryptor.ivLength + this.#encryptor.authTagLength
|
||||
if (streamLength !== undefined) streamLength += overhead
|
||||
if (maxStreamLength !== undefined) maxStreamLength += overhead
|
||||
info('stream is updated ', { path, streamLength, maxStreamLength, overhead })
|
||||
}
|
||||
|
||||
input = this.#encryptor.encryptStream(input)
|
||||
if (checksum) {
|
||||
checksumStream = createChecksumStream()
|
||||
|
||||
@@ -40,8 +40,6 @@ export default class S3Handler extends RemoteHandlerAbstract {
|
||||
#bucket
|
||||
#dir
|
||||
#s3
|
||||
#httpAgent
|
||||
#httpsAgent
|
||||
#immutable = false
|
||||
#maxPartSize
|
||||
#maxPartNumber
|
||||
@@ -79,13 +77,13 @@ export default class S3Handler extends RemoteHandlerAbstract {
|
||||
region,
|
||||
requestHandler: new NodeHttpHandler({
|
||||
socketTimeout: 600000,
|
||||
httpAgent: (this.#httpAgent = new HttpAgent({
|
||||
httpAgent: new HttpAgent({
|
||||
keepAlive: true,
|
||||
})),
|
||||
httpsAgent: (this.#httpsAgent = new HttpsAgent({
|
||||
}),
|
||||
httpsAgent: new HttpsAgent({
|
||||
rejectUnauthorized: !allowUnauthorized,
|
||||
keepAlive: true,
|
||||
})),
|
||||
}),
|
||||
}),
|
||||
// from https://github.com/aws/aws-sdk-js-v3/issues/6810
|
||||
// some non AWS services like backblaze or cloudflare don't expect the new headers
|
||||
@@ -102,12 +100,6 @@ export default class S3Handler extends RemoteHandlerAbstract {
|
||||
return 's3'
|
||||
}
|
||||
|
||||
async _forget() {
|
||||
this.#s3.destroy()
|
||||
this.#httpAgent.destroy()
|
||||
this.#httpsAgent.destroy()
|
||||
}
|
||||
|
||||
#makeCopySource(path) {
|
||||
return join(this.#bucket, this.#dir, path)
|
||||
}
|
||||
@@ -441,11 +433,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 ?? [],
|
||||
},
|
||||
})
|
||||
)
|
||||
|
||||
@@ -157,7 +157,7 @@ export abstract class RemoteHandlerAbstract {
|
||||
abstract getInfo(): Promise<RemoteInfoResult>
|
||||
|
||||
abstract getSize(file: FileDescriptor): Promise<number>
|
||||
abstract getSizeOnDisk(file: FileDescriptor): Promise<number>
|
||||
abstract getSizeOnDisk(file: FileArg): Promise<number>
|
||||
abstract lock(path: string): Promise<LockDisposer>
|
||||
abstract test(): Promise<TestResult>
|
||||
abstract isImmutable(): boolean
|
||||
|
||||
@@ -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
|
||||
@@ -101,33 +100,13 @@ 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
|
||||
|
||||
If one or a few VM had an issue and need manual cleanup, you can manually lift the immutability for one VM.
|
||||
|
||||
1. Stop the `xo-immutable-remote` service.
|
||||
2. As root on the file server, run:
|
||||
```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
|
||||
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
|
||||
```
|
||||
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.
|
||||
|
||||
### Increasing the immutability duration
|
||||
|
||||
Change the setting. The next lift cycle will use the new duration; files already past the old duration but within the new one will remain protected.
|
||||
|
||||
### 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,33 +116,13 @@ 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
|
||||
|
||||
If one or a few VM had an issue and need manual cleanup, you can manually lift the immutability for one VM.
|
||||
|
||||
1. Stop the `xo-immutable-remote` service.
|
||||
2. As root on the file server, run:
|
||||
```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
|
||||
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
|
||||
```
|
||||
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.
|
||||
|
||||
### Increasing the immutability duration
|
||||
|
||||
Change the setting. The next lift cycle will use the new duration; files already past the old duration but within the new one will remain protected.
|
||||
|
||||
### 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.4",
|
||||
"version": "3.0.3",
|
||||
"engines": {
|
||||
"node": ">=20.0.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@vates/async-each": "^1.0.3",
|
||||
"@xen-orchestra/backups": "^0.73.10",
|
||||
"@xen-orchestra/backups": "^0.73.2",
|
||||
"@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,26 +1,9 @@
|
||||
# ChangeLog
|
||||
|
||||
## **0.24.0** (2026-07-30)
|
||||
|
||||
- [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)
|
||||
## **next**
|
||||
|
||||
- Update the UiTitle component to use the one from web-core (PR [#9869](https://github.com/vatesfr/xen-orchestra/pull/9869))
|
||||
- [Pool/System] Add `Reboot VM on internal shutdown` in pool's system tab (PR [#9962](https://github.com/vatesfr/xen-orchestra/pull/9962))
|
||||
- Update the UiCard component to use the one from web-core (PR [#9980](https://github.com/vatesfr/xen-orchestra/pull/9980))
|
||||
- Update the UiCardTitle component to use the one from web-core (PR [#9982](https://github.com/vatesfr/xen-orchestra/pull/9982))
|
||||
- Replacement of the UiSeparator component with VtsDivider from web-core (PR [#10017](https://github.com/vatesfr/xen-orchestra/pull/10017))
|
||||
- Update side panels (PR [#9836](https://github.com/vatesfr/xen-orchestra/pull/9836))
|
||||
- [XOA deploy] Update log visualization component (PR [#9995](https://github.com/vatesfr/xen-orchestra/pull/9995))
|
||||
- [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.24.0",
|
||||
"version": "0.22.0",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"dev": "GIT_HEAD=$(git rev-parse HEAD) vite",
|
||||
@@ -28,13 +28,13 @@
|
||||
"@types/file-saver": "^2.0.7",
|
||||
"@types/lodash-es": "^4.17.12",
|
||||
"@types/node": "^18.19.80",
|
||||
"@vates/types": "^1.30.1",
|
||||
"@vates/types": "^1.26.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.58.0",
|
||||
"@xen-orchestra/web-core": "^0.54.0",
|
||||
"complex-matcher": "^1.1.1",
|
||||
"d3-time-format": "^4.1.0",
|
||||
"decorator-synchronized": "^0.6.0",
|
||||
@@ -62,7 +62,7 @@
|
||||
"vite": "^8.0.0",
|
||||
"vue": "~3.5.13",
|
||||
"vue-i18n": "^11.1.2",
|
||||
"vue-router": "5.0.6",
|
||||
"vue-router": "^5.0.0",
|
||||
"vue-tsc": "~2.2.8",
|
||||
"zx": "^7.2.3"
|
||||
},
|
||||
|
||||
@@ -11,7 +11,8 @@
|
||||
</main>
|
||||
</div>
|
||||
</div>
|
||||
<VtsOverlayList />
|
||||
<VtsModalList />
|
||||
<VtsDrawerList />
|
||||
<VtsTooltipList />
|
||||
</template>
|
||||
|
||||
@@ -22,7 +23,8 @@ import AppNavigation from '@/components/AppNavigation.vue'
|
||||
import { useUnreachableHosts } from '@/composables/unreachable-hosts.composable'
|
||||
import { usePoolStore } from '@/stores/xen-api/pool.store'
|
||||
import { useXenApiStore } from '@/stores/xen-api.store'
|
||||
import VtsOverlayList from '@core/components/overlay/VtsOverlayList.vue'
|
||||
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'
|
||||
import { useUiStore } from '@core/stores/ui.store'
|
||||
|
||||
@@ -20,7 +20,8 @@ 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'
|
||||
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 { 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" />
|
||||
@@ -20,6 +20,7 @@
|
||||
<script lang="ts" setup>
|
||||
import UiActionButton from '@/components/ui/UiActionButton.vue'
|
||||
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'
|
||||
@@ -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
|
||||
)
|
||||
|
||||
@@ -24,7 +24,8 @@ import UiFilter from '@/components/ui/UiFilter.vue'
|
||||
import UiFilterGroup from '@/components/ui/UiFilterGroup.vue'
|
||||
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>
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<template>
|
||||
<UiLoader v-if="!isReady" />
|
||||
<UiSpinner v-if="!isReady" />
|
||||
<template v-else-if="record !== undefined">
|
||||
<RouterLink v-if="objectRoute" :to="objectRoute">
|
||||
{{ record.name_label }}
|
||||
@@ -10,13 +10,13 @@
|
||||
</template>
|
||||
|
||||
<script generic="T extends ObjectType" lang="ts" setup>
|
||||
import UiSpinner from '@/components/ui/UiSpinner.vue'
|
||||
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'
|
||||
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
<template>
|
||||
<div v-if="!isReady" class="wrapper-spinner">
|
||||
<UiLoader class="loader" />
|
||||
<UiSpinner class="spinner" />
|
||||
</div>
|
||||
<ObjectNotFoundView v-else-if="isRecordNotFound" :id />
|
||||
<slot v-else />
|
||||
</template>
|
||||
|
||||
<script generic="T extends XenApiRecord<ObjectType>, I extends T['uuid']" lang="ts" setup>
|
||||
import UiSpinner from '@/components/ui/UiSpinner.vue'
|
||||
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'
|
||||
import { useRoute } from 'vue-router'
|
||||
|
||||
@@ -32,7 +32,7 @@ const isRecordNotFound = computed(() => props.isReady && !props.uuidChecker(id.v
|
||||
height: 100%;
|
||||
}
|
||||
|
||||
.loader {
|
||||
.spinner {
|
||||
color: var(--color-brand-txt-base);
|
||||
display: flex;
|
||||
margin: auto;
|
||||
|
||||
@@ -40,7 +40,7 @@
|
||||
<UiCard>
|
||||
<UiCardTitle>
|
||||
Logs
|
||||
<template #info>
|
||||
<template #right>
|
||||
<UiButton
|
||||
v-if="eventsLog.length > 0"
|
||||
size="medium"
|
||||
@@ -79,6 +79,8 @@ import StoryEventParams from '@/components/component-story/StoryEventParams.vue'
|
||||
import StoryPropParams from '@/components/component-story/StoryPropParams.vue'
|
||||
import StorySettingParams from '@/components/component-story/StorySettingParams.vue'
|
||||
import StorySlotParams from '@/components/component-story/StorySlotParams.vue'
|
||||
import UiCard from '@/components/ui/UiCard.vue'
|
||||
import UiCardTitle from '@/components/ui/UiCardTitle.vue'
|
||||
import {
|
||||
isEventParam,
|
||||
isModelParam,
|
||||
@@ -94,8 +96,6 @@ import MenuList from '@core/components/menu/MenuList.vue'
|
||||
import TabItem from '@core/components/tab/TabItem.vue'
|
||||
import TabList from '@core/components/tab/TabList.vue'
|
||||
import UiButton from '@core/components/ui/button/UiButton.vue'
|
||||
import UiCard from '@core/components/ui/card/UiCard.vue'
|
||||
import UiCardTitle from '@core/components/ui/card-title/UiCardTitle.vue'
|
||||
import UiCounter from '@core/components/ui/counter/UiCounter.vue'
|
||||
import 'highlight.js/styles/github-dark.css'
|
||||
import { uniqueId, upperFirst } from 'lodash-es'
|
||||
|
||||
@@ -87,7 +87,7 @@ 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'
|
||||
import { useOverlay } from '@core/packages/overlay/use-overlay.ts'
|
||||
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>
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
<script lang="ts" setup>
|
||||
import FormInput from '@/components/form/FormInput.vue'
|
||||
import { useOverlay } from '@core/packages/overlay/use-overlay.ts'
|
||||
import { useModal } from '@core/packages/modal/use-modal.ts'
|
||||
import { useVModel } from '@vueuse/core'
|
||||
import { computed } from 'vue'
|
||||
|
||||
@@ -20,17 +20,11 @@ const model = useVModel(props, 'modelValue', emit)
|
||||
|
||||
const jsonValue = computed(() => JSON.stringify(model.value, undefined, 2))
|
||||
|
||||
const { open } = useOverlay({
|
||||
component: () => import('@/components/modals/JsonEditorModal.vue'),
|
||||
events: {
|
||||
onConfirm: (newValue: string) => {
|
||||
model.value = JSON.parse(newValue)
|
||||
},
|
||||
onCancel: true,
|
||||
const openJsonModal = useModal({
|
||||
component: import('@/components/modals/JsonEditorModal.vue'),
|
||||
props: { initialValue: computed(() => jsonValue.value) },
|
||||
onConfirm: newValue => {
|
||||
model.value = JSON.parse(newValue)
|
||||
},
|
||||
})
|
||||
|
||||
function openJsonModal() {
|
||||
return open({ props: { initialValue: jsonValue.value } })
|
||||
}
|
||||
</script>
|
||||
|
||||
@@ -12,9 +12,6 @@
|
||||
<RouterTab :to="{ name: '/host/[uuid]/network', params: { uuid } }">
|
||||
{{ t('network') }}
|
||||
</RouterTab>
|
||||
<RouterTab :to="{ name: '/host/[uuid]/storage', params: { uuid } }">
|
||||
{{ t('storage') }}
|
||||
</RouterTab>
|
||||
<RouterTab :to="{ name: '/host/[uuid]/tasks', params: { uuid } }" disabled>
|
||||
{{ t('tasks') }}
|
||||
</RouterTab>
|
||||
|
||||
@@ -1,10 +1,58 @@
|
||||
<template>
|
||||
<VtsSidePanel :has-selection="!!pif" @close="emit('close')">
|
||||
<template v-if="pif" #default>
|
||||
<UiPanel :class="{ 'mobile-drawer': uiStore.isSmall }">
|
||||
<template #header>
|
||||
<div :class="{ 'action-buttons-container': uiStore.isSmall }">
|
||||
<UiButtonIcon
|
||||
v-if="uiStore.isSmall"
|
||||
v-tooltip="t('action:close')"
|
||||
size="small"
|
||||
variant="tertiary"
|
||||
accent="brand"
|
||||
icon="fa:angle-left"
|
||||
@click="emit('close')"
|
||||
/>
|
||||
<div class="action-buttons">
|
||||
<UiButton
|
||||
v-tooltip="t('coming-soon!')"
|
||||
disabled
|
||||
size="medium"
|
||||
variant="tertiary"
|
||||
accent="brand"
|
||||
left-icon="fa:edit"
|
||||
>
|
||||
{{ t('action:edit') }}
|
||||
</UiButton>
|
||||
<UiButton
|
||||
v-tooltip="t('coming-soon!')"
|
||||
disabled
|
||||
size="medium"
|
||||
variant="tertiary"
|
||||
accent="danger"
|
||||
left-icon="fa:trash"
|
||||
>
|
||||
{{ t('action:delete') }}
|
||||
</UiButton>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
<template #default>
|
||||
<!-- PIF -->
|
||||
<UiCard class="card">
|
||||
<VtsCardObjectTitle :id="pif.uuid" :label="isBond ? t('bond') : t('pif')" />
|
||||
<UiCardTitle>{{ isBond ? t('bond') : t('pif') }}</UiCardTitle>
|
||||
<div class="content">
|
||||
<!-- UUID -->
|
||||
<VtsCardRowKeyValue>
|
||||
<template #key>
|
||||
{{ t('uuid') }}
|
||||
</template>
|
||||
<template #value>
|
||||
{{ pif.uuid }}
|
||||
</template>
|
||||
<template #addons>
|
||||
<VtsIcon v-if="pif.management" v-tooltip="t('management')" name="status:primary-circle" size="medium" />
|
||||
<VtsCopyButton :value="pif.uuid" />
|
||||
</template>
|
||||
</VtsCardRowKeyValue>
|
||||
<!-- NETWORK -->
|
||||
<VtsCardRowKeyValue>
|
||||
<template #key>
|
||||
@@ -27,7 +75,6 @@
|
||||
</template>
|
||||
<template #value>
|
||||
{{ pif.device }}
|
||||
<VtsIcon v-if="pif.management" v-tooltip="t('management')" name="status:primary-circle" size="medium" />
|
||||
</template>
|
||||
<template #addons>
|
||||
<VtsCopyButton :value="pif.device" />
|
||||
@@ -91,7 +138,14 @@
|
||||
</template>
|
||||
<template #addons>
|
||||
<VtsCopyButton :value="ip" />
|
||||
<VtsCopyAllMenuItem v-if="index === 0 && ipAddresses.length > 1" :values="ipAddresses" />
|
||||
<UiButtonIcon
|
||||
v-if="index === 0 && ipAddresses.length > 1"
|
||||
v-tooltip="t('coming-soon!')"
|
||||
disabled
|
||||
icon="fa:ellipsis"
|
||||
size="small"
|
||||
accent="brand"
|
||||
/>
|
||||
</template>
|
||||
</VtsCardRowKeyValue>
|
||||
</div>
|
||||
@@ -175,7 +229,14 @@
|
||||
</template>
|
||||
<template v-if="device" #addons>
|
||||
<VtsCopyButton :value="device" />
|
||||
<VtsCopyAllMenuItem v-if="index === 0 && bondDevices.length > 1" :values="bondDevicesFiltered" />
|
||||
<UiButtonIcon
|
||||
v-if="index === 0 && bondDevices.length > 1"
|
||||
v-tooltip="t('coming-soon!')"
|
||||
disabled
|
||||
icon="fa:ellipsis"
|
||||
size="small"
|
||||
accent="brand"
|
||||
/>
|
||||
</template>
|
||||
</VtsCardRowKeyValue>
|
||||
</div>
|
||||
@@ -221,7 +282,7 @@
|
||||
</div>
|
||||
</UiCard>
|
||||
</template>
|
||||
</VtsSidePanel>
|
||||
</UiPanel>
|
||||
</template>
|
||||
|
||||
<script setup lang="ts">
|
||||
@@ -230,23 +291,24 @@ import { useNetworkStore } from '@/stores/xen-api/network.store'
|
||||
import { usePifMetricsStore } from '@/stores/xen-api/pif-metrics.store'
|
||||
import { usePifStore } from '@/stores/xen-api/pif.store'
|
||||
import VtsCardRowKeyValue from '@core/components/card/VtsCardRowKeyValue.vue'
|
||||
import VtsCardObjectTitle from '@core/components/card-object-title/VtsCardObjectTitle.vue'
|
||||
import VtsCopyAllMenuItem from '@core/components/copy-all-menu-item/VtsCopyAllMenuItem.vue'
|
||||
import VtsCopyButton from '@core/components/copy-button/VtsCopyButton.vue'
|
||||
import VtsIcon from '@core/components/icon/VtsIcon.vue'
|
||||
import VtsSidePanel from '@core/components/panel/VtsSidePanel.vue'
|
||||
import VtsStatus from '@core/components/status/VtsStatus.vue'
|
||||
import VtsTag from '@core/components/tag/VtsTag.vue'
|
||||
import UiButton from '@core/components/ui/button/UiButton.vue'
|
||||
import UiButtonIcon from '@core/components/ui/button-icon/UiButtonIcon.vue'
|
||||
import UiCard from '@core/components/ui/card/UiCard.vue'
|
||||
import UiCardTitle from '@core/components/ui/card-title/UiCardTitle.vue'
|
||||
import UiPanel from '@core/components/ui/panel/UiPanel.vue'
|
||||
import UiTagsList from '@core/components/ui/tag/UiTagsList.vue'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive'
|
||||
import { useUiStore } from '@core/stores/ui.store.ts'
|
||||
import humanFormat from 'human-format'
|
||||
import { computed } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
|
||||
const { pif } = defineProps<{
|
||||
pif?: XenApiPif
|
||||
pif: XenApiPif
|
||||
}>()
|
||||
|
||||
const emit = defineEmits<{
|
||||
@@ -256,32 +318,21 @@ const emit = defineEmits<{
|
||||
const { getByOpaqueRef: getPifMetricsByOpaqueRef, getPifCarrier } = usePifMetricsStore().subscribe()
|
||||
const { getByOpaqueRef: getNetworkByOpaqueRef } = useNetworkStore().subscribe()
|
||||
const { getBondsDevices, isBondMaster } = usePifStore().subscribe()
|
||||
const uiStore = useUiStore()
|
||||
|
||||
const { t } = useI18n()
|
||||
|
||||
const ipAddresses = computed(() => {
|
||||
if (pif === undefined) {
|
||||
return []
|
||||
}
|
||||
const ipAddresses = computed(() => [pif.IP, ...pif.IPv6].filter(ip => ip))
|
||||
|
||||
return [pif.IP, ...pif.IPv6].filter(ip => ip)
|
||||
})
|
||||
|
||||
const network = computed(() => (pif !== undefined ? getNetworkByOpaqueRef(pif.network) : undefined))
|
||||
const network = computed(() => getNetworkByOpaqueRef(pif.network))
|
||||
|
||||
const networkPurpose = computed(() => (network.value?.purpose?.[0] ? t('on') : t('off')))
|
||||
|
||||
const status = computed(() => (pif?.currently_attached ? 'connected' : 'disconnected'))
|
||||
const status = computed(() => (pif.currently_attached ? 'connected' : 'disconnected'))
|
||||
|
||||
const physicalInterfaceStatus = computed(() =>
|
||||
pif !== undefined && getPifCarrier(pif) ? 'connected' : 'physically-disconnected'
|
||||
)
|
||||
const physicalInterfaceStatus = computed(() => (getPifCarrier(pif) ? 'connected' : 'physically-disconnected'))
|
||||
|
||||
const ipConfigurationMode = computed(() => {
|
||||
if (pif === undefined) {
|
||||
return t('none')
|
||||
}
|
||||
|
||||
switch (pif.ip_configuration_mode) {
|
||||
case 'Static':
|
||||
return t('static')
|
||||
@@ -292,19 +343,11 @@ const ipConfigurationMode = computed(() => {
|
||||
}
|
||||
})
|
||||
|
||||
const bondDevices = computed(() => (pif !== undefined ? getBondsDevices(pif) : []))
|
||||
const bondDevices = computed(() => getBondsDevices(pif))
|
||||
|
||||
const bondDevicesFiltered = computed(() => {
|
||||
return bondDevices.value.filter((bondDevice): bondDevice is string => bondDevice !== undefined)
|
||||
})
|
||||
|
||||
const isBond = computed(() => (pif !== undefined ? isBondMaster(pif) : false))
|
||||
const isBond = computed(() => isBondMaster(pif))
|
||||
|
||||
const speed = computed(() => {
|
||||
if (pif === undefined) {
|
||||
return ''
|
||||
}
|
||||
|
||||
const speed = getPifMetricsByOpaqueRef(pif.metrics)?.speed || 0
|
||||
const speedInBytes = speed * 1000000
|
||||
|
||||
@@ -341,4 +384,21 @@ const speed = computed(() => {
|
||||
content: '-';
|
||||
}
|
||||
}
|
||||
|
||||
.mobile-drawer {
|
||||
position: fixed;
|
||||
inset: 0;
|
||||
|
||||
.action-buttons-container {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
width: 100%;
|
||||
}
|
||||
}
|
||||
|
||||
.action-buttons {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
}
|
||||
</style>
|
||||
|
||||
@@ -2,9 +2,45 @@
|
||||
<div class="host-pif-table">
|
||||
<UiTitle>
|
||||
{{ t('pifs') }}
|
||||
<template #action>
|
||||
<UiButton
|
||||
v-tooltip="t('coming-soon!')"
|
||||
disabled
|
||||
left-icon="fa:plus"
|
||||
variant="secondary"
|
||||
accent="brand"
|
||||
size="medium"
|
||||
>
|
||||
{{ t('scan-pifs') }}
|
||||
</UiButton>
|
||||
</template>
|
||||
</UiTitle>
|
||||
<div class="container">
|
||||
<UiQuerySearchBar @search="(value: string) => (searchQuery = value)" />
|
||||
<div class="table-actions">
|
||||
<UiQuerySearchBar @search="(value: string) => (searchQuery = value)" />
|
||||
<UiTableActions :title="t('table-actions')">
|
||||
<UiButton
|
||||
v-tooltip="t('coming-soon!')"
|
||||
disabled
|
||||
left-icon="fa:edit"
|
||||
variant="tertiary"
|
||||
accent="brand"
|
||||
size="medium"
|
||||
>
|
||||
{{ t('action:edit') }}
|
||||
</UiButton>
|
||||
<UiButton
|
||||
v-tooltip="t('coming-soon!')"
|
||||
disabled
|
||||
left-icon="fa:trash"
|
||||
variant="tertiary"
|
||||
accent="danger"
|
||||
size="medium"
|
||||
>
|
||||
{{ t('action:delete') }}
|
||||
</UiButton>
|
||||
</UiTableActions>
|
||||
</div>
|
||||
<VtsTable :state :pagination-bindings sticky="right">
|
||||
<thead>
|
||||
<tr>
|
||||
@@ -27,11 +63,14 @@ import { useNetworkStore } from '@/stores/xen-api/network.store'
|
||||
import { usePifStore } from '@/stores/xen-api/pif.store'
|
||||
import VtsRow from '@core/components/table/VtsRow.vue'
|
||||
import VtsTable from '@core/components/table/VtsTable.vue'
|
||||
import UiButton from '@core/components/ui/button/UiButton.vue'
|
||||
import UiQuerySearchBar from '@core/components/ui/query-search-bar/UiQuerySearchBar.vue'
|
||||
import UiTableActions from '@core/components/ui/table-actions/UiTableActions.vue'
|
||||
import UiTitle from '@core/components/ui/title/UiTitle.vue'
|
||||
import { usePagination } from '@core/composables/pagination.composable'
|
||||
import { useRouteQuery } from '@core/composables/route-query.composable'
|
||||
import { useTableState } from '@core/composables/table-state.composable'
|
||||
import { vTooltip } from '@core/directives/tooltip.directive'
|
||||
import { icon } from '@core/icons'
|
||||
import { usePifColumns } from '@core/tables/column-sets/pif-columns'
|
||||
import { logicNot } from '@vueuse/math'
|
||||
@@ -128,6 +167,7 @@ const { HeadCells, BodyCells } = usePifColumns({
|
||||
|
||||
<style scoped lang="postcss">
|
||||
.host-pif-table,
|
||||
.table-actions,
|
||||
.container {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
@@ -136,7 +176,8 @@ const { HeadCells, BodyCells } = usePifColumns({
|
||||
.host-pif-table {
|
||||
gap: 2.4rem;
|
||||
|
||||
.container {
|
||||
.container,
|
||||
.table-actions {
|
||||
gap: 0.8rem;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
<template>
|
||||
<UiModal accent="info" @dismiss="emit('close')">
|
||||
<VtsModal accent="info" dismissible>
|
||||
<template #content>
|
||||
<CodeHighlight :code />
|
||||
</template>
|
||||
</UiModal>
|
||||
</VtsModal>
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import CodeHighlight from '@/components/CodeHighlight.vue'
|
||||
import UiModal from '@core/components/ui/modal/UiModal.vue'
|
||||
import VtsModal from '@core/components/modal/VtsModal.vue'
|
||||
|
||||
defineProps<{
|
||||
code: any
|
||||
}>()
|
||||
|
||||
const emit = defineEmits<{
|
||||
close: []
|
||||
}>()
|
||||
</script>
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user