package server import ( "context" "encoding/json" "fmt" "io" "net/http" "net/url" "os" "strings" "time" "git.a-wan.net/alan/pipelines/internal/stage" ) const ( verificationFixtureID = "reconnect-foreground" verificationFixtureResponseLimit int64 = 64 << 10 verificationFixtureTimeout = 10 * time.Second ) // VerificationFixture is a server-owned, explicitly registered probe. Its // endpoint and expected provenance come from server configuration, never a // stage definition or result. type VerificationFixture struct { ID, Endpoint, Backend, Revision, Capability, State string } // VerificationFixturesFromEnvironment returns the single supported fixture // registration when its endpoint is explicitly configured. There is no default // endpoint: an unconfigured server fails target-aware verification closed. func VerificationFixturesFromEnvironment(getenv func(string) string) []VerificationFixture { if getenv == nil { getenv = os.Getenv } endpoint := strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_URL")) if endpoint == "" { return nil } return []VerificationFixture{{ ID: verificationFixtureID, Endpoint: endpoint, Backend: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_BACKEND")), Revision: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_REVISION")), Capability: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_CAPABILITY")), State: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_STATE")), }} } type verificationFixtureRegistry struct { fixtures map[string]VerificationFixture err error } func newVerificationFixtureRegistry(fixtures []VerificationFixture) *verificationFixtureRegistry { r := &verificationFixtureRegistry{fixtures: make(map[string]VerificationFixture, len(fixtures))} for _, fixture := range fixtures { if err := validVerificationFixture(fixture); err != nil { r.err = err return r } if _, exists := r.fixtures[fixture.ID]; exists { r.err = fmt.Errorf("duplicate verification fixture %q", fixture.ID) return r } r.fixtures[fixture.ID] = fixture } return r } func validVerificationFixture(fixture VerificationFixture) error { if fixture.ID != verificationFixtureID { return fmt.Errorf("unsupported verification fixture %q", fixture.ID) } for _, value := range []string{fixture.Endpoint, fixture.Backend, fixture.Revision, fixture.Capability, fixture.State} { if value == "" || len(value) > 256 { return fmt.Errorf("verification fixture %q has incomplete configuration", fixture.ID) } } u, err := url.Parse(fixture.Endpoint) if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") { return fmt.Errorf("verification fixture %q has invalid endpoint", fixture.ID) } return nil } func (r *verificationFixtureRegistry) verify(ctx context.Context, target stage.VerificationTarget) (stage.VerificationEvidence, error) { if r.err != nil { return stage.VerificationEvidence{}, r.err } fixture, exists := r.fixtures[target.Fixture] if !exists { return stage.VerificationEvidence{}, fmt.Errorf("unknown verification fixture %q", target.Fixture) } if fixture.Backend != target.Backend || fixture.Revision != target.Revision || fixture.Capability != target.Capability { return stage.VerificationEvidence{}, fmt.Errorf("verification target does not match registered fixture %q", target.Fixture) } probeCtx, cancel := context.WithTimeout(ctx, verificationFixtureTimeout) defer cancel() req, err := http.NewRequestWithContext(probeCtx, http.MethodGet, fixture.Endpoint, nil) if err != nil { return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q request: %w", fixture.ID, err) } client := &http.Client{Timeout: verificationFixtureTimeout, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }} response, err := client.Do(req) if err != nil { return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q probe: %w", fixture.ID, err) } defer response.Body.Close() if response.StatusCode != http.StatusOK { return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q probe returned %s", fixture.ID, response.Status) } var observed struct { Backend string `json:"backend"` Revision string `json:"revision"` Capability string `json:"capability"` Fixture string `json:"fixture"` State string `json:"state"` } body, err := io.ReadAll(io.LimitReader(response.Body, verificationFixtureResponseLimit+1)) if err != nil { return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q response: %w", fixture.ID, err) } if int64(len(body)) > verificationFixtureResponseLimit { return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q response exceeds %d bytes", fixture.ID, verificationFixtureResponseLimit) } if err := json.Unmarshal(body, &observed); err != nil { return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q response: %w", fixture.ID, err) } if observed.Backend != fixture.Backend || observed.Revision != fixture.Revision || observed.Capability != fixture.Capability || observed.Fixture != fixture.ID || observed.State != fixture.State { return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q returned incompatible backend, revision, capability, fixture, or state", fixture.ID) } return stage.VerificationEvidence{Backend: observed.Backend, Revision: observed.Revision, Capability: observed.Capability, Fixture: observed.Fixture}, nil }