feat: add typed Go Agent domain delete boundary
parent
41ee38b9f2
commit
0599909d28
@ -0,0 +1,204 @@
|
||||
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)
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,170 @@
|
||||
package hypervisor
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestFakeDeleteDomainRequiresInactiveAndProvesAbsence(t *testing.T) {
|
||||
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
||||
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
|
||||
UUID: testUUID,
|
||||
XML: testDomainXML(testUUID),
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
preflight, err := backend.InspectDomainForDeletion(context.Background(), testUUID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !preflight.Present || preflight.Active || preflight.State != StateShutoff || preflight.XMLHash == "" {
|
||||
t.Fatalf("preflight = %+v", preflight)
|
||||
}
|
||||
|
||||
result, err := backend.DeleteDomain(context.Background(), strings.ToUpper(testUUID))
|
||||
if err != nil {
|
||||
t.Fatalf("DeleteDomain() error = %v", err)
|
||||
}
|
||||
if result.UUID != testUUID || !result.Existed || !result.Removed || result.AlreadyAbsent ||
|
||||
result.StorageRemoved || result.NetworkChanged || result.XMLHash != preflight.XMLHash {
|
||||
t.Fatalf("delete result = %+v", result)
|
||||
}
|
||||
after, err := backend.InspectDomainForDeletion(context.Background(), testUUID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if after.Present || after.UUID != testUUID {
|
||||
t.Fatalf("post-delete observation = %+v", after)
|
||||
}
|
||||
if _, err := backend.ReadDomainXML(context.Background(), testUUID); !errors.Is(err, ErrDomainNotFound) {
|
||||
t.Fatalf("ReadDomainXML() after delete = %v, want ErrDomainNotFound", err)
|
||||
}
|
||||
|
||||
// A repeated request is an idempotent, already-absent observation; it does
|
||||
// not resurrect or touch any unrelated host resource.
|
||||
repeated, err := backend.DeleteDomain(context.Background(), testUUID)
|
||||
if err != nil {
|
||||
t.Fatalf("repeated DeleteDomain() error = %v", err)
|
||||
}
|
||||
if !repeated.AlreadyAbsent || !repeated.Removed || repeated.Existed {
|
||||
t.Fatalf("repeated delete result = %+v", repeated)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFakeDeleteDomainRejectsActiveWithoutRemovingDefinition(t *testing.T) {
|
||||
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
||||
if _, err := backend.DefineDomain(context.Background(), DefineRequest{UUID: testUUID, XML: testDomainXML(testUUID)}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := backend.PowerDomain(context.Background(), testUUID, PowerActionStart); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
result, err := backend.DeleteDomain(context.Background(), testUUID)
|
||||
if !errors.Is(err, ErrDomainActive) {
|
||||
t.Fatalf("DeleteDomain() error = %v, want ErrDomainActive", err)
|
||||
}
|
||||
if result.Removed || !result.Existed || result.StateBefore != StateRunning {
|
||||
t.Fatalf("active delete result = %+v", result)
|
||||
}
|
||||
observation, err := backend.InspectDomainForDeletion(context.Background(), testUUID)
|
||||
if err != nil || !observation.Present || !observation.Active {
|
||||
t.Fatalf("active definition after rejected delete = %+v, err=%v", observation, err)
|
||||
}
|
||||
}
|
||||
|
||||
type deleteRecordingRunner struct {
|
||||
mu sync.Mutex
|
||||
commands [][]string
|
||||
present bool
|
||||
state []byte
|
||||
readbackErr error
|
||||
undefineErr error
|
||||
returnNotFound bool
|
||||
}
|
||||
|
||||
func (r *deleteRecordingRunner) Run(_ context.Context, args ...string) ([]byte, error) {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
r.commands = append(r.commands, append([]string(nil), args...))
|
||||
if len(args) < 3 {
|
||||
return nil, fmt.Errorf("missing virsh command")
|
||||
}
|
||||
switch args[2] {
|
||||
case "dumpxml":
|
||||
if !r.present || r.returnNotFound {
|
||||
if !r.present && r.readbackErr != nil {
|
||||
return nil, r.readbackErr
|
||||
}
|
||||
return nil, ErrDomainNotFound
|
||||
}
|
||||
return []byte(`<domain><uuid>` + testUUID + `</uuid><os><type>hvm</type></os></domain>`), nil
|
||||
case "domstate":
|
||||
if !r.present {
|
||||
return nil, ErrDomainNotFound
|
||||
}
|
||||
return append([]byte(nil), r.state...), nil
|
||||
case "undefine":
|
||||
if r.undefineErr != nil {
|
||||
return nil, r.undefineErr
|
||||
}
|
||||
r.present = false
|
||||
return []byte("undefined"), nil
|
||||
default:
|
||||
return nil, fmt.Errorf("unexpected command %q", args[2])
|
||||
}
|
||||
}
|
||||
|
||||
func TestVirshDeleteDomainUsesCanonicalUndefineAndAbsenceReadback(t *testing.T) {
|
||||
runner := &deleteRecordingRunner{present: true, state: []byte("shut off\n")}
|
||||
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
result, err := backend.DeleteDomain(context.Background(), strings.ToUpper(testUUID))
|
||||
if err != nil {
|
||||
t.Fatalf("DeleteDomain() error = %v", err)
|
||||
}
|
||||
if !result.Existed || !result.Removed || result.StorageRemoved || result.NetworkChanged {
|
||||
t.Fatalf("result = %+v", result)
|
||||
}
|
||||
runner.mu.Lock()
|
||||
commands := append([][]string(nil), runner.commands...)
|
||||
runner.mu.Unlock()
|
||||
want := [][]string{
|
||||
{"-c", "qemu:///system", "dumpxml", "--inactive", testUUID},
|
||||
{"-c", "qemu:///system", "domstate", "--domain", testUUID},
|
||||
{"-c", "qemu:///system", "undefine", "--domain", testUUID},
|
||||
{"-c", "qemu:///system", "dumpxml", "--inactive", testUUID},
|
||||
}
|
||||
if len(commands) != len(want) {
|
||||
t.Fatalf("commands = %+v, want %+v", commands, want)
|
||||
}
|
||||
for i := range want {
|
||||
if strings.Join(commands[i], "\x00") != strings.Join(want[i], "\x00") {
|
||||
t.Fatalf("command[%d] = %+v, want %+v", i, commands[i], want[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestVirshDeleteDomainLeavesUncertainWhenAbsenceReadbackFails(t *testing.T) {
|
||||
runner := &deleteRecordingRunner{
|
||||
present: true,
|
||||
state: []byte("shut off\n"),
|
||||
readbackErr: errors.New("transport lost"),
|
||||
}
|
||||
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
result, err := backend.DeleteDomain(context.Background(), testUUID)
|
||||
if !errors.Is(err, ErrDeleteReadbackMismatch) {
|
||||
t.Fatalf("DeleteDomain() error = %v, want ErrDeleteReadbackMismatch", err)
|
||||
}
|
||||
if result.Removed {
|
||||
t.Fatalf("ambiguous delete was reported removed: %+v", result)
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,33 @@
|
||||
# Go Agent `domain_delete` contract
|
||||
|
||||
This slice implements a narrow, identity-bound **libvirt definition undefine**
|
||||
operation. It is not the panel's full VM deletion workflow.
|
||||
|
||||
## Host boundary
|
||||
|
||||
- The request payload is exactly `{ "uuid": "<canonical UUID>" }`.
|
||||
- `InspectDomainForDeletion` performs a targeted read-only `dumpxml --inactive`
|
||||
and `domstate` observation. It does not enumerate domains or touch storage,
|
||||
networking, firewall state, or seed artifacts.
|
||||
- `DeleteDomain` refuses an active domain. It invokes only
|
||||
`virsh undefine --domain <canonical UUID>` and then requires a targeted
|
||||
absence read-back before returning success.
|
||||
- Fake and virsh backends report only a SHA-256 XML digest; raw XML and host
|
||||
paths never enter the operation result or journal.
|
||||
- `storage_removed=false` and `network_changed=false` are explicit result
|
||||
facts. The operation never deletes disks or changes a network.
|
||||
|
||||
If the undefine command or absence read-back is ambiguous, the operation is
|
||||
`uncertain`. Reconciliation calls only `InspectDomainForDeletion`; it never
|
||||
replays `undefine`. A present definition, failed transport, or missing state
|
||||
read-back therefore cannot become a false success.
|
||||
|
||||
## PHP boundary
|
||||
|
||||
The Go API accepts `domain_delete`, but the PHP `CloudAgentVmGateway` keeps the
|
||||
legacy panel `delete` mapping disabled (`null`). The existing panel operation
|
||||
also owns disk/seed cleanup, billing state, firewall history, and irreversible
|
||||
instance tombstoning. Mapping it to definition-only undefine would report a
|
||||
successful VM deletion while leaving those resources behind. A future mapping
|
||||
requires a separate typed storage/seed/network cleanup contract, panel CAS
|
||||
updates, and real-host read-back evidence.
|
||||
Loading…
Reference in New Issue