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.
virt/agent/internal/api/server_create_validate_test.go

210 lines
8.4 KiB
Go

package api
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"path/filepath"
"testing"
"g.luoli.live/root/virt/agent/internal/capability"
"g.luoli.live/root/virt/agent/internal/config"
"g.luoli.live/root/virt/agent/internal/domaincreateplan"
"g.luoli.live/root/virt/agent/internal/domaincreatevalidate"
"g.luoli.live/root/virt/agent/internal/hypervisor"
"g.luoli.live/root/virt/agent/internal/operation"
"g.luoli.live/root/virt/agent/internal/startup"
)
func publishedCreateValidatePayload(t *testing.T, artifactRoot string, publish bool) domaincreateplan.JournalPayload {
t.Helper()
request := createPlanRequest()
payload, err := domaincreateplan.PrepareJournal(request)
if err != nil {
t.Fatal(err)
}
if publish {
files, err := startup.BuildCreateSeed(request.Seed.InstanceID, request.Seed.Hostname, request.Seed.NetworkConfig, request.Seed.StartupScript)
if err != nil {
t.Fatal(err)
}
if _, err := startup.WriteSeedDirectory(filepath.Join(artifactRoot, request.Seed.ArtifactID), files); err != nil {
t.Fatal(err)
}
}
return payload
}
func createValidateBody(t *testing.T, operationID, idempotency string, payload domaincreateplan.JournalPayload) []byte {
t.Helper()
encoded, err := json.Marshal(payload)
if err != nil {
t.Fatal(err)
}
return []byte(fmt.Sprintf(`{"operation_id":%q,"idempotency_key":%q,"kind":"domain_create_validate","target":%q,"payload":%s}`, operationID, idempotency, payload.Domain.UUID, encoded))
}
func createValidateServer(t *testing.T, backend hypervisor.Backend, artifactRoot string, store *operation.Store) *Server {
t.Helper()
c := config.Defaults()
c.AgentID = "host-create-validate"
c.ArtifactRoot = artifactRoot
if backend == nil {
backend = hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())
}
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
}
func TestDomainCreateValidateVerifiesSeedAndDoesNotDefine(t *testing.T) {
store := operation.NewMemory()
backend := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())
root := t.TempDir()
s := createValidateServer(t, backend, root, store)
payload := publishedCreateValidatePayload(t, root, true)
requestBody := createValidateBody(t, "00000000-0000-4000-8000-000000001201", "create-validate-1201", payload)
recorder := httptest.NewRecorder()
s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(requestBody)))
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_create_validate_confirmed" {
t.Fatalf("record=%+v", record)
}
if bytes.Contains(record.Payload, []byte("panel-secret")) || bytes.Contains(record.Payload, []byte(`"network_config"`)) ||
bytes.Contains(record.Result, []byte("panel-secret")) || bytes.Contains(record.Result, []byte(`{"version":2`)) ||
bytes.Contains(record.Payload, []byte(root)) || bytes.Contains(record.Result, []byte(root)) {
t.Fatalf("validation journal/result contains raw or path data: payload=%s result=%s", record.Payload, record.Result)
}
var result domainCreateValidateResult
if err := json.Unmarshal(record.Result, &result); err != nil {
t.Fatal(err)
}
if result.CommitBoundary != domaincreatevalidate.CommitBoundarySeedVerified || result.PlanHash != payload.PlanHash ||
result.DomainXMLHash != payload.DomainXMLHash || !result.StartupScriptPresent ||
result.StartupScriptSHA256 != payload.StartupScriptSHA256 || !result.LoaderPending ||
result.Capabilities.Policy != "efi-q35-no-secure-boot" {
t.Fatalf("result=%+v", result)
}
if _, err := backend.ReadDomainXML(context.Background(), payload.Domain.UUID); !errors.Is(err, hypervisor.ErrDomainNotFound) {
t.Fatalf("validation defined a domain: %v", err)
}
}
func TestDomainCreateValidateMissingSeedIsDefinitiveBeforeHost(t *testing.T) {
store := operation.NewMemory()
backend := &preflightProbeBackend{FakeBackend: hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot())}
root := t.TempDir()
s := createValidateServer(t, backend, root, store)
payload := publishedCreateValidatePayload(t, root, false)
id := "00000000-0000-4000-8000-000000001202"
recorder := httptest.NewRecorder()
s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(createValidateBody(t, id, "create-validate-1202", payload))))
if recorder.Code != http.StatusUnprocessableEntity {
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.StatusFailed || record.ErrorCode != "domain_create_validate_seed_artifact_rejected" {
t.Fatalf("record=%+v", record)
}
if backend.capabilityCalls != 0 {
t.Fatalf("host capability probe ran after seed rejection: capabilities=%d", backend.capabilityCalls)
}
if _, err := backend.ReadDomainXML(context.Background(), payload.Domain.UUID); !errors.Is(err, hypervisor.ErrDomainNotFound) {
t.Fatalf("seed rejection defined a domain: %v", err)
}
}
func TestDomainCreateValidateHostUnavailableReconcilesReadOnly(t *testing.T) {
store := operation.NewMemory()
backend := &preflightProbeBackend{
FakeBackend: hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot()),
capabilityErr: errors.New("capability transport unavailable"),
}
root := t.TempDir()
s := createValidateServer(t, backend, root, store)
payload := publishedCreateValidatePayload(t, root, true)
id := "00000000-0000-4000-8000-000000001203"
first := httptest.NewRecorder()
s.Handler().ServeHTTP(first, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(createValidateBody(t, id, "create-validate-1203", payload))))
if first.Code != http.StatusServiceUnavailable {
t.Fatalf("initial status=%d body=%s", first.Code, first.Body.String())
}
record, err := store.Get(id)
if err != nil {
t.Fatal(err)
}
if record.Status != operation.StatusUncertain || record.ErrorCode != "domain_create_validate_host_unavailable" {
t.Fatalf("initial record=%+v", record)
}
backend.capabilityErr = nil
reconciled := httptest.NewRecorder()
s.Handler().ServeHTTP(reconciled, httptest.NewRequest(http.MethodPost, "/v1/operations/"+id+"/reconcile", nil))
if reconciled.Code != http.StatusOK {
t.Fatalf("reconcile status=%d body=%s", reconciled.Code, reconciled.Body.String())
}
final, err := store.Get(id)
if err != nil {
t.Fatal(err)
}
if final.Status != operation.StatusSucceeded || final.CommitBoundary != "domain_create_validate_confirmed" {
t.Fatalf("final=%+v", final)
}
if backend.probeCalls != 0 || backend.capabilityCalls != 2 {
t.Fatalf("unexpected host calls probe=%d capabilities=%d", backend.probeCalls, backend.capabilityCalls)
}
if _, err := backend.ReadDomainXML(context.Background(), payload.Domain.UUID); !errors.Is(err, hypervisor.ErrDomainNotFound) {
t.Fatalf("validation reconciliation defined a domain: %v", err)
}
}
func TestDomainCreateValidateRejectsUnknownFieldsBeforeJournal(t *testing.T) {
store := operation.NewMemory()
root := t.TempDir()
s := createValidateServer(t, nil, root, store)
payload := publishedCreateValidatePayload(t, root, true)
encoded, err := json.Marshal(payload)
if err != nil {
t.Fatal(err)
}
var raw map[string]any
if err := json.Unmarshal(encoded, &raw); err != nil {
t.Fatal(err)
}
raw["startup_script"] = "must-not-be-accepted"
encoded, err = json.Marshal(raw)
if err != nil {
t.Fatal(err)
}
id := "00000000-0000-4000-8000-000000001204"
body := []byte(fmt.Sprintf(`{"operation_id":%q,"idempotency_key":"create-validate-1204","kind":"domain_create_validate","target":%q,"payload":%s}`, id, payload.Domain.UUID, encoded))
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", recorder.Code, recorder.Body.String())
}
if _, err := store.Get(id); !errors.Is(err, operation.ErrNotFound) {
t.Fatalf("unknown field entered journal: %v", err)
}
}