You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
324 lines
12 KiB
Go
324 lines
12 KiB
Go
//go:build libvirt
|
|
|
|
package hypervisor
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"git.luoli.live/root/virt/agent/objecttransfer"
|
|
"git.luoli.live/root/virt/agent/operation"
|
|
"libvirt.org/go/libvirt"
|
|
"libvirt.org/go/libvirtxml"
|
|
)
|
|
|
|
func TestBackupTransientBlockerUsesOneAuthoritativeMapping(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
metadata *domainMetadataXML
|
|
reason string
|
|
}{
|
|
{name: "ready", metadata: &domainMetadataXML{}},
|
|
{name: "rescue", metadata: &domainMetadataXML{RescueTemplateID: "rescue-image"}, reason: "backup_rescue_active"},
|
|
{name: "cleanup", metadata: &domainMetadataXML{PendingCleanupVolume: "root-old.qcow2"}, reason: "backup_disk_transition_active"},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if got := backupTransientBlocker(test.metadata); got != test.reason {
|
|
t.Fatalf("blocker=%q want=%q", got, test.reason)
|
|
}
|
|
err := validateBackupTransientState(test.metadata)
|
|
if test.reason == "" && err != nil {
|
|
t.Fatalf("ready state rejected: %v", err)
|
|
}
|
|
if test.reason != "" && errorPublicCode(err) != test.reason {
|
|
t.Fatalf("validation code=%q want=%q", errorPublicCode(err), test.reason)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func portableRestoreDomainFixture(t *testing.T) (*Libvirt, *libvirtxml.Domain, *domainMetadataXML) {
|
|
t.Helper()
|
|
definition := validDomainDefinition()
|
|
directory := "/var/lib/libvirt/qemu/nvram"
|
|
definition.Firmware.NVRAMPath = filepath.Join(directory, definition.UUID+"_VARS.fd")
|
|
document, err := BuildDomainXML(definition)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
domain, metadata, err := parseManagedDomain(document)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
adapter := &Libvirt{local: LocalConfig{
|
|
FirmwareLoader: definition.Firmware.Loader,
|
|
FirmwareNVRAMTemplate: definition.Firmware.NVRAMTemplate,
|
|
NVRAMDirectory: directory,
|
|
}}
|
|
return adapter, domain, metadata
|
|
}
|
|
|
|
func TestPortableRestoreSourceContractRequiresActualManagedPlatform(t *testing.T) {
|
|
adapter, domain, metadata := portableRestoreDomainFixture(t)
|
|
contract, err := adapter.validatePortableRestoreDomain(domain, metadata)
|
|
if err != nil || contract != fixedPortableRestoreContract() {
|
|
t.Fatalf("valid portable source contract=%#v err=%v", contract, err)
|
|
}
|
|
|
|
tests := map[string]func(*libvirtxml.Domain, *domainMetadataXML){
|
|
"architecture": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.OS.Type.Arch = "aarch64" },
|
|
"machine": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.OS.Type.Machine = "pc-i440fx-9.2" },
|
|
"secure boot": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.OS.Loader.Secure = "yes" },
|
|
"firmware": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.OS.Loader.Type = "rom" },
|
|
"nvram": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.OS.NVRam = nil },
|
|
"smm": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.Features.SMM.State = "on" },
|
|
"disk format": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.Devices.Disks[0].Driver.Type = "raw" },
|
|
"disk bus": func(value *libvirtxml.Domain, _ *domainMetadataXML) { value.Devices.Disks[0].Target.Bus = "sata" },
|
|
"backing": func(value *libvirtxml.Domain, _ *domainMetadataXML) {
|
|
value.Devices.Disks[0].BackingStore = &libvirtxml.DomainDiskBackingStore{
|
|
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: "/foreign/base.qcow2"}},
|
|
}
|
|
},
|
|
"public contract": func(_ *libvirtxml.Domain, value *domainMetadataXML) { value.PublicNetwork.Contract = 2 },
|
|
"public source": func(value *libvirtxml.Domain, _ *domainMetadataXML) {
|
|
value.Devices.Interfaces[0].Source.Bridge.Bridge = "br1"
|
|
},
|
|
}
|
|
for name, mutate := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
currentAdapter, current, currentMetadata := portableRestoreDomainFixture(t)
|
|
mutate(current, currentMetadata)
|
|
if _, err := currentAdapter.validatePortableRestoreDomain(current, currentMetadata); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("incompatible source error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPortableRestoreSourceContractDoesNotInheritSourceVPC(t *testing.T) {
|
|
definition := validDomainDefinition()
|
|
directory := "/var/lib/libvirt/qemu/nvram"
|
|
definition.Firmware.NVRAMPath = filepath.Join(directory, definition.UUID+"_VARS.fd")
|
|
port := validVPCPortMetadata()
|
|
definition.VPCPort = &port
|
|
definition.Network = append(definition.Network, NetworkAttachment{
|
|
Bridge: port.Bridge, MAC: port.MAC,
|
|
})
|
|
document, err := BuildDomainXML(definition)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
domain, metadata, err := parseManagedDomain(document)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
adapter := &Libvirt{local: LocalConfig{
|
|
FirmwareLoader: definition.Firmware.Loader, FirmwareNVRAMTemplate: definition.Firmware.NVRAMTemplate,
|
|
NVRAMDirectory: directory,
|
|
}}
|
|
contract, err := adapter.validatePortableRestoreDomain(domain, metadata)
|
|
if err != nil || contract.VPCInherited {
|
|
t.Fatalf("source VPC contract=%#v err=%v", contract, err)
|
|
}
|
|
}
|
|
|
|
type backupVolumeInspector struct {
|
|
document string
|
|
capacity uint64
|
|
}
|
|
|
|
func (v backupVolumeInspector) GetXMLDesc(uint32) (string, error) { return v.document, nil }
|
|
func (v backupVolumeInspector) GetInfo() (*libvirt.StorageVolInfo, error) {
|
|
return &libvirt.StorageVolInfo{Capacity: v.capacity}, nil
|
|
}
|
|
|
|
func TestValidateSingleWritableRootRejectsAdditionalDataDisk(t *testing.T) {
|
|
root := libvirtxml.DomainDisk{
|
|
Device: "disk", Target: &libvirtxml.DomainDiskTarget{Dev: "vda"},
|
|
}
|
|
seed := libvirtxml.DomainDisk{
|
|
Device: "cdrom", Target: &libvirtxml.DomainDiskTarget{Dev: "sda"},
|
|
ReadOnly: &libvirtxml.DomainDiskReadOnly{},
|
|
}
|
|
domain := &libvirtxml.Domain{Devices: &libvirtxml.DomainDeviceList{Disks: []libvirtxml.DomainDisk{root, seed}}}
|
|
if err := validateSingleWritableRoot(domain); err != nil {
|
|
t.Fatalf("one root plus read-only seed rejected: %v", err)
|
|
}
|
|
domain.Devices.Disks = append(domain.Devices.Disks, libvirtxml.DomainDisk{
|
|
Device: "disk", Target: &libvirtxml.DomainDiskTarget{Dev: "vdb"},
|
|
})
|
|
if err := validateSingleWritableRoot(domain); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("extra writable disk error = %v", err)
|
|
}
|
|
domain.Devices.Disks = []libvirtxml.DomainDisk{root, {
|
|
Device: "lun", Target: &libvirtxml.DomainDiskTarget{Dev: "sdb"},
|
|
}}
|
|
if err := validateSingleWritableRoot(domain); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("extra writable LUN error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateLiveBackupDefinitionRejectsLiveOnlyDiskTopology(t *testing.T) {
|
|
const managedPath = "/var/lib/virt-cloud/managed/root.qcow2"
|
|
root := libvirtxml.DomainDisk{
|
|
Device: "disk", Driver: &libvirtxml.DomainDiskDriver{Type: "qcow2"},
|
|
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: managedPath}},
|
|
Target: &libvirtxml.DomainDiskTarget{Dev: "vda"},
|
|
}
|
|
domain := &libvirtxml.Domain{Devices: &libvirtxml.DomainDeviceList{Disks: []libvirtxml.DomainDisk{root}}}
|
|
if err := validateLiveBackupDefinition(domain, managedPath); err != nil {
|
|
t.Fatalf("matching live root rejected: %v", err)
|
|
}
|
|
domain.Devices.Disks[0].BackingStore = &libvirtxml.DomainDiskBackingStore{}
|
|
if err := validateLiveBackupDefinition(domain, managedPath); err != nil {
|
|
t.Fatalf("empty libvirt backing-store sentinel rejected: %v", err)
|
|
}
|
|
domain.Devices.Disks[0].BackingStore = nil
|
|
|
|
domain.Devices.Disks = append(domain.Devices.Disks, libvirtxml.DomainDisk{
|
|
Device: "disk", Target: &libvirtxml.DomainDiskTarget{Dev: "vdb"},
|
|
})
|
|
if err := validateLiveBackupDefinition(domain, managedPath); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("live-only writable disk error = %v", err)
|
|
}
|
|
|
|
domain.Devices.Disks = []libvirtxml.DomainDisk{root}
|
|
domain.Devices.Disks[0].Source.File.File = "/var/lib/virt-cloud/managed/pivoted.qcow2"
|
|
if err := validateLiveBackupDefinition(domain, managedPath); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("live pivoted root error = %v", err)
|
|
}
|
|
|
|
domain.Devices.Disks = []libvirtxml.DomainDisk{root}
|
|
domain.Devices.Disks[0].BackingStore = &libvirtxml.DomainDiskBackingStore{
|
|
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: "/external/base.qcow2"}},
|
|
}
|
|
if err := validateLiveBackupDefinition(domain, managedPath); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("live backing chain error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateLiveBackupDefinitionAcceptsSerializedEmptyBackingStoreSentinel(t *testing.T) {
|
|
const managedPath = "/var/lib/virt-cloud/managed/root.qcow2"
|
|
var domain libvirtxml.Domain
|
|
if err := domain.Unmarshal(`<domain><devices>
|
|
<disk type='file' device='disk'>
|
|
<driver name='qemu' type='qcow2'/>
|
|
<source file='` + managedPath + `' index='2'/>
|
|
<backingStore/>
|
|
<target dev='vda' bus='virtio'/>
|
|
</disk>
|
|
</devices></domain>`); err != nil {
|
|
t.Fatalf("unmarshal live libvirt XML: %v", err)
|
|
}
|
|
if err := validateLiveBackupDefinition(&domain, managedPath); err != nil {
|
|
t.Fatalf("serialized empty libvirt backing-store sentinel rejected: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateStandaloneQCOW2RejectsBackingChain(t *testing.T) {
|
|
const capacity = 40 << 30
|
|
standalone := backupVolumeInspector{
|
|
capacity: capacity,
|
|
document: `<volume><name>root.qcow2</name><capacity unit="bytes">42949672960</capacity><target><format type="qcow2"/></target></volume>`,
|
|
}
|
|
if _, err := validateStandaloneQCOW2Volume(standalone, capacity); err != nil {
|
|
t.Fatalf("standalone qcow2 rejected: %v", err)
|
|
}
|
|
standalone.document = `<volume><name>root.qcow2</name><capacity unit="bytes">42949672960</capacity><target><format type="qcow2"/></target><backingStore><path>/template/base.qcow2</path><format type="qcow2"/></backingStore></volume>`
|
|
if _, err := validateStandaloneQCOW2Volume(standalone, capacity); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("backing-chain error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateBackupTransitionStateAllowsCompletedDiskTransitions(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
metadata *domainMetadataXML
|
|
wantError bool
|
|
}{
|
|
{
|
|
name: "reinstall cleanup pending",
|
|
metadata: &domainMetadataXML{
|
|
PendingCleanupVolume: "123e4567-e89b-42d3-a456-426614174000-root.qcow2",
|
|
DiskTransitionKind: "reinstall",
|
|
DiskTransitionID: "operation-reinstall-one",
|
|
},
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "completed reinstall marker",
|
|
metadata: &domainMetadataXML{
|
|
DiskTransitionKind: "reinstall",
|
|
DiskTransitionID: "operation-reinstall-one",
|
|
},
|
|
},
|
|
{
|
|
name: "completed snapshot restore marker",
|
|
metadata: &domainMetadataXML{
|
|
DiskTransitionKind: "snapshot_restore",
|
|
DiskTransitionID: "operation-snapshot-restore-one",
|
|
},
|
|
},
|
|
{name: "no transition", metadata: &domainMetadataXML{}},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
err := validateBackupTransitionState(test.metadata)
|
|
if test.wantError && !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("pending transition error = %v", err)
|
|
}
|
|
if !test.wantError && err != nil {
|
|
t.Fatalf("completed transition marker rejected: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAbortRejectedBackupPlanPreservesPreflightCause(t *testing.T) {
|
|
rejected := NewError(ErrConflict, "backup_disk_transition_active",
|
|
"VM backup is unavailable during a disk transition", nil)
|
|
called := false
|
|
err := abortRejectedBackupPlan(
|
|
context.Background(),
|
|
func(context.Context, objecttransfer.MultipartPlan) error {
|
|
called = true
|
|
return nil
|
|
},
|
|
objecttransfer.MultipartPlan{},
|
|
rejected,
|
|
)
|
|
if !called || !errors.Is(err, rejected) {
|
|
t.Fatalf("called=%v err=%v", called, err)
|
|
}
|
|
}
|
|
|
|
func TestAbortRejectedBackupPlanSeparatesAbortFailureCause(t *testing.T) {
|
|
rejected := NewError(ErrConflict, "backup_disk_transition_active",
|
|
"VM backup is unavailable during a disk transition", nil)
|
|
abortFailure := errors.New("multipart abort failed")
|
|
err := abortRejectedBackupPlan(
|
|
context.Background(),
|
|
func(context.Context, objecttransfer.MultipartPlan) error {
|
|
return abortFailure
|
|
},
|
|
objecttransfer.MultipartPlan{},
|
|
rejected,
|
|
)
|
|
var public interface{ PublicCode() string }
|
|
var semantics interface{ FailureSemantics() (bool, bool) }
|
|
if !errors.As(err, &semantics) {
|
|
t.Fatalf("abort failure has no explicit semantics: %v", err)
|
|
}
|
|
mayHaveApplied, safeToResubmit := semantics.FailureSemantics()
|
|
if !operation.IsNotApplied(err) || !errors.As(err, &public) ||
|
|
public.PublicCode() != "backup_upload_abort_failed" ||
|
|
operation.IsUncertain(err) || mayHaveApplied || !safeToResubmit ||
|
|
!errors.Is(err, rejected) || !errors.Is(err, abortFailure) {
|
|
t.Fatalf("unexpected abort failure classification: %v", err)
|
|
}
|
|
}
|