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.
145 lines
5.6 KiB
Go
145 lines
5.6 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 observeTestUUID = "00000000-0000-4000-8000-000000000301"
|
|
|
|
type observeCountingBackend struct {
|
|
*hypervisor.FakeBackend
|
|
defineCalls int
|
|
powerCalls int
|
|
xmlReads int
|
|
stateReads int
|
|
}
|
|
|
|
func (b *observeCountingBackend) DefineDomain(ctx context.Context, request hypervisor.DefineRequest) (hypervisor.Definition, error) {
|
|
b.defineCalls++
|
|
return b.FakeBackend.DefineDomain(ctx, request)
|
|
}
|
|
|
|
func (b *observeCountingBackend) PowerDomain(ctx context.Context, uuid string, action hypervisor.PowerAction) (hypervisor.PowerResult, error) {
|
|
b.powerCalls++
|
|
return b.FakeBackend.PowerDomain(ctx, uuid, action)
|
|
}
|
|
|
|
func (b *observeCountingBackend) ReadDomainXML(ctx context.Context, uuid string) ([]byte, error) {
|
|
b.xmlReads++
|
|
return b.FakeBackend.ReadDomainXML(ctx, uuid)
|
|
}
|
|
|
|
func (b *observeCountingBackend) ReadDomainPowerState(ctx context.Context, uuid string) (hypervisor.DomainPowerState, error) {
|
|
b.stateReads++
|
|
return b.FakeBackend.ReadDomainPowerState(ctx, uuid)
|
|
}
|
|
|
|
func newObserveTestServer(t *testing.T) (*Server, *operation.Store, *observeCountingBackend) {
|
|
t.Helper()
|
|
base := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())
|
|
if _, err := base.DefineDomain(context.Background(), hypervisor.DefineRequest{
|
|
UUID: observeTestUUID,
|
|
XML: []byte(`<domain><uuid>` + observeTestUUID + `</uuid><os><type>hvm</type></os></domain>`),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
backend := &observeCountingBackend{FakeBackend: base}
|
|
store := operation.NewMemory()
|
|
c := config.Defaults()
|
|
c.AgentID = "host-observe"
|
|
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, backend
|
|
}
|
|
|
|
func TestDomainObserveReturnsSafeXMLAndPowerSummary(t *testing.T) {
|
|
s, store, backend := newObserveTestServer(t)
|
|
body := []byte(`{"operation_id":"00000000-0000-4000-8000-000000000302","idempotency_key":"observe-302","kind":"domain_observe","target":"` + observeTestUUID + `","payload":{"uuid":"` + observeTestUUID + `"}}`)
|
|
recorder := httptest.NewRecorder()
|
|
s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(body)))
|
|
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_observe_confirmed" {
|
|
t.Fatalf("record=%+v", record)
|
|
}
|
|
var result domainObserveResult
|
|
if err := json.Unmarshal(record.Result, &result); err != nil {
|
|
t.Fatalf("decode result: %v; raw=%s", err, record.Result)
|
|
}
|
|
if result.UUID != observeTestUUID || !validSHA256(result.XMLHash) || result.State != hypervisor.StateShutoff || result.Active {
|
|
t.Fatalf("result=%+v", result)
|
|
}
|
|
var resultShape map[string]json.RawMessage
|
|
if err := json.Unmarshal(record.Result, &resultShape); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, ok := resultShape["xml"]; ok {
|
|
t.Fatalf("domain observe result must not contain raw XML: %s", record.Result)
|
|
}
|
|
if backend.powerCalls != 0 || backend.defineCalls != 0 || backend.xmlReads == 0 || backend.stateReads == 0 {
|
|
t.Fatalf("backend calls define=%d power=%d xml=%d state=%d", backend.defineCalls, backend.powerCalls, backend.xmlReads, backend.stateReads)
|
|
}
|
|
if _, err := store.Get(record.OperationID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestDomainObserveRejectsUnknownPayloadFieldsBeforeJournal(t *testing.T) {
|
|
s, store, _ := newObserveTestServer(t)
|
|
body := []byte(`{"operation_id":"00000000-0000-4000-8000-000000000303","idempotency_key":"observe-303","kind":"domain_observe","target":"` + observeTestUUID + `","payload":{"uuid":"` + observeTestUUID + `","include_xml":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("00000000-0000-4000-8000-000000000303"); !errors.Is(err, operation.ErrNotFound) {
|
|
t.Fatalf("invalid observe payload entered journal: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDomainObserveReconcileReadsWithoutMutation(t *testing.T) {
|
|
s, store, backend := newObserveTestServer(t)
|
|
id := "00000000-0000-4000-8000-000000000304"
|
|
payload := []byte(`{"uuid":"` + observeTestUUID + `"}`)
|
|
journalUncertain(t, store, id, "observe-reconcile-304", "domain_observe", observeTestUUID, payload)
|
|
recorder := httptest.NewRecorder()
|
|
s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations/"+id+"/reconcile", nil))
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
record, err := store.Get(id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if record.Status != operation.StatusSucceeded || record.CommitBoundary != "domain_observe_confirmed" {
|
|
t.Fatalf("record=%+v", record)
|
|
}
|
|
if backend.defineCalls != 0 || backend.powerCalls != 0 || backend.xmlReads == 0 || backend.stateReads == 0 {
|
|
t.Fatalf("reconcile mutated backend: define=%d power=%d xml=%d state=%d", backend.defineCalls, backend.powerCalls, backend.xmlReads, backend.stateReads)
|
|
}
|
|
}
|