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) } }