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.
311 lines
13 KiB
Go
311 lines
13 KiB
Go
//go:build libvirt
|
|
|
|
package hypervisor
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"git.luoli.live/root/virt/agent/operation"
|
|
"libvirt.org/go/libvirt"
|
|
"libvirt.org/go/libvirtxml"
|
|
)
|
|
|
|
type resizeResourceValues struct {
|
|
VCPUs uint
|
|
MemoryMiB uint64
|
|
DiskGiB uint64
|
|
BandwidthMbps uint64
|
|
}
|
|
|
|
func resizeFromValues(request ResizeResourcesRequest) resizeResourceValues {
|
|
return resizeResourceValues{
|
|
VCPUs: request.FromVCPUs, MemoryMiB: request.FromMemoryMiB,
|
|
DiskGiB: request.FromDiskGiB, BandwidthMbps: request.FromBandwidthMbps,
|
|
}
|
|
}
|
|
|
|
func resizeTargetValues(request ResizeResourcesRequest) resizeResourceValues {
|
|
return resizeResourceValues{
|
|
VCPUs: request.TargetVCPUs, MemoryMiB: request.TargetMemoryMiB,
|
|
DiskGiB: request.TargetDiskGiB, BandwidthMbps: request.TargetBandwidthMbps,
|
|
}
|
|
}
|
|
|
|
func expectedResizeFromValues(expected *operation.ExpectedState) resizeResourceValues {
|
|
return resizeResourceValues{
|
|
VCPUs: expected.FromVCPUs, MemoryMiB: expected.FromMemoryMiB,
|
|
DiskGiB: expected.FromDiskGiB, BandwidthMbps: expected.FromBandwidthMbps,
|
|
}
|
|
}
|
|
|
|
func expectedResizeTargetValues(expected *operation.ExpectedState) resizeResourceValues {
|
|
return resizeResourceValues{
|
|
VCPUs: expected.TargetVCPUs, MemoryMiB: expected.TargetMemoryMiB,
|
|
DiskGiB: expected.TargetDiskGiB, BandwidthMbps: expected.TargetBandwidthMbps,
|
|
}
|
|
}
|
|
|
|
func (l *Libvirt) ResizeResources(ctx context.Context, uuid string, request ResizeResourcesRequest) (_ ResizeResourcesResult, resultErr error) {
|
|
mutationStarted := false
|
|
defer func() {
|
|
if !mutationStarted {
|
|
resultErr = operation.MarkNotApplied(resultErr)
|
|
}
|
|
}()
|
|
if err := ValidateResizeResources(request); err != nil {
|
|
return ResizeResourcesResult{}, err
|
|
}
|
|
expected, err := expectedMutationState(ctx, operation.ExpectedResizeResources)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, err
|
|
}
|
|
if !resizeRequestMatchesExpected(
|
|
request, expected.FromVCPUs, expected.TargetVCPUs,
|
|
expected.FromMemoryMiB, expected.TargetMemoryMiB,
|
|
expected.FromDiskGiB, expected.TargetDiskGiB,
|
|
expected.FromBandwidthMbps, expected.TargetBandwidthMbps,
|
|
) {
|
|
return ResizeResourcesResult{}, NewError(ErrConflict, "reconciliation_descriptor_mismatch", "resource resize request does not match its durable reconciliation descriptor", nil)
|
|
}
|
|
|
|
domain, err := l.domainByUUID(ctx, uuid)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, err
|
|
}
|
|
defer domain.Free()
|
|
active, err := domain.IsActive()
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, translateLibvirtError("check resource resize domain activity", err)
|
|
}
|
|
if active {
|
|
return ResizeResourcesResult{}, NewError(ErrConflict, "vm_must_be_shutoff", "virtual machine must be shut off before resizing resources", nil)
|
|
}
|
|
|
|
document, definition, metadata, pool, root, err := l.managedRootContext(domain)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, err
|
|
}
|
|
defer pool.Free()
|
|
defer root.Free()
|
|
if len(metadata.Snapshots) != 0 {
|
|
return ResizeResourcesResult{}, NewError(ErrConflict, "snapshots_present", "resource resize is blocked while managed snapshots exist", nil)
|
|
}
|
|
if metadata.PendingCleanupVolume != "" {
|
|
return ResizeResourcesResult{}, NewError(ErrConflict, "disk_cleanup_pending", "resource resize is blocked while system disk cleanup is pending", nil)
|
|
}
|
|
if metadata.RescueTemplateID != "" {
|
|
return ResizeResourcesResult{}, NewError(ErrConflict, "rescue_active", "resource resize is blocked while rescue boot is staged or active", nil)
|
|
}
|
|
rootInfo, err := validateQCOW2Volume(root, request.FromDiskGiB*gib)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, err
|
|
}
|
|
if !managedDefinitionMatchesResources(definition, metadata, rootInfo.Capacity, resizeFromValues(request)) {
|
|
return ResizeResourcesResult{}, NewError(ErrConflict, "resource_state_changed", "host resources no longer match the requested source values", nil)
|
|
}
|
|
autostart, err := domain.GetAutostart()
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, translateLibvirtError("read resource resize domain autostart", err)
|
|
}
|
|
updatedXML, err := resizeManagedDomainDocument(document, resizeTargetValues(request), expected.TransitionID)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, err
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return ResizeResourcesResult{}, err
|
|
}
|
|
active, err = domain.IsActive()
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, translateLibvirtError("recheck resource resize domain activity", err)
|
|
}
|
|
if active {
|
|
return ResizeResourcesResult{}, NewError(ErrConflict, "vm_must_be_shutoff", "virtual machine must remain shut off before resizing resources", nil)
|
|
}
|
|
|
|
if request.TargetDiskGiB > request.FromDiskGiB {
|
|
mutationStarted = true
|
|
if err := root.Resize(request.TargetDiskGiB*gib, 0); err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(mutationLibvirtError("grow managed system disk", err))
|
|
}
|
|
if _, err := validateQCOW2Volume(root, request.TargetDiskGiB*gib); err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(err)
|
|
}
|
|
}
|
|
|
|
mutationStarted = true
|
|
defined, err := l.conn.DomainDefineXML(updatedXML)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(mutationLibvirtError("persist resized VM resources", err))
|
|
}
|
|
defer defined.Free()
|
|
if err := defined.SetAutostart(autostart); err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(mutationLibvirtError("preserve resized domain autostart", err))
|
|
}
|
|
observedXML, observedMetadata, err := requireManagedDomain(defined)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(err)
|
|
}
|
|
observedDefinition, _, err := parseManagedDomain(observedXML)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(err)
|
|
}
|
|
observedRootInfo, err := validateQCOW2Volume(root, request.TargetDiskGiB*gib)
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(err)
|
|
}
|
|
if observedMetadata.ResourcesTransitionID != expected.TransitionID ||
|
|
!managedDefinitionMatchesResources(observedDefinition, observedMetadata, observedRootInfo.Capacity, resizeTargetValues(request)) {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(NewError(ErrConflict, "resource_resize_observation_failed", "resized resources did not expose the committed transition", nil))
|
|
}
|
|
active, err = defined.IsActive()
|
|
if err != nil {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(translateLibvirtError("verify resized domain activity", err))
|
|
}
|
|
if active {
|
|
return ResizeResourcesResult{}, operation.MarkUncertain(NewError(ErrConflict, "vm_state_changed", "virtual machine became active during the stopped resource resize", nil))
|
|
}
|
|
return resizeResourcesResult(uuid, expected, VMStateShutoff), nil
|
|
}
|
|
|
|
func resizeManagedDomainDocument(document string, target resizeResourceValues, transitionID string) (string, error) {
|
|
return mutateDomainDocument(document, func(definition *libvirtxml.Domain, metadata *domainMetadataXML) error {
|
|
if definition.VCPU == nil || definition.Memory == nil || definition.Devices == nil || len(definition.Devices.Interfaces) != 1 {
|
|
return NewError(ErrConflict, "resource_layout_changed", "managed VM resource definition is incomplete", nil)
|
|
}
|
|
if definition.VCPUs != nil || definition.MaximumMemory != nil ||
|
|
(definition.CPU != nil && definition.CPU.Topology != nil) {
|
|
return NewError(ErrConflict, "resource_layout_changed", "managed VM resource layout does not support stopped resize", nil)
|
|
}
|
|
definition.VCPU.Value = target.VCPUs
|
|
if definition.VCPU.Current != 0 {
|
|
definition.VCPU.Current = target.VCPUs
|
|
}
|
|
definition.Memory.Value = uint(target.MemoryMiB)
|
|
definition.Memory.Unit = "MiB"
|
|
if definition.CurrentMemory != nil {
|
|
definition.CurrentMemory.Value = uint(target.MemoryMiB)
|
|
definition.CurrentMemory.Unit = "MiB"
|
|
}
|
|
setDomainInterfaceBandwidth(definition, target.BandwidthMbps)
|
|
metadata.DiskGiB = target.DiskGiB
|
|
metadata.BandwidthMbps = target.BandwidthMbps
|
|
metadata.ResourcesTransitionID = transitionID
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func managedDefinitionMatchesResources(definition *libvirtxml.Domain, metadata *domainMetadataXML, rootCapacity uint64, values resizeResourceValues) bool {
|
|
if definition == nil || metadata == nil || definition.VCPU == nil || definition.Memory == nil ||
|
|
definition.Devices == nil || len(definition.Devices.Interfaces) != 1 ||
|
|
definition.VCPUs != nil || definition.MaximumMemory != nil ||
|
|
(definition.CPU != nil && definition.CPU.Topology != nil) {
|
|
return false
|
|
}
|
|
if definition.VCPU.Value != values.VCPUs ||
|
|
(definition.VCPU.Current != 0 && definition.VCPU.Current != values.VCPUs) ||
|
|
!memoryValueMatchesMiB(definition.Memory.Value, definition.Memory.Unit, values.MemoryMiB) ||
|
|
(definition.CurrentMemory != nil && !memoryValueMatchesMiB(
|
|
definition.CurrentMemory.Value, definition.CurrentMemory.Unit, values.MemoryMiB,
|
|
)) {
|
|
return false
|
|
}
|
|
return rootCapacity == values.DiskGiB*gib && metadata.DiskGiB == values.DiskGiB &&
|
|
metadata.BandwidthMbps == values.BandwidthMbps &&
|
|
domainInterfaceBandwidthMatches(definition, values.BandwidthMbps)
|
|
}
|
|
|
|
func memoryValueMatchesMiB(value uint, unit string, expected uint64) bool {
|
|
switch strings.ToLower(unit) {
|
|
case "b", "bytes":
|
|
return uint64(value) == expected*1024*1024
|
|
case "kb", "kib", "":
|
|
return uint64(value) == expected*1024
|
|
case "mb", "mib":
|
|
return uint64(value) == expected
|
|
case "gb", "gib":
|
|
return uint64(value)*1024 == expected
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func setDomainInterfaceBandwidth(definition *libvirtxml.Domain, bandwidthMbps uint64) {
|
|
rate := bandwidthRateKiBPerSecond(bandwidthMbps)
|
|
for index := range definition.Devices.Interfaces {
|
|
definition.Devices.Interfaces[index].Bandwidth = &libvirtxml.DomainInterfaceBandwidth{
|
|
Inbound: &libvirtxml.DomainInterfaceBandwidthParams{Average: &rate, Peak: &rate},
|
|
Outbound: &libvirtxml.DomainInterfaceBandwidthParams{Average: &rate, Peak: &rate},
|
|
}
|
|
}
|
|
}
|
|
|
|
func domainInterfaceBandwidthMatches(definition *libvirtxml.Domain, bandwidthMbps uint64) bool {
|
|
if definition == nil || definition.Devices == nil || len(definition.Devices.Interfaces) == 0 {
|
|
return false
|
|
}
|
|
rate := bandwidthRateKiBPerSecond(bandwidthMbps)
|
|
for _, iface := range definition.Devices.Interfaces {
|
|
bandwidth := iface.Bandwidth
|
|
if bandwidth == nil || bandwidth.Inbound == nil || bandwidth.Outbound == nil ||
|
|
bandwidth.Inbound.Average == nil || bandwidth.Inbound.Peak == nil ||
|
|
bandwidth.Outbound.Average == nil || bandwidth.Outbound.Peak == nil ||
|
|
*bandwidth.Inbound.Average != rate || *bandwidth.Inbound.Peak != rate ||
|
|
*bandwidth.Outbound.Average != rate || *bandwidth.Outbound.Peak != rate {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func bandwidthRateKiBPerSecond(bandwidthMbps uint64) int {
|
|
return int((bandwidthMbps*1_000_000 + 8191) / 8192)
|
|
}
|
|
|
|
func resizeResourcesResult(uuid string, expected operation.ExpectedState, status VMStateName) ResizeResourcesResult {
|
|
return ResizeResourcesResult{
|
|
UUID: uuid,
|
|
FromVCPUs: expected.FromVCPUs, TargetVCPUs: expected.TargetVCPUs, AppliedVCPUs: expected.TargetVCPUs,
|
|
FromMemoryMiB: expected.FromMemoryMiB, TargetMemoryMiB: expected.TargetMemoryMiB, AppliedMemoryMiB: expected.TargetMemoryMiB,
|
|
FromDiskGiB: expected.FromDiskGiB, TargetDiskGiB: expected.TargetDiskGiB, AppliedDiskGiB: expected.TargetDiskGiB,
|
|
FromBandwidthMbps: expected.FromBandwidthMbps, TargetBandwidthMbps: expected.TargetBandwidthMbps, AppliedBandwidthMbps: expected.TargetBandwidthMbps,
|
|
Status: status, ResourcesResized: true,
|
|
}
|
|
}
|
|
|
|
func reconcileResizeObservation(expected *operation.ExpectedState, marker string, definition *libvirtxml.Domain,
|
|
metadata *domainMetadataXML, rootCapacity uint64) operation.Resolution {
|
|
targetMatches := managedDefinitionMatchesResources(definition, metadata, rootCapacity, expectedResizeTargetValues(expected))
|
|
if marker == expected.TransitionID && targetMatches {
|
|
return operation.Resolution{Resolved: true, Succeeded: true}
|
|
}
|
|
fromMatches := managedDefinitionMatchesResources(definition, metadata, rootCapacity, expectedResizeFromValues(expected))
|
|
if marker != expected.TransitionID && fromMatches {
|
|
return resolvedExpectedFailure("resources_not_committed", "host evidence confirms the resource resize did not commit")
|
|
}
|
|
return resolvedExpectedFailure("resources_partially_resized", "host evidence shows a partial or conflicting resource resize")
|
|
}
|
|
|
|
func (l *Libvirt) reconcileResizeResources(record operation.Record, domain *libvirt.Domain) (operation.Resolution, error) {
|
|
_, definition, metadata, pool, root, err := l.managedRootContext(domain)
|
|
if err != nil {
|
|
return expectedEvidenceError("resources", err)
|
|
}
|
|
defer pool.Free()
|
|
defer root.Free()
|
|
rootInfo, err := validateQCOW2Volume(root, 0)
|
|
if err != nil {
|
|
return expectedEvidenceError("resources", err)
|
|
}
|
|
classification := reconcileResizeObservation(record.ExpectedState, metadata.ResourcesTransitionID, definition, metadata, rootInfo.Capacity)
|
|
if !classification.Resolved || !classification.Succeeded {
|
|
return classification, nil
|
|
}
|
|
state, _, err := domain.GetState()
|
|
if err != nil {
|
|
return operation.Resolution{}, translateLibvirtError("reconcile resized domain state", err)
|
|
}
|
|
result := resizeResourcesResult(record.ResourceID, *record.ExpectedState, mapDomainState(state))
|
|
return resolvedExpectedSuccess(result)
|
|
}
|