From fd52a84cd5eaa0275df9edb95dbba8b3f6080e0a Mon Sep 17 00:00:00 2001 From: reoring Date: Fri, 13 Nov 2026 07:50:45 +0900 Subject: [PATCH 1/2] gatewayendpoint: treat a route-level Accepted=False as Unknown for DNS retention A transient Accepted=False on every HTTPRoute of a Project (management control-plane restart, policy staging) deleted the EndpointRecordSet and all Route 53 records for two to three minutes while the data path stayed healthy. Route admission controls serving, not publication intent: a receipted hostname is now retained under the same boundary as Unknown. New hostnames still require Accepted=True; identity, Gateway-level and intent-removal withdrawals are unchanged. Design: appthrust/platform ADR-0082 D4. --- docs/design/gateway-api-integration.md | 39 +- .../controllers/gateway/controller.go | 5 +- .../controllers/gateway/retention_test.go | 362 +++++++++++++++++- 3 files changed, 379 insertions(+), 27 deletions(-) diff --git a/docs/design/gateway-api-integration.md b/docs/design/gateway-api-integration.md index 80db7d9..47efcdd 100644 --- a/docs/design/gateway-api-integration.md +++ b/docs/design/gateway-api-integration.md @@ -156,14 +156,20 @@ The Gateway controller preserves target type and value. It does not turn hostnam ## Parent Acceptance -The controller distinguishes current admission from unavailable observation for -each parent reference. A current `Accepted=True` condition has +The controller distinguishes current admission from retention of an established +publication for each parent reference. A current `Accepted=True` condition has `observedGeneration` equal to the route generation and is the only state that -can admit a hostname for a first publication. A current `Accepted=False` -explicitly withdraws the affected binding. Missing, `Unknown`, and stale -conditions are observation-unknown rather than denials: they may retain only -an exact receipt from an earlier admitted reconcile, never authorize a new -hostname. +can admit a hostname for a first publication. For DNS retention, a current +route-level `Accepted=False` is treated exactly as `Unknown`: like missing or +stale conditions, it may retain a hostname with a matching admission receipt +only when the listener allows unknown retention. None of these states +authorizes a new hostname. + +This follows [appthrust/platform ADR-0082, D4](https://github.com/appthrust/platform/blob/main/design/platform/adr-0082-publication-continuity.md): +route admission and policy staging control serving permission, not publication +intent. Withdrawing an established name during those transitions can send users +to an estate wildcard with the wrong certificate; DNS withdrawal is not a +security fence. An explicit current Gateway `Accepted=False` condition, whose `observedGeneration` equals the Gateway generation, withdraws every hostname @@ -176,16 +182,21 @@ Gateway's targets or receipt forward. An older managed `EndpointRecordSet` without a valid receipt fails closed during -unknown observation. It receives a receipt only from a normal reconcile with -complete current acceptance and nonempty current targets. +unknown observation or route-level `Accepted=False`. It receives a receipt only +from a normal reconcile with complete current acceptance and nonempty current +targets. The receipt also records the specific listener. Hostname or parent removal, -listener removal or ownership change, route or Gateway identity replacement, -and route/Gateway deletion remove the affected hostname immediately. A -dynamic `allowedRoutes.namespaces.from: Selector` policy cannot be re-proved -without a namespace read, so unknown observation under that policy is not -retained. Independent sibling listener bindings are evaluated separately. +listener removal or ownership change, and route/Gateway deletion remove the +affected hostname immediately. Receipt identity rules remain unchanged: a route +with a replacement UID may inherit and rebind a receipt only when all its current +parent references are `Accepted=True`; a replacement under `False` or `Unknown` +cannot inherit it. Gateway UID and class and the listener digest must still +match for retention. A dynamic `allowedRoutes.namespaces.from: Selector` policy +cannot be re-proved without a namespace read, so neither unknown observation +nor route-level `Accepted=False` is retained under that policy. Independent +sibling listener bindings are evaluated separately. The receipt records route namespace and name only so a parent-reference removal, change, deletion, or final not-found reconciliation can requeue the previously diff --git a/internal/go/apps/gatewayendpoint/controllers/gateway/controller.go b/internal/go/apps/gatewayendpoint/controllers/gateway/controller.go index 2333fd8..5778eec 100644 --- a/internal/go/apps/gatewayendpoint/controllers/gateway/controller.go +++ b/internal/go/apps/gatewayendpoint/controllers/gateway/controller.go @@ -300,8 +300,9 @@ func (r *Reconciler) endpointRecordSetsForGateway(ctx context.Context, gateway * } continue } - if acceptance == parentAcceptanceRejected || - (acceptance == parentAcceptanceUnknown && !listenerAllowsUnknownRetention(route, gateway, binding.listener)) || + // Route admission controls serving, not publication intent. + // False and Unknown have the same receipt-retention boundary. + if (acceptance != parentAcceptanceAccepted && !listenerAllowsUnknownRetention(route, gateway, binding.listener)) || !hasReceipt { continue } diff --git a/internal/go/apps/gatewayendpoint/controllers/gateway/retention_test.go b/internal/go/apps/gatewayendpoint/controllers/gateway/retention_test.go index 58a671c..23cbf04 100644 --- a/internal/go/apps/gatewayendpoint/controllers/gateway/retention_test.go +++ b/internal/go/apps/gatewayendpoint/controllers/gateway/retention_test.go @@ -3,15 +3,28 @@ package gateway import ( "context" "errors" + "fmt" + "net/http/httptest" + "reflect" "testing" + endpointcontroller "github.com/appthrust/dns-api/internal/go/apps/endpoint/controllers/endpointrecordset" + corezoneunit "github.com/appthrust/dns-api/internal/go/core/controllers/zoneunit" + route53 "github.com/appthrust/dns-api/internal/go/providers/route53/controllers/zoneunit" + route53conversion "github.com/appthrust/dns-api/internal/go/providers/route53/conversion" + dnsv1alpha1 "github.com/appthrust/dns-api/pkg/go/api/dns/v1alpha1" endpointv1alpha1 "github.com/appthrust/dns-api/pkg/go/api/endpoint/v1alpha1" + route53v1alpha1 "github.com/appthrust/dns-api/pkg/go/api/route53/v1alpha1" + corev1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/types" + "k8s.io/client-go/rest" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/fake" + "sigs.k8s.io/controller-runtime/pkg/client/interceptor" "sigs.k8s.io/controller-runtime/pkg/reconcile" gatewayv1 "sigs.k8s.io/gateway-api/apis/v1" ) @@ -130,21 +143,272 @@ func TestGatewayEndpointRecordSetRetainsReceiptAcrossObservedTransientStates(t * } } -func TestGatewayEndpointRecordSetRevokesExplicitFalseAndForeignGateway(t *testing.T) { - t.Run("explicit false", func(t *testing.T) { - ctx := context.Background() - r, _, haKey, _, recordKey := retentionFixture(t, false) - setRouteAcceptance(t, r, haKey, metav1.ConditionFalse) - reconcileRetentionRoute(t, r, haKey) +func TestGatewayRouteAdmissionRetainsPublishedRecordsWithoutProviderDelete(t *testing.T) { + ctx := t.Context() + r, _, routeKey, gatewayKey, recordKey := retentionFixture(t, false) + scheme := r.Client.Scheme() + for _, add := range []func(*runtime.Scheme) error{corev1.AddToScheme, dnsv1alpha1.AddToScheme, route53v1alpha1.AddToScheme} { + if err := add(scheme); err != nil { + t.Fatal(err) + } + } + var intent endpointv1alpha1.EndpointRecordSet + if err := r.Get(ctx, recordKey, &intent); err != nil { + t.Fatal(err) + } + intent.UID, intent.Generation = "publication-intent", 1 + if err := r.Update(ctx, &intent); err != nil { + t.Fatal(err) + } + var route gatewayv1.HTTPRoute + if err := r.Get(ctx, routeKey, &route); err != nil { + t.Fatal(err) + } + var gateway gatewayv1.Gateway + if err := r.Get(ctx, gatewayKey, &gateway); err != nil { + t.Fatal(err) + } + // Fake clients do not allocate UIDs. Assign distinct incarnations at the + // create boundary, as the API server does, so replacement cannot pass. + incarnation := 0 + r.Client = fake.NewClientBuilder().WithScheme(scheme). + WithStatusSubresource(&route, &gateway, &intent, &dnsv1alpha1.Zone{}, &dnsv1alpha1.ZoneUnit{}, &dnsv1alpha1.RecordSet{}). + WithObjects(&route, &gateway, &intent). + WithInterceptorFuncs(interceptor.Funcs{ + Create: func(ctx context.Context, cl client.WithWatch, obj client.Object, opts ...client.CreateOption) error { + incarnation++ + obj.SetUID(types.UID(fmt.Sprintf("publication-%d", incarnation))) + obj.SetGeneration(1) + return cl.Create(ctx, obj, opts...) + }, + }).Build() + zone := &dnsv1alpha1.Zone{ + ObjectMeta: metav1.ObjectMeta{Namespace: "dns-system", Name: "example", UID: "publication-zone", Generation: 1}, + Spec: dnsv1alpha1.ZoneSpec{ + DomainName: "example.com", Provider: route53v1alpha1.ProviderRef, + ZoneClassRef: dnsv1alpha1.ZoneClassReference{Name: "route53"}, + Adoption: runtime.RawExtension{Raw: []byte(`{"hostedZoneId":"ZPUBLICATION"}`)}, + AllowedRecordSets: []dnsv1alpha1.AllowedRecordSet{{ + Namespaces: dnsv1alpha1.AllowedRecordSetNamespaces{Selector: metav1.LabelSelector{}}, + Records: []dnsv1alpha1.AllowedRecord{{ + Name: dnsv1alpha1.RecordNamePolicy{Pattern: ".*"}, Types: []dnsv1alpha1.RecordType{dnsv1alpha1.RecordTypeA}, + }}, + }}, + }, + } + objects := []client.Object{ + zone, + &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: zone.Namespace}}, + &dnsv1alpha1.Provider{ + ObjectMeta: metav1.ObjectMeta{Name: route53v1alpha1.ProviderName}, + Spec: dnsv1alpha1.ProviderSpec{Versions: []dnsv1alpha1.ProviderVersion{{ + Name: route53v1alpha1.ProviderVersion, Served: true, Storage: true, + RecordSet: dnsv1alpha1.ProviderRecordSet{SupportedTypes: []dnsv1alpha1.RecordType{dnsv1alpha1.RecordTypeA}}, + }}}, + }, + &dnsv1alpha1.ZoneClass{ + ObjectMeta: metav1.ObjectMeta{Namespace: zone.Namespace, Name: "route53", Generation: 1}, + Spec: dnsv1alpha1.ZoneClassSpec{ + Provider: route53v1alpha1.ProviderRef, ControllerName: route53.DefaultControllerName, + IdentityRef: &dnsv1alpha1.LocalObjectReference{Name: "route53"}, + Parameters: runtime.RawExtension{Raw: []byte(`{}`)}, + AllowedZones: dnsv1alpha1.ZoneClassAllowedZones{ + Namespaces: dnsv1alpha1.NamespacePolicy{From: dnsv1alpha1.NamespacesFromSame}, + }, + }, + Status: dnsv1alpha1.ZoneClassStatus{Conditions: []metav1.Condition{{ + Type: "Accepted", Status: metav1.ConditionTrue, ObservedGeneration: 1, + }}}, + }, + &route53v1alpha1.Route53Identity{ + ObjectMeta: metav1.ObjectMeta{Namespace: zone.Namespace, Name: "route53", Generation: 1}, + Status: route53v1alpha1.Route53IdentityStatus{Conditions: []metav1.Condition{ + {Type: "Accepted", Status: metav1.ConditionTrue, ObservedGeneration: 1}, + {Type: "Ready", Status: metav1.ConditionTrue, ObservedGeneration: 1}, + }}, + }, + &endpointv1alpha1.EndpointProviderCapability{ + ObjectMeta: metav1.ObjectMeta{Name: "route53"}, + Spec: endpointv1alpha1.EndpointProviderCapabilitySpec{ + Provider: route53v1alpha1.ProviderRef, + Conversion: endpointv1alpha1.EndpointRecordSetConversionAPI{ + Group: route53conversion.GroupName, Version: route53conversion.Version, Resource: route53conversion.Resource, + }, + }, + }, + } + for _, obj := range objects { + if err := r.Create(ctx, obj); err != nil { + t.Fatal(err) + } + } + server := httptest.NewServer(route53conversion.NewHandler()) + t.Cleanup(server.Close) + endpoint := &endpointcontroller.Reconciler{Client: r.Client, RecordSetNamespace: recordKey.Namespace, RESTConfig: &rest.Config{Host: server.URL}} + composition := &corezoneunit.ZoneUnitCompositionReconciler{Client: r.Client} + provider := &publicationProvider{records: map[string]route53.RecordSetResource{}} + dns := &route53.ZoneReconciler{Client: r.Client, Provider: provider} + advance := func() { + t.Helper() + for range 8 { + for _, step := range []struct { + reconciler reconcile.Reconciler + key client.ObjectKey + }{{endpoint, recordKey}, {composition, client.ObjectKeyFromObject(zone)}, {dns, client.ObjectKeyFromObject(zone)}} { + if _, err := step.reconciler.Reconcile(ctx, reconcile.Request{NamespacedName: step.key}); err != nil { + t.Fatal(err) + } + } + } + } + advance() + var before endpointv1alpha1.EndpointRecordSet + if err := r.Get(ctx, recordKey, &before); err != nil { + t.Fatal(err) + } + var children dnsv1alpha1.RecordSetList + if err := r.List(ctx, &children); err != nil { + t.Fatal(err) + } + if len(children.Items) != 1 || children.Items[0].UID == "" || provider.upserts != 1 || len(provider.records) != 1 { + var unit dnsv1alpha1.ZoneUnit + if err := r.Get(ctx, client.ObjectKeyFromObject(zone), &unit); err != nil { + t.Fatal(err) + } + t.Fatalf("publication did not reach provider: children=%d upserts=%d records=%#v zone conditions=%#v", len(children.Items), provider.upserts, provider.records, unit.Status.Zone) + } + child := children.Items[0] + for _, status := range []metav1.ConditionStatus{metav1.ConditionFalse, metav1.ConditionUnknown} { + for _, emptyAddresses := range []bool{false, true} { + t.Run(fmt.Sprintf("%s/empty-addresses=%t", status, emptyAddresses), func(t *testing.T) { + setRouteAcceptance(t, r, routeKey, status) + addresses := []gatewayv1.GatewayStatusAddress{{Value: "192.0.2.1"}} + if emptyAddresses { + addresses = nil + } + setGatewayAddresses(t, r, gatewayKey, addresses) + // Reconstruct the source reconciler: no in-memory admission + // observation is available after a controller restart. + r = &Reconciler{Client: r.Client, EndpointRecordSetNamespace: recordKey.Namespace} + reconcileRetentionRoute(t, r, routeKey) + advance() + var after endpointv1alpha1.EndpointRecordSet + if err := r.Get(ctx, recordKey, &after); err != nil { + t.Fatal(err) + } + if after.UID != before.UID || !after.DeletionTimestamp.IsZero() || !reflect.DeepEqual(after.Spec, before.Spec) { + t.Fatalf("established intent changed: before=%#v after=%#v", before, after) + } + var current dnsv1alpha1.RecordSet + if err := r.Get(ctx, client.ObjectKeyFromObject(&child), ¤t); err != nil { + t.Fatal(err) + } + if current.UID != child.UID || !current.DeletionTimestamp.IsZero() || !reflect.DeepEqual(current.Spec, child.Spec) { + t.Fatalf("established child changed: before=%#v after=%#v", child, current) + } + if provider.deletes != 0 || provider.upserts != 1 || len(provider.records) != 1 { + t.Fatalf("admission churn changed provider records: deletes=%d upserts=%d records=%#v", provider.deletes, provider.upserts, provider.records) + } + }) + } + } + // Positive control: the same consumer chain really deletes the provider + // record when publication intent ends. + deleteRoute(t, r, routeKey) + advance() + if provider.deletes != 1 || len(provider.records) != 0 { + t.Fatalf("route deletion did not reach provider: deletes=%d records=%#v", provider.deletes, provider.records) + } +} - var record endpointv1alpha1.EndpointRecordSet - if err := r.Get(ctx, recordKey, &record); err != nil || record.DeletionTimestamp.IsZero() { - t.Fatalf("explicitly rejected route retained DNS intent: %v", err) +type publicationProvider struct { + route53.Provider + records map[string]route53.RecordSetResource + tags map[string]string + upserts int + deletes int +} + +func (p *publicationProvider) GetHostedZone(context.Context, string) (route53.HostedZone, error) { + return route53.HostedZone{ID: "ZPUBLICATION", Name: "example.com"}, nil +} + +func (p *publicationProvider) TagHostedZone(_ context.Context, _ string, tags map[string]string) error { + p.tags = tags + return nil +} + +func (p *publicationProvider) ListRecordSets(context.Context, string) ([]route53.RecordSetResource, error) { + records := make([]route53.RecordSetResource, 0, len(p.records)) + for _, record := range p.records { + records = append(records, record) + } + return records, nil +} + +func (p *publicationProvider) ChangeRecordSets(_ context.Context, _ string, changes []route53.RecordSetChange) (*route53v1alpha1.Route53Change, error) { + for _, change := range changes { + switch change.Action { + case route53.RecordSetChangeActionDelete: + p.deletes++ + delete(p.records, change.RecordSet.Name) + case route53.RecordSetChangeActionUpsert: + p.upserts++ + p.records[change.RecordSet.Name] = change.RecordSet + default: + return nil, fmt.Errorf("unexpected provider action %q", change.Action) } - }) + } + return &route53v1alpha1.Route53Change{ID: "publication-change", Status: route53v1alpha1.Route53ChangeStatusPending}, nil +} + +func (p *publicationProvider) GetChange(context.Context, string) (*route53v1alpha1.Route53Change, error) { + return &route53v1alpha1.Route53Change{ID: "publication-change", Status: route53v1alpha1.Route53ChangeStatusInSync}, nil +} + +func TestGatewayEndpointRecordSetRetainsReceiptOnRouteAcceptedFalse(t *testing.T) { + for _, status := range []metav1.ConditionStatus{metav1.ConditionFalse, metav1.ConditionUnknown} { + for _, policy := range []gatewayv1.FromNamespaces{gatewayv1.NamespacesFromAll, gatewayv1.NamespacesFromSame, gatewayv1.NamespacesFromSelector} { + t.Run(string(status)+"/"+string(policy), func(t *testing.T) { + ctx := context.Background() + r, _, routeKey, _, recordKey := retentionFixtureWithNamespacePolicy(t, false, policy) + var before endpointv1alpha1.EndpointRecordSet + if err := r.Get(ctx, recordKey, &before); err != nil { + t.Fatal(err) + } + before.UID = "retained-endpoint" + if err := r.Update(ctx, &before); err != nil { + t.Fatal(err) + } + setRouteAcceptance(t, r, routeKey, status) + reconcileRetentionRoute(t, r, routeKey) + + var after endpointv1alpha1.EndpointRecordSet + if err := r.Get(ctx, recordKey, &after); err != nil { + t.Fatal(err) + } + if policy != gatewayv1.NamespacesFromAll { + // The fixture route is in a different namespace. Same and + // Selector cannot re-prove its attachment while unaccepted. + if after.DeletionTimestamp.IsZero() { + t.Fatal("listener without retention permission retained DNS intent") + } + return + } + assertRetentionRecord(t, r, recordKey, []string{"ha.example.com"}, "192.0.2.1") + if after.UID != before.UID || after.ResourceVersion != before.ResourceVersion { + t.Fatal("route admission changed the established DNS intent") + } + }) + } + } +} + +func TestGatewayEndpointRecordSetWithdrawalBoundaries(t *testing.T) { t.Run("gateway accepted false", func(t *testing.T) { ctx := context.Background() - r, _, haKey, gatewayKey, recordKey := retentionFixture(t, false) + r, _, haKey, gatewayKey, recordKey := retentionFixture(t, true) + assertRetentionRecord(t, r, recordKey, []string{"ha.example.com", "payment.example.com"}, "192.0.2.1") setGatewayAcceptance(t, r, gatewayKey, metav1.ConditionFalse) setGatewayAddresses(t, r, gatewayKey, nil) reconcileRetentionRoute(t, r, haKey) @@ -204,6 +468,79 @@ func TestGatewayEndpointRecordSetRevokesExplicitFalseAndForeignGateway(t *testin }) } +func TestGatewayEndpointRecordSetAddsUnreceiptedHostnameOnlyWhenAccepted(t *testing.T) { + for _, status := range []metav1.ConditionStatus{metav1.ConditionFalse, metav1.ConditionUnknown} { + t.Run(string(status), func(t *testing.T) { + ctx := context.Background() + r, _, routeKey, _, recordKey := retentionFixture(t, false) + var route gatewayv1.HTTPRoute + if err := r.Get(ctx, routeKey, &route); err != nil { + t.Fatal(err) + } + route.Spec.Hostnames = append(route.Spec.Hostnames, "new.example.com") + route.Generation++ + if err := r.Update(ctx, &route); err != nil { + t.Fatal(err) + } + setRouteAcceptance(t, r, routeKey, status) + reconcileRetentionRoute(t, r, routeKey) + assertRetentionRecord(t, r, recordKey, []string{"ha.example.com"}, "192.0.2.1") + + setRouteAcceptance(t, r, routeKey, metav1.ConditionTrue) + reconcileRetentionRoute(t, r, routeKey) + assertRetentionRecord(t, r, recordKey, []string{"ha.example.com", "new.example.com"}, "192.0.2.1") + }) + } +} + +func TestGatewayEndpointRecordSetWithdrawsUnacceptedIntentOrIdentityRemoval(t *testing.T) { + for _, status := range []metav1.ConditionStatus{metav1.ConditionFalse, metav1.ConditionUnknown} { + for _, removal := range []string{"hostname", "parentRef", "route", "route UID"} { + t.Run(string(status)+"/"+removal, func(t *testing.T) { + ctx := context.Background() + r, _, routeKey, _, recordKey := retentionFixture(t, false) + setRouteAcceptance(t, r, routeKey, status) + var route gatewayv1.HTTPRoute + if err := r.Get(ctx, routeKey, &route); err != nil { + t.Fatal(err) + } + switch removal { + case "hostname": + route.Spec.Hostnames = nil + case "parentRef": + route.Spec.ParentRefs = nil + case "route": + deleteRoute(t, r, routeKey) + case "route UID": + route.Finalizers = nil + if err := r.Update(ctx, &route); err != nil { + t.Fatal(err) + } + if err := r.Delete(ctx, &route); err != nil { + t.Fatal(err) + } + replacement := retentionRoute(route.Namespace, route.Name, "replacement-route", "ha.example.com", status) + if err := r.Create(ctx, replacement); err != nil { + t.Fatal(err) + } + } + if removal == "hostname" || removal == "parentRef" { + route.Generation++ + if err := r.Update(ctx, &route); err != nil { + t.Fatal(err) + } + setRouteAcceptance(t, r, routeKey, status) + } + reconcileRetentionRoute(t, r, routeKey) + var record endpointv1alpha1.EndpointRecordSet + if err := r.Get(ctx, recordKey, &record); err != nil || record.DeletionTimestamp.IsZero() { + t.Fatalf("removed %s retained DNS intent: %v", removal, err) + } + }) + } + } +} + func TestGatewayEndpointRecordSetDoesNotPublishUnreceiptedHostnameDuringAddressLoss(t *testing.T) { ctx := context.Background() r, _, haKey, gatewayKey, recordKey := retentionFixture(t, false) @@ -450,6 +787,9 @@ func assertRetentionRecord(t *testing.T, r *Reconciler, key client.ObjectKey, ho if err := r.Get(context.Background(), key, &record); err != nil { t.Fatal(err) } + if !record.DeletionTimestamp.IsZero() { + t.Fatal("retained EndpointRecordSet is being deleted") + } if len(record.Spec.Hostnames) != len(hostnames) { t.Fatalf("hostnames = %#v, want %#v", record.Spec.Hostnames, hostnames) } From 2543d5847c3079e7edcfd165943a11b9614544d1 Mon Sep 17 00:00:00 2001 From: reoring Date: Fri, 13 Nov 2026 10:03:31 +0900 Subject: [PATCH 2/2] docs: the platform design record is ADR-0083 --- docs/design/gateway-api-integration.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/design/gateway-api-integration.md b/docs/design/gateway-api-integration.md index 47efcdd..5afbccf 100644 --- a/docs/design/gateway-api-integration.md +++ b/docs/design/gateway-api-integration.md @@ -165,7 +165,7 @@ stale conditions, it may retain a hostname with a matching admission receipt only when the listener allows unknown retention. None of these states authorizes a new hostname. -This follows [appthrust/platform ADR-0082, D4](https://github.com/appthrust/platform/blob/main/design/platform/adr-0082-publication-continuity.md): +This follows [appthrust/platform ADR-0083, D4](https://github.com/appthrust/platform/blob/main/design/platform/adr-0083-publication-continuity.md): route admission and policy staging control serving permission, not publication intent. Withdrawing an established name during those transitions can send users to an estate wildcard with the wrong certificate; DNS withdrawal is not a