//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(` `); 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: `root.qcow242949672960`, } if _, err := validateStandaloneQCOW2Volume(standalone, capacity); err != nil { t.Fatalf("standalone qcow2 rejected: %v", err) } standalone.document = `root.qcow242949672960/template/base.qcow2` 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) } }