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.
215 lines
8.1 KiB
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)
|
|
}
|
|
}
|
|
}
|