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.
205 lines
7.8 KiB
Go
205 lines
7.8 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"g.luoli.live/root/virt/agent/internal/capability"
|
|
"g.luoli.live/root/virt/agent/internal/config"
|
|
"g.luoli.live/root/virt/agent/internal/hypervisor"
|
|
"g.luoli.live/root/virt/agent/internal/operation"
|
|
)
|
|
|
|
const deleteTestUUID = "00000000-0000-4000-8000-000000000401"
|
|
|
|
func newDeleteTestServer(t *testing.T, backend hypervisor.Backend) (*Server, *operation.Store) {
|
|
t.Helper()
|
|
store := operation.NewMemory()
|
|
c := config.Defaults()
|
|
c.AgentID = "host-delete-test"
|
|
s, err := New(Options{
|
|
Config: c,
|
|
Store: store,
|
|
Capabilities: capability.BackendProvider{Backend: backend, AgentID: c.AgentID, ProtocolVersion: c.ProtocolVersion},
|
|
Backend: backend,
|
|
HostBackendReady: true,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return s, store
|
|
}
|
|
|
|
func defineDeleteTestDomain(t *testing.T, backend *hypervisor.FakeBackend) {
|
|
t.Helper()
|
|
if _, err := backend.DefineDomain(context.Background(), hypervisor.DefineRequest{
|
|
UUID: deleteTestUUID,
|
|
XML: []byte(`<domain><uuid>` + deleteTestUUID + `</uuid><os><type>hvm</type></os></domain>`),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func deleteOperationBody(id, key string) []byte {
|
|
return []byte(`{"operation_id":"` + id + `","idempotency_key":"` + key + `","kind":"domain_delete","target":"` + deleteTestUUID + `","payload":{"uuid":"` + deleteTestUUID + `"}}`)
|
|
}
|
|
|
|
func TestDomainDeleteUndefinesOnlyInactiveDefinitionAndJournalsReadback(t *testing.T) {
|
|
backend := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())
|
|
defineDeleteTestDomain(t, backend)
|
|
s, store := newDeleteTestServer(t, backend)
|
|
operationID := "00000000-0000-4000-8000-000000000402"
|
|
recorder := httptest.NewRecorder()
|
|
s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(
|
|
deleteOperationBody(operationID, "delete-operation-0402"),
|
|
)))
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
var record operation.Record
|
|
if err := json.Unmarshal(recorder.Body.Bytes(), &record); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if record.Status != operation.StatusSucceeded || record.CommitBoundary != "domain_delete_readback_confirmed" {
|
|
t.Fatalf("record=%+v", record)
|
|
}
|
|
var result hypervisor.DomainDeleteResult
|
|
if err := json.Unmarshal(record.Result, &result); err != nil {
|
|
t.Fatalf("decode result: %v raw=%s", err, record.Result)
|
|
}
|
|
if result.UUID != deleteTestUUID || !result.Existed || !result.Removed || result.AlreadyAbsent ||
|
|
result.StorageRemoved || result.NetworkChanged || result.XMLHash == "" {
|
|
t.Fatalf("result=%+v", result)
|
|
}
|
|
observation, err := backend.InspectDomainForDeletion(context.Background(), deleteTestUUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if observation.Present {
|
|
t.Fatalf("definition remains after successful delete: %+v", observation)
|
|
}
|
|
if _, err := store.Get(operationID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestDomainDeleteRejectsActiveDomainBeforeUndefine(t *testing.T) {
|
|
backend := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())
|
|
defineDeleteTestDomain(t, backend)
|
|
if _, err := backend.PowerDomain(context.Background(), deleteTestUUID, hypervisor.PowerActionStart); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s, store := newDeleteTestServer(t, backend)
|
|
operationID := "00000000-0000-4000-8000-000000000403"
|
|
recorder := httptest.NewRecorder()
|
|
s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(
|
|
deleteOperationBody(operationID, "delete-operation-0403"),
|
|
)))
|
|
if recorder.Code != http.StatusUnprocessableEntity {
|
|
t.Fatalf("status=%d body=%s; want 422", recorder.Code, recorder.Body.String())
|
|
}
|
|
record, err := store.Get(operationID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if record.Status != operation.StatusFailed || record.ErrorCode != "domain_delete_active" {
|
|
t.Fatalf("record=%+v", record)
|
|
}
|
|
observation, err := backend.InspectDomainForDeletion(context.Background(), deleteTestUUID)
|
|
if err != nil || !observation.Present || !observation.Active {
|
|
t.Fatalf("domain changed after active rejection: %+v err=%v", observation, err)
|
|
}
|
|
}
|
|
|
|
type deleteCountingBackend struct {
|
|
*hypervisor.FakeBackend
|
|
deleteCalls int
|
|
inspectCalls int
|
|
}
|
|
|
|
func (b *deleteCountingBackend) DeleteDomain(ctx context.Context, uuid string) (hypervisor.DomainDeleteResult, error) {
|
|
b.deleteCalls++
|
|
return b.FakeBackend.DeleteDomain(ctx, uuid)
|
|
}
|
|
|
|
func (b *deleteCountingBackend) InspectDomainForDeletion(ctx context.Context, uuid string) (hypervisor.DomainDeletionObservation, error) {
|
|
b.inspectCalls++
|
|
return b.FakeBackend.InspectDomainForDeletion(ctx, uuid)
|
|
}
|
|
|
|
func TestDomainDeleteReconcileReadsAbsenceWithoutReplayingUndefine(t *testing.T) {
|
|
base := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())
|
|
defineDeleteTestDomain(t, base)
|
|
backend := &deleteCountingBackend{FakeBackend: base}
|
|
store := operation.NewMemory()
|
|
const operationID = "00000000-0000-4000-8000-000000000404"
|
|
payload := []byte(`{"uuid":"` + deleteTestUUID + `"}`)
|
|
journalUncertain(t, store, operationID, "delete-reconcile-0404", "domain_delete", deleteTestUUID, payload)
|
|
s, _ := newDeleteTestServerWithStore(t, backend, store)
|
|
|
|
first := httptest.NewRecorder()
|
|
s.Handler().ServeHTTP(first, httptest.NewRequest(http.MethodPost, "/v1/operations/"+operationID+"/reconcile", nil))
|
|
if first.Code != http.StatusConflict {
|
|
t.Fatalf("first reconcile status=%d body=%s; want 409", first.Code, first.Body.String())
|
|
}
|
|
if backend.deleteCalls != 0 || backend.inspectCalls != 1 {
|
|
t.Fatalf("first reconcile calls delete=%d inspect=%d; undefine must not replay", backend.deleteCalls, backend.inspectCalls)
|
|
}
|
|
|
|
if _, err := base.DeleteDomain(context.Background(), deleteTestUUID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
second := httptest.NewRecorder()
|
|
s.Handler().ServeHTTP(second, httptest.NewRequest(http.MethodPost, "/v1/operations/"+operationID+"/reconcile", nil))
|
|
if second.Code != http.StatusOK {
|
|
t.Fatalf("second reconcile status=%d body=%s", second.Code, second.Body.String())
|
|
}
|
|
record, err := store.Get(operationID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if record.Status != operation.StatusSucceeded || record.CommitBoundary != "domain_delete_readback_confirmed" {
|
|
t.Fatalf("record=%+v", record)
|
|
}
|
|
if backend.deleteCalls != 0 || backend.inspectCalls != 2 {
|
|
t.Fatalf("second reconcile calls delete=%d inspect=%d; want read-only reconcile", backend.deleteCalls, backend.inspectCalls)
|
|
}
|
|
}
|
|
|
|
func newDeleteTestServerWithStore(t *testing.T, backend hypervisor.Backend, store *operation.Store) (*Server, *operation.Store) {
|
|
t.Helper()
|
|
c := config.Defaults()
|
|
c.AgentID = "host-delete-reconcile"
|
|
s, err := New(Options{
|
|
Config: c,
|
|
Store: store,
|
|
Capabilities: capability.BackendProvider{Backend: backend, AgentID: c.AgentID, ProtocolVersion: c.ProtocolVersion},
|
|
Backend: backend,
|
|
HostBackendReady: true,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return s, store
|
|
}
|
|
|
|
func TestDomainDeleteRejectsExtraPayloadBeforeJournal(t *testing.T) {
|
|
backend := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())
|
|
s, store := newDeleteTestServer(t, backend)
|
|
operationID := "00000000-0000-4000-8000-000000000405"
|
|
body := []byte(`{"operation_id":"` + operationID + `","idempotency_key":"delete-operation-0405","kind":"domain_delete","target":"` + deleteTestUUID + `","payload":{"uuid":"` + deleteTestUUID + `","delete_disks":true}}`)
|
|
recorder := httptest.NewRecorder()
|
|
s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(body)))
|
|
if recorder.Code != http.StatusBadRequest {
|
|
t.Fatalf("status=%d body=%s; want 400", recorder.Code, recorder.Body.String())
|
|
}
|
|
if _, err := store.Get(operationID); !errors.Is(err, operation.ErrNotFound) {
|
|
t.Fatalf("invalid delete entered journal: %v", err)
|
|
}
|
|
}
|