From df07f3ca34f540c00a9df116940be1519eef5a6c Mon Sep 17 00:00:00 2001 From: James Sturtevant Date: Sat, 14 Nov 2026 00:31:18 +0000 Subject: [PATCH 1/2] test: reproduce route reload failures from invalid files Signed-off-by: James Sturtevant --- internal/fiberdintegration/router_test.go | 190 ++++++++++++++++++++++ 1 file changed, 190 insertions(+) diff --git a/internal/fiberdintegration/router_test.go b/internal/fiberdintegration/router_test.go index 53a6057..e7741c8 100644 --- a/internal/fiberdintegration/router_test.go +++ b/internal/fiberdintegration/router_test.go @@ -4,10 +4,12 @@ package fiberdintegration import ( + "bytes" "context" "encoding/json" "errors" "fmt" + "log" "net/http" "net/http/httptest" "net/url" @@ -415,6 +417,194 @@ func TestRevisionReloadUpdatesReuseIdleTimeout(t *testing.T) { } } +func writeReloadRoute(t *testing.T, dir, name string, revision RevisionRoute) { + t.Helper() + data, err := json.Marshal(revision) + if err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, name), data, 0o600); err != nil { + t.Fatal(err) + } +} + +func checkReloadReadiness(t *testing.T, router *Router, revision RevisionRoute, want int) { + t.Helper() + query := url.Values{ + "namespace": {revision.Namespace}, + "revision": {revision.Revision}, + "version": {revision.Version()}, + } + response := httptest.NewRecorder() + router.ServeHTTP(response, httptest.NewRequest("GET", "http://fiber-router/readyz?"+query.Encode(), nil)) + if response.Code != want { + t.Fatalf("readiness for %s/%s at %s = %d, want %d", + revision.Namespace, revision.Revision, revision.Version(), response.Code, want) + } +} + +func TestRevisionReloadSkipsInvalidFiles(t *testing.T) { + for _, test := range []struct { + name string + data string + directory bool + diagnostic string + }{ + {name: "malformed-json", data: "{", diagnostic: "decode route metadata"}, + {name: "legacy", data: `{"host":"demo.default.localhost"}`, diagnostic: "not a Revision"}, + {name: "invalid-field-type", data: `{"kind":"revision","routed":"yes"}`, diagnostic: "decode Revision route"}, + {name: "invalid-policy", data: `{"kind":"revision","namespace":"default","revision":"bad","execution":{"mode":"invalid"},"timeout":"30s"}`, diagnostic: "Revision route"}, + {name: "invalid-timeout", data: `{"kind":"revision","namespace":"default","revision":"bad","execution":{"mode":"fresh-per-request"},"timeout":"0s"}`, diagnostic: "positive duration"}, + {name: "unreadable-entry", directory: true, diagnostic: "read"}, + } { + t.Run(test.name, func(t *testing.T) { + router, _, revision := routerFixture(t, project.ExecutionFresh) + const name = "000-invalid.json" + path := filepath.Join(router.routesDir, name) + if test.directory { + if err := os.Mkdir(path, 0o700); err != nil { + t.Fatal(err) + } + } else if err := os.WriteFile(path, []byte(test.data), 0o600); err != nil { + t.Fatal(err) + } + var diagnostics bytes.Buffer + previous := log.Writer() + log.SetOutput(&diagnostics) + t.Cleanup(func() { log.SetOutput(previous) }) + if err := router.Reload(); err != nil { + t.Fatalf("invalid file blocked valid routes: %v", err) + } + checkReloadReadiness(t, router, revision, http.StatusOK) + if len(router.revisions) != 1 { + t.Fatalf("loaded %d routes, want only the valid route", len(router.revisions)) + } + if text := diagnostics.String(); !strings.Contains(text, name) || !strings.Contains(text, test.diagnostic) { + t.Fatalf("missing file and cause in diagnostics: %q", text) + } + started, err := NewRouter(testHomeResolver{client: &testFiberClient{}}, router.routesDir) + if err != nil { + t.Fatalf("invalid file prevented router startup: %v", err) + } + defer started.Close() + checkReloadReadiness(t, started, revision, http.StatusOK) + }) + } +} + +func TestRevisionReloadUpdatesAndRemovesWithInvalidFile(t *testing.T) { + router, client, revision := routerFixture(t, project.ExecutionReuse) + response := httptest.NewRecorder() + router.ServeHTTP(response, revisionRequest("GET", "/test", revision)) + if response.Code != http.StatusOK { + t.Fatalf("initial request = %d", response.Code) + } + previous := revision + revision.Execution.IdleTimeout = "1s" + const originalFile = "revision-default--demo-1234.json" + writeReloadRoute(t, router.routesDir, originalFile, revision) + added := revision + added.Revision = "other-1234" + t.Cleanup(func() { forgetRevision(added.Namespace, added.Revision) }) + writeReloadRoute(t, router.routesDir, "other.json", added) + if err := os.WriteFile(filepath.Join(router.routesDir, "000-invalid.json"), []byte("{"), 0o600); err != nil { + t.Fatal(err) + } + if err := router.Reload(); err != nil { + t.Fatalf("invalid file blocked update: %v", err) + } + checkReloadReadiness(t, router, previous, http.StatusServiceUnavailable) + checkReloadReadiness(t, router, revision, http.StatusOK) + checkReloadReadiness(t, router, added, http.StatusOK) + pool := router.pools["default--demo-1234"] + if pool == nil || pool.idle != time.Second { + t.Fatal("valid update did not change the retained pool's idle timeout") + } + response = httptest.NewRecorder() + router.ServeHTTP(response, revisionRequest("GET", "/test", added)) + if response.Code != http.StatusOK { + t.Fatalf("added route request = %d", response.Code) + } + revision.Routed = false + writeReloadRoute(t, router.routesDir, originalFile, revision) + if err := router.Reload(); err != nil { + t.Fatalf("invalid file blocked routing-state update: %v", err) + } + router.releases.Wait() + if !slices.Equal(client.released, []string{"1"}) || len(router.pools) != 1 || router.pools["default--other-1234"] == nil { + t.Fatalf("routing-state update released %v, pools = %v", client.released, router.pools) + } + checkReloadReadiness(t, router, revision, http.StatusOK) + for _, name := range []string{originalFile, "other.json"} { + if err := os.Remove(filepath.Join(router.routesDir, name)); err != nil { + t.Fatal(err) + } + } + if err := router.Reload(); err != nil { + t.Fatalf("invalid file blocked removal: %v", err) + } + router.releases.Wait() + if !slices.Equal(client.released, []string{"1", "2"}) || len(router.pools) != 0 { + t.Fatalf("removal released %v, pools = %v", client.released, router.pools) + } + checkReloadReadiness(t, router, revision, http.StatusServiceUnavailable) + checkReloadReadiness(t, router, added, http.StatusServiceUnavailable) +} + +func TestRevisionReloadRejectsAllDuplicates(t *testing.T) { + router, client, revision := routerFixture(t, project.ExecutionReuse) + response := httptest.NewRecorder() + router.ServeHTTP(response, revisionRequest("GET", "/test", revision)) + if response.Code != http.StatusOK { + t.Fatalf("initial request = %d", response.Code) + } + other := revision + other.Revision = "other-1234" + t.Cleanup(func() { forgetRevision(other.Namespace, other.Revision) }) + writeReloadRoute(t, router.routesDir, "other.json", other) + conflict := revision + conflict.Timeout = "1s" + writeReloadRoute(t, router.routesDir, "000-duplicate.json", conflict) + conflict.Timeout = "2s" + writeReloadRoute(t, router.routesDir, "zzz-duplicate.json", conflict) + var diagnostics bytes.Buffer + previous := log.Writer() + log.SetOutput(&diagnostics) + t.Cleanup(func() { log.SetOutput(previous) }) + for range 2 { + if err := router.Reload(); err != nil { + t.Fatalf("duplicate identity blocked unrelated route: %v", err) + } + checkReloadReadiness(t, router, other, http.StatusOK) + for _, timeout := range []string{"30s", "1s", "2s"} { + conflict.Timeout = timeout + checkReloadReadiness(t, router, conflict, http.StatusServiceUnavailable) + } + if len(router.revisions) != 1 { + t.Fatalf("loaded %d routes, want only the unambiguous route", len(router.revisions)) + } + } + router.releases.Wait() + if !slices.Equal(client.released, []string{"1"}) { + t.Fatalf("ambiguous route retained its pool: releases = %v", client.released) + } + for _, want := range []string{"duplicate Revision route", "default/demo-1234", "000-duplicate.json", "revision-default--demo-1234.json", "zzz-duplicate.json"} { + if !strings.Contains(diagnostics.String(), want) { + t.Fatalf("missing %q in duplicate diagnostics: %q", want, diagnostics.String()) + } + } + for _, name := range []string{"000-duplicate.json", "zzz-duplicate.json"} { + if err := os.Remove(filepath.Join(router.routesDir, name)); err != nil { + t.Fatal(err) + } + } + if err := router.Reload(); err != nil { + t.Fatal(err) + } + checkReloadReadiness(t, router, revision, http.StatusOK) + checkReloadReadiness(t, router, other, http.StatusOK) +} + func TestDomainMappingRestoresOriginalHost(t *testing.T) { router, _, revision := routerFixture(t, project.ExecutionFresh) request := revisionRequest("GET", "/test", revision) From eeb00ceba7f5a785e2794a29ab31402c1a2e0081 Mon Sep 17 00:00:00 2001 From: James Sturtevant Date: Sat, 14 Nov 2026 00:44:18 +0000 Subject: [PATCH 2/2] fix: skip invalid route files and reject ambiguous revisions Signed-off-by: James Sturtevant --- docs/designs/knative-fiber-serving.md | 6 +++++ internal/fiberdintegration/router.go | 33 +++++++++++++++++++-------- 2 files changed, 29 insertions(+), 10 deletions(-) diff --git a/docs/designs/knative-fiber-serving.md b/docs/designs/knative-fiber-serving.md index 86e6ca5..b901874 100644 --- a/docs/designs/knative-fiber-serving.md +++ b/docs/designs/knative-fiber-serving.md @@ -186,6 +186,12 @@ The custom Go reconciler: Revision readiness requires a verified artifact, admitted CapacityGrant, ready Home, ready backend Service, and published router metadata. +The router logs and skips each metadata file that it cannot read, decode, or +validate. If multiple valid files identify the same namespace and Revision, +the router logs the conflict and excludes that Revision until only one file +remains. Other valid Revisions continue to load. Excluded and removed Revisions +release their Fiber pools. Readiness confirms the loaded metadata version. + ## Scaling translation Lampyr does not install KPA. diff --git a/internal/fiberdintegration/router.go b/internal/fiberdintegration/router.go index 32cbf81..6aadd1d 100644 --- a/internal/fiberdintegration/router.go +++ b/internal/fiberdintegration/router.go @@ -262,38 +262,51 @@ func (router *Router) Reload() error { return err } revisions := map[string]RevisionRoute{} - retain := map[string]bool{} - routed := map[string]bool{} - idle := map[string]time.Duration{} + sources := map[string]string{} for _, entry := range entries { if !strings.HasSuffix(entry.Name(), ".json") { continue } data, err := os.ReadFile(router.routesDir + "/" + entry.Name()) if err != nil { - return err + log.Printf("read route metadata %s: %v", entry.Name(), err) + continue } var metadata struct { Kind string `json:"kind"` } if err := json.Unmarshal(data, &metadata); err != nil { - return fmt.Errorf("decode route metadata %s: %w", entry.Name(), err) + log.Printf("decode route metadata %s: %v", entry.Name(), err) + continue } if metadata.Kind != "revision" { - return fmt.Errorf("route metadata %s is not a Revision", entry.Name()) + log.Printf("route metadata %s is not a Revision", entry.Name()) + continue } var revision RevisionRoute if err := json.Unmarshal(data, &revision); err != nil { - return fmt.Errorf("decode Revision route %s: %w", entry.Name(), err) + log.Printf("decode Revision route %s: %v", entry.Name(), err) + continue } if err := revision.Validate(); err != nil { - return fmt.Errorf("Revision route %s: %w", entry.Name(), err) + log.Printf("Revision route %s: %v", entry.Name(), err) + continue } key := revision.Namespace + "/" + revision.Revision - if _, exists := revisions[key]; exists { - return fmt.Errorf("duplicate Revision route %q", key) + if source, exists := sources[key]; exists { + log.Printf("duplicate Revision route %q in %s and %s; skipping all files for this Revision", key, source, entry.Name()) + delete(revisions, key) + continue } + // Keep the first source even after a duplicate removes the route, + // so a third copy cannot make an ambiguous Revision valid again. + sources[key] = entry.Name() revisions[key] = revision + } + retain := map[string]bool{} + routed := map[string]bool{} + idle := map[string]time.Duration{} + for key, revision := range revisions { poolKey := revision.Namespace + "--" + revision.Revision if revision.Routed { retain[poolKey] = true