fix(agent): boot rescue ISO before seed media

go
codex 4 weeks ago
parent 16f0a541c2
commit 5a01ef25da

@ -782,12 +782,9 @@ func (l *Libvirt) EnterRescue(ctx context.Context, uuid string, request RescueRe
if definition.OS == nil || definition.Devices == nil {
return NewError(ErrConflict, "invalid_domain", "managed domain XML is incomplete", nil)
}
definition.OS.BootDevices = []libvirtxml.DomainBootDevice{{Dev: "cdrom"}, {Dev: "hd"}}
definition.Devices.Disks = append(definition.Devices.Disks, libvirtxml.DomainDisk{
Device: "cdrom", Driver: &libvirtxml.DomainDiskDriver{Name: "qemu", Type: "raw"},
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: path}},
Target: &libvirtxml.DomainDiskTarget{Dev: "sdb", Bus: "sata"}, ReadOnly: &libvirtxml.DomainDiskReadOnly{},
})
if err := stageRescueBoot(definition, path); err != nil {
return err
}
metadata.RescueTemplateID = request.TemplateID
metadata.RescueWasRunning = wasRunning
metadata.RescueAutostart = autostart
@ -951,15 +948,7 @@ func (l *Libvirt) ExitRescue(ctx context.Context, uuid string, request ExitRescu
if definition.OS == nil || definition.Devices == nil {
return NewError(ErrConflict, "invalid_domain", "managed domain XML is incomplete", nil)
}
definition.OS.BootDevices = []libvirtxml.DomainBootDevice{{Dev: "hd"}}
disks := definition.Devices.Disks[:0]
for _, disk := range definition.Devices.Disks {
if disk.Device == "cdrom" && disk.Target != nil && disk.Target.Dev == "sdb" {
continue
}
disks = append(disks, disk)
}
definition.Devices.Disks = disks
restoreNormalBoot(definition)
linkState := "up"
if *request.NetworkSuspended {
linkState = "down"
@ -1095,25 +1084,100 @@ func validateRescueDefinition(document, templateID, expectedPath string) error {
if err != nil {
return err
}
if metadata.RescueTemplateID != templateID || definition.OS == nil || len(definition.OS.BootDevices) != 2 || definition.OS.BootDevices[0].Dev != "cdrom" || definition.OS.BootDevices[1].Dev != "hd" || definition.Devices == nil {
if metadata.RescueTemplateID != templateID || definition.OS == nil || definition.Devices == nil {
return NewError(ErrConflict, "rescue_definition_invalid", "rescue boot metadata or order is invalid", nil)
}
legacyBootOrder := len(definition.OS.BootDevices) == 2 && definition.OS.BootDevices[0].Dev == "cdrom" && definition.OS.BootDevices[1].Dev == "hd"
deviceBootOrder := len(definition.OS.BootDevices) == 0
if !legacyBootOrder && !deviceBootOrder {
return NewError(ErrConflict, "rescue_definition_invalid", "rescue boot metadata or order is invalid", nil)
}
matches := 0
rescueMatches := 0
rootMatches := 0
bootDevices := 0
for _, disk := range definition.Devices.Disks {
if disk.Device != "cdrom" || disk.Target == nil || disk.Target.Dev != "sdb" {
if disk.Boot != nil {
bootDevices++
}
if disk.Device == "disk" && disk.Target != nil && disk.Target.Dev == "vda" {
if deviceBootOrder && (disk.Boot == nil || disk.Boot.Order != 2) {
return NewError(ErrConflict, "rescue_definition_invalid", "managed root disk is not the rescue fallback boot device", nil)
}
if legacyBootOrder && disk.Boot != nil {
return NewError(ErrConflict, "rescue_definition_invalid", "legacy rescue boot mixes global and per-device order", nil)
}
rootMatches++
continue
}
if disk.Device == "cdrom" && disk.Target != nil && disk.Target.Dev == "sdb" {
if deviceBootOrder && (disk.Boot == nil || disk.Boot.Order != 1) {
return NewError(ErrConflict, "rescue_definition_invalid", "managed rescue disk is not the first boot device", nil)
}
if legacyBootOrder && disk.Boot != nil {
return NewError(ErrConflict, "rescue_definition_invalid", "legacy rescue boot mixes global and per-device order", nil)
}
if disk.Driver == nil || disk.Driver.Type != "raw" || disk.Source == nil || disk.Source.File == nil || filepath.Clean(disk.Source.File.File) != filepath.Clean(expectedPath) || disk.ReadOnly == nil {
return NewError(ErrConflict, "rescue_definition_invalid", "rescue boot disk does not match the managed template", nil)
}
rescueMatches++
continue
}
if disk.Driver == nil || disk.Driver.Type != "raw" || disk.Source == nil || disk.Source.File == nil || filepath.Clean(disk.Source.File.File) != filepath.Clean(expectedPath) || disk.ReadOnly == nil {
return NewError(ErrConflict, "rescue_definition_invalid", "rescue boot disk does not match the managed template", nil)
if disk.Boot != nil {
return NewError(ErrConflict, "rescue_definition_invalid", "an unmanaged disk participates in rescue boot order", nil)
}
matches++
}
if matches != 1 {
return NewError(ErrConflict, "rescue_definition_invalid", "rescue boot must contain exactly one managed rescue disk", nil)
expectedBootDevices := 2
if legacyBootOrder {
expectedBootDevices = 0
}
if rescueMatches != 1 || rootMatches != 1 || bootDevices != expectedBootDevices {
return NewError(ErrConflict, "rescue_definition_invalid", "rescue boot must contain exactly one rescue disk and one managed root fallback", nil)
}
return nil
}
func stageRescueBoot(definition *libvirtxml.Domain, path string) error {
definition.OS.BootDevices = nil
rootIndex := -1
for index := range definition.Devices.Disks {
disk := &definition.Devices.Disks[index]
disk.Boot = nil
if disk.Device == "disk" && disk.Target != nil && disk.Target.Dev == "vda" {
if rootIndex >= 0 {
return NewError(ErrConflict, "invalid_domain", "managed domain contains multiple root disks", nil)
}
rootIndex = index
}
if disk.Device == "cdrom" && disk.Target != nil && disk.Target.Dev == "sdb" {
return NewError(ErrConflict, "invalid_domain", "managed rescue disk target is already in use", nil)
}
}
if rootIndex < 0 {
return NewError(ErrConflict, "invalid_domain", "managed root disk is missing", nil)
}
definition.Devices.Disks[rootIndex].Boot = &libvirtxml.DomainDeviceBoot{Order: 2}
definition.Devices.Disks = append(definition.Devices.Disks, libvirtxml.DomainDisk{
Device: "cdrom", Driver: &libvirtxml.DomainDiskDriver{Name: "qemu", Type: "raw"},
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: path}},
Target: &libvirtxml.DomainDiskTarget{Dev: "sdb", Bus: "sata"}, ReadOnly: &libvirtxml.DomainDiskReadOnly{},
Boot: &libvirtxml.DomainDeviceBoot{Order: 1},
})
return nil
}
func restoreNormalBoot(definition *libvirtxml.Domain) {
definition.OS.BootDevices = []libvirtxml.DomainBootDevice{{Dev: "hd"}}
disks := definition.Devices.Disks[:0]
for _, disk := range definition.Devices.Disks {
if disk.Device == "cdrom" && disk.Target != nil && disk.Target.Dev == "sdb" {
continue
}
disk.Boot = nil
disks = append(disks, disk)
}
definition.Devices.Disks = disks
}
func definitionNetworkSuspended(definition *libvirtxml.Domain) bool {
if definition == nil || definition.Devices == nil || len(definition.Devices.Interfaces) == 0 {
return false

@ -1633,12 +1633,9 @@ func TestValidateRescueDefinitionRequiresManagedReadOnlyBootDisk(t *testing.T) {
templateID := "0123456789abcdef0123456789abcdef"
rescuePath := "/var/lib/libvirt/images/rescue-0123456789abcdef0123456789abcdef.iso"
staged, err := mutateDomainDocument(document, func(domain *libvirtxml.Domain, metadata *domainMetadataXML) error {
domain.OS.BootDevices = []libvirtxml.DomainBootDevice{{Dev: "cdrom"}, {Dev: "hd"}}
domain.Devices.Disks = append(domain.Devices.Disks, libvirtxml.DomainDisk{
Device: "cdrom", Driver: &libvirtxml.DomainDiskDriver{Name: "qemu", Type: "raw"},
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: rescuePath}},
Target: &libvirtxml.DomainDiskTarget{Dev: "sdb", Bus: "sata"}, ReadOnly: &libvirtxml.DomainDiskReadOnly{},
})
if err := stageRescueBoot(domain, rescuePath); err != nil {
return err
}
metadata.RescueTemplateID = templateID
return nil
})
@ -1651,6 +1648,63 @@ func TestValidateRescueDefinitionRequiresManagedReadOnlyBootDisk(t *testing.T) {
if err := validateRescueDefinition(staged, templateID, rescuePath+".foreign"); err == nil {
t.Fatal("foreign rescue volume path was accepted")
}
parsed, _, err := parseManagedDomain(staged)
if err != nil {
t.Fatal(err)
}
if len(parsed.OS.BootDevices) != 0 {
t.Fatalf("global boot order remains staged: %#v", parsed.OS.BootDevices)
}
for _, disk := range parsed.Devices.Disks {
if disk.Target == nil {
continue
}
switch disk.Target.Dev {
case "vda":
if disk.Boot == nil || disk.Boot.Order != 2 {
t.Fatalf("root disk boot order = %#v, want 2", disk.Boot)
}
case "sda":
if disk.Boot != nil {
t.Fatalf("seed ISO unexpectedly participates in rescue boot: %#v", disk.Boot)
}
case "sdb":
if disk.Boot == nil || disk.Boot.Order != 1 {
t.Fatalf("rescue ISO boot order = %#v, want 1", disk.Boot)
}
}
}
legacy, err := mutateDomainDocument(staged, func(domain *libvirtxml.Domain, _ *domainMetadataXML) error {
domain.OS.BootDevices = []libvirtxml.DomainBootDevice{{Dev: "cdrom"}, {Dev: "hd"}}
for index := range domain.Devices.Disks {
domain.Devices.Disks[index].Boot = nil
}
return nil
})
if err != nil {
t.Fatal(err)
}
if err := validateRescueDefinition(legacy, templateID, rescuePath); err != nil {
t.Fatalf("legacy rescue definition cannot be exited after upgrade: %v", err)
}
restored, _, err := parseManagedDomain(staged)
if err != nil {
t.Fatal(err)
}
restoreNormalBoot(restored)
if len(restored.OS.BootDevices) != 1 || restored.OS.BootDevices[0].Dev != "hd" {
t.Fatalf("normal global boot order = %#v, want hd", restored.OS.BootDevices)
}
for _, disk := range restored.Devices.Disks {
if disk.Boot != nil {
t.Fatalf("per-device boot order remained after rescue exit: %#v", disk.Boot)
}
if disk.Target != nil && disk.Target.Dev == "sdb" {
t.Fatal("managed rescue disk remained after rescue exit")
}
}
}
func TestCollectVMManagedVolumeNamesIncludesTransitionsSnapshotsAndOrphans(t *testing.T) {

Loading…
Cancel
Save