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.
210 lines
8.4 KiB
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)
|
|
}
|
|
}
|