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) } } }