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.
virt/agent/hypervisor/backup_test.go

215 lines
8.1 KiB
Go

package hypervisor
import (
"context"
"errors"
"strings"
"testing"
"time"
"git.luoli.live/root/virt/agent/objecttransfer"
"git.luoli.live/root/virt/agent/operation"
)
const testBackupKey = "0123456789abcdef0123456789abcdef"
func validBackupRequest() BackupRequest {
return BackupRequest{
OperationID: "backup-operation-1", BackupKey: testBackupKey,
Name: "portable backup", ConsistencyMode: "filesystem",
ObjectUpload: objecttransfer.MultipartPlan{
PartSizeBytes: 5 << 20,
PartURLs: []string{
"https://objects.example.test/backups/object?partNumber=1&uploadId=secret",
"https://objects.example.test/backups/object?partNumber=2&uploadId=secret",
},
CompleteURL: "https://objects.example.test/backups/object?uploadId=secret",
AbortURL: "https://objects.example.test/backups/object?uploadId=secret",
VerifyURL: "https://objects.example.test/backups/object?signature=secret",
MaximumSizeBytes: 10 << 20,
},
}
}
func TestBackupUploadFailureSemanticsRequireConfirmedLocalRollback(t *testing.T) {
transferErr := NewError(ErrUnavailable, "upload_part_failed", "backup upload part failed", nil)
deterministic := classifyBackupUploadFailure(transferErr, nil)
var semantics interface{ FailureSemantics() (bool, bool) }
if !errors.As(deterministic, &semantics) {
t.Fatalf("confirmed rollback has no explicit failure semantics: %v", deterministic)
}
effect, safe := semantics.FailureSemantics()
if effect || !safe || operation.IsUncertain(deterministic) {
t.Fatalf("confirmed rollback semantics effect=%v safe=%v err=%v", effect, safe, deterministic)
}
uncertain := classifyBackupUploadFailure(transferErr, errors.New("snapshot cleanup failed"))
if !operation.IsUncertain(uncertain) {
t.Fatalf("failed local rollback was not fenced as uncertain: %v", uncertain)
}
}
func TestBackupLocalCleanupOutlivesCancelledTransferContext(t *testing.T) {
parent, cancelParent := context.WithCancel(context.Background())
cancelParent()
cleanup, cancelCleanup := backupLocalCleanupContext(parent)
defer cancelCleanup()
if err := cleanup.Err(); err != nil {
t.Fatalf("local cleanup inherited transfer cancellation: %v", err)
}
deadline, ok := cleanup.Deadline()
if !ok {
t.Fatal("local cleanup is not bounded")
}
remaining := time.Until(deadline)
if remaining <= 0 || remaining > backupLocalCleanupTimeout {
t.Fatalf("local cleanup deadline remaining = %s", remaining)
}
}
func validRestoreBackupRequest(t *testing.T) RestoreBackupRequest {
create := validIntentCreateRequest(t)
create.Source = ""
create.TemplateID = ""
create.TemplateRevision = 0
create.TemplateGenerationToken = ""
create.RootPassword = ""
create.GuestSSHPublicKey = ""
create.StartupScript = ""
create.OperationID = "restore-operation-1"
debian12NetworkFix := true
return RestoreBackupRequest{
CreateVMRequest: create, BackupKey: testBackupKey,
SourceURL: "https://objects.example.test/backups/object?signature=secret",
SourceSizeBytes: 4 << 20,
SourceSHA256: strings.Repeat("a", 64),
Debian12NetworkFix: &debian12NetworkFix,
}
}
func TestValidateBackupRequestChecksCapabilityBeforeDispatch(t *testing.T) {
request := validBackupRequest()
if err := ValidateBackupRequest(request); err != nil {
t.Fatalf("valid backup rejected: %v", err)
}
request.ObjectUpload.PartURLs[0] = "http://objects.example.test/unsafe"
if err := ValidateBackupRequest(request); err == nil {
t.Fatal("plain-HTTP upload capability was accepted")
}
}
func TestBackupWorkspaceIdentityAndCleanupRequestAreBound(t *testing.T) {
const uuid = "123e4567-e89b-42d3-a456-426614174000"
name := backupWorkspaceVolumeName(uuid, testBackupKey)
if name == snapshotVolumeName(uuid, testBackupKey) ||
!isVMOwnedManagedVolumeName(uuid, name) {
t.Fatalf("backup workspace identity was not isolated: %q", name)
}
request := CleanupBackupWorkspaceRequest{
OperationID: "operation-backup-cleanup-2",
PriorOperationID: "operation-backup-create-1",
CleanupPlanID: strings.Repeat("a", 64),
}
if err := ValidateCleanupBackupWorkspaceRequest(request); err != nil {
t.Fatalf("valid workspace cleanup rejected: %v", err)
}
request.OperationID = request.PriorOperationID
if err := ValidateCleanupBackupWorkspaceRequest(request); err == nil {
t.Fatal("cleanup accepted the original operation id as its successor")
}
}
func TestValidateRestoreBackupReusesCreateIntentWithoutReplacingCredentials(t *testing.T) {
request := validRestoreBackupRequest(t)
if err := ValidateRestoreBackupRequest(request); err != nil {
t.Fatalf("valid backup restore rejected: %v", err)
}
request.RootPassword = "Replacement1!Password"
if err := ValidateRestoreBackupRequest(request); err == nil {
t.Fatal("backup restore accepted replacement credentials")
}
request = validRestoreBackupRequest(t)
request.Hostname = "replacement.example.com"
if err := ValidateRestoreBackupRequest(request); err == nil {
t.Fatal("backup restore accepted a replacement hostname")
}
request = validRestoreBackupRequest(t)
request.DiskGiB = 0
if err := ValidateRestoreBackupRequest(request); err == nil {
t.Fatal("backup restore accepted invalid target disk size")
}
request = validRestoreBackupRequest(t)
request.Debian12NetworkFix = nil
if err := ValidateRestoreBackupRequest(request); err == nil {
t.Fatal("backup restore accepted missing Debian 12 network compatibility metadata")
}
}
func TestValidateRecoverBackupAcceptsOnlyBoundImmutableObject(t *testing.T) {
request := RecoverBackupRequest{
OperationID: "operation-recover-backup", BackupKey: testBackupKey,
SourceURL: "https://objects.example.test/backups/object?signature=secret",
SourceSizeBytes: 4 << 20, SourceSHA256: strings.Repeat("b", 64),
}
if err := ValidateRecoverBackupRequest(request); err != nil {
t.Fatalf("valid backup recovery rejected: %v", err)
}
request.SourceURL = "http://objects.example.test/unsafe"
if err := ValidateRecoverBackupRequest(request); err == nil {
t.Fatal("backup recovery accepted a plain-HTTP object capability")
}
}
func TestBackupAdmissionsFenceSourceAndNewVMArtifacts(t *testing.T) {
const uuid = "123e4567-e89b-42d3-a456-426614174000"
backupRequest := validBackupRequest()
backup := CreateBackupAdmission(uuid, backupRequest)
for _, key := range []string{
domainLockKey(uuid), vmManagedVolumesLockKey(uuid),
volumeLockKey(managedStoragePoolName, backupWorkspaceVolumeName(uuid, backupRequest.BackupKey)),
catalogLockKey("backup", backupRequest.BackupKey),
} {
if !containsString(backup.LockKeys, key) || !backup.HeavyIO {
t.Fatalf("backup admission missing %q: %#v", key, backup)
}
}
cleanup := CleanupBackupWorkspaceAdmission(uuid, backupRequest.BackupKey)
for _, key := range []string{
domainLockKey(uuid), vmManagedVolumesLockKey(uuid),
volumeLockKey(managedStoragePoolName,
backupWorkspaceVolumeName(uuid, backupRequest.BackupKey)),
volumeLockKey(managedStoragePoolName,
snapshotVolumeName(uuid, backupRequest.BackupKey)),
catalogLockKey("backup", backupRequest.BackupKey),
} {
if !containsString(cleanup.LockKeys, key) || !cleanup.HeavyIO {
t.Fatalf("cleanup admission missing %q: %#v", key, cleanup)
}
}
restore := RestoreBackupAdmission(validRestoreBackupRequest(t))
for _, key := range []string{
domainLockKey(uuid), vmManagedVolumesLockKey(uuid),
volumeLockKey(managedStoragePoolName, rootVolumeName(uuid)),
volumeLockKey(seedStoragePoolName, seedVolumeName(uuid)),
nwfilterLockKey(networkFilterName(uuid)),
} {
if !containsString(restore.LockKeys, key) || !restore.HeavyIO {
t.Fatalf("restore admission missing %q: %#v", key, restore)
}
}
recoveryRequest := RecoverBackupRequest{
OperationID: "operation-recover-backup", BackupKey: testBackupKey,
}
recovery := RecoverBackupAdmission(uuid, recoveryRequest)
for _, key := range []string{
domainLockKey(uuid), vmManagedVolumesLockKey(uuid),
volumeLockKey(managedStoragePoolName,
snapshotRestoreVolumeName(uuid, recoveryRequest.OperationID)),
volumeLockKey(seedStoragePoolName, seedVolumeName(uuid)),
catalogLockKey("backup", recoveryRequest.BackupKey),
} {
if !containsString(recovery.LockKeys, key) || !recovery.HeavyIO {
t.Fatalf("recovery admission missing %q: %#v", key, recovery)
}
}
}