Release v0.2.2

Author: reoring

deploy/charts/dns-api/Chart.yaml

@@ -2,6 +2,6 @@ apiVersion: v2
 name: dns-api
 description: Kubernetes DNS API controller for Route 53 and Cloudflare
 type: application
-version: 0.2.1
-appVersion: "0.2.1"
+version: 0.2.2
+appVersion: "0.2.2"
 kubeVersion: ">=1.22.0-0"

internal/go/providers/route53/controllers/zoneunit/recordset.go

@@ -686,8 +686,12 @@ func route53RecordSetEqual(a, b RecordSetResource) bool {
 	if (a.Alias == nil) != (b.Alias == nil) {
 		return false
 	}
-	if a.Alias != nil && b.Alias != nil && *a.Alias != *b.Alias {
-		return false
+	if a.Alias != nil && b.Alias != nil {
+		if normalizeRoute53RecordName(a.Alias.DNSName) != normalizeRoute53RecordName(b.Alias.DNSName) ||
+			normalizeHostedZoneID(a.Alias.HostedZoneID) != normalizeHostedZoneID(b.Alias.HostedZoneID) ||
+			a.Alias.EvaluateTargetHealth != b.Alias.EvaluateTargetHealth {
+			return false
+		}
 	}
 	aValues, ok := canonicalRecordSetValues(a.Type, a.Values)
 	if !ok {

internal/go/providers/route53/controllers/zoneunit/zone_test.go

@@ -1745,6 +1745,60 @@ func TestZoneReconcilerUpsertsRoute53AliasRecordSet(t *testing.T) {
 	}
 }
 
+func TestZoneReconcilerAdoptsMatchingRoute53AliasRecordSet(t *testing.T) {
+	ctx := context.Background()
+	scheme := testScheme(t)
+	provider := newFakeProvider()
+	provider.zones["Z000001"] = HostedZone{
+		ID:              "Z000001",
+		Name:            "apps.example.com",
+		CallerReference: "dns-api:11111111-2222-3333-4444-555555555555",
+		NameServers:     []string{"ns-1.awsdns.example", "ns-2.awsdns.example"},
+	}
+	provider.records[recordKey("Z000001", "alias.apps.example.com.", dnsv1alpha1.RecordTypeA)] = RecordSetResource{
+		HostedZoneID: "Z000001",
+		Name:         "alias.apps.example.com.",
+		Type:         dnsv1alpha1.RecordTypeA,
+		Alias: &route53v1alpha1.Route53AliasTarget{
+			DNSName:              "target.apps.example.com",
+			HostedZoneID:         "/hostedzone/Z000001",
+			EvaluateTargetHealth: false,
+		},
+	}
+	recordSet := route53AliasARecordSet("app", "alias")
+	recordSet.Spec.Adoption = runtime.RawExtension{Raw: []byte(`{"enabled":true}`)}
+	objects := route53RecordSetObjects(t, recordSet)
+	k8sClient := fake.NewClientBuilder().
+		WithScheme(scheme).
+		WithObjects(objects...).
+		WithStatusSubresource(&dnsv1alpha1.Zone{}, &dnsv1alpha1.RecordSet{}, &dnsv1alpha1.ZoneClass{}, &route53v1alpha1.Route53Identity{}, &dnsv1alpha1.ZoneUnit{}).
+		Build()
+	reconciler := &ZoneReconciler{Client: k8sClient, Provider: provider}
+
+	result, err := reconcileRoute53AndProject(t, ctx, k8sClient, reconciler, ctrl.Request{NamespacedName: types.NamespacedName{Namespace: "app", Name: "apps-example-com"}})
+	if err != nil {
+		t.Fatalf("Reconcile returned error: %v", err)
+	}
+	if result.Requeue {
+		t.Fatalf("Reconcile result = %#v, want no immediate requeue", result)
+	}
+	if len(provider.upserted) != 0 {
+		t.Fatalf("upserted record sets = %d, want 0", len(provider.upserted))
+	}
+
+	var unit dnsv1alpha1.ZoneUnit
+	if err := k8sClient.Get(ctx, client.ObjectKey{Namespace: "app", Name: "apps-example-com"}, &unit); err != nil {
+		t.Fatalf("ZoneUnit was not found: %v", err)
+	}
+	index := slices.IndexFunc(unit.Status.RecordSets, func(status dnsv1alpha1.ZoneUnitRecordSetStatus) bool {
+		return status.RecordSetNamespace == recordSet.Namespace && status.RecordSetName == recordSet.Name
+	})
+	if index < 0 {
+		t.Fatalf("ZoneUnit status.recordSets has no entry for %s/%s: %#v", recordSet.Namespace, recordSet.Name, unit.Status.RecordSets)
+	}
+	assertCondition(t, unit.Status.RecordSets[index].Conditions, string(dnsv1alpha1.ConditionProgrammed), metav1.ConditionTrue, "Programmed")
+}
+
 func TestZoneReconcilerRejectsRecordSetWhenCNAMEZoneUnitItemOwnsSameName(t *testing.T) {
 	ctx := context.Background()
 	scheme := testScheme(t)

internal/go/providers/route53/conversion/alias.go

@@ -96,6 +96,9 @@ func route53CanonicalHostedZone(hostname string) string {
 }
 
 func normalizeRoute53AliasDNSName(hostname string) string {
-	trimmed := strings.TrimSuffix(hostname, ".")
+	trimmed := strings.TrimSuffix(strings.ToLower(strings.TrimSpace(hostname)), ".")
+	if route53CanonicalHostedZone(trimmed) != "" && !strings.HasPrefix(trimmed, "dualstack.") {
+		trimmed = "dualstack." + trimmed
+	}
 	return trimmed + "."
 }

internal/go/providers/route53/conversion/handler_test.go

@@ -65,13 +65,57 @@ func TestHandlerConvertsELBHostnameToAliasAAndAAAA(t *testing.T) {
 		t.Fatalf("decode options: %v", err)
 	}
 	if options.Alias == nil ||
-		options.Alias.DNSName != "k8s-public-123456.ap-northeast-1.elb.amazonaws.com." ||
+		options.Alias.DNSName != "dualstack.k8s-public-123456.ap-northeast-1.elb.amazonaws.com." ||
 		options.Alias.HostedZoneID != "Z14GRHDCWA56QT" ||
 		options.Alias.EvaluateTargetHealth {
 		t.Fatalf("alias = %#v", options.Alias)
 	}
 }
 
+func TestHandlerPreservesExistingELBDualstackAliasPrefix(t *testing.T) {
+	review := endpointconversionv1alpha1.EndpointRecordSetConversion{
+		TypeMeta: metav1.TypeMeta{APIVersion: GroupName + "/" + Version, Kind: "EndpointRecordSetConversion"},
+		Spec: endpointconversionv1alpha1.EndpointRecordSetConversionSpec{
+			UID: "request-1",
+			Input: endpointv1alpha1.EndpointRecordSetConversionInput{
+				Hostname: "api.example.com",
+				Name:     "api",
+				Zone:     endpointv1alpha1.EndpointRecordSetConversionZone{DomainName: "example.com"},
+				Targets: []endpointv1alpha1.EndpointTarget{{
+					Type:  endpointv1alpha1.EndpointTargetTypeHostname,
+					Value: "dualstack.k8s-public-123456.ap-northeast-1.elb.amazonaws.com.",
+				}},
+			},
+		},
+	}
+	body, err := json.Marshal(review)
+	if err != nil {
+		t.Fatalf("marshal review: %v", err)
+	}
+	request := httptest.NewRequest(http.MethodPost, "/apis/"+GroupName+"/"+Version+"/"+Resource, bytes.NewReader(body))
+	response := httptest.NewRecorder()
+
+	NewHandler().ServeHTTP(response, request)
+
+	if response.Code != http.StatusCreated {
+		t.Fatalf("status = %d, body = %s", response.Code, response.Body.String())
+	}
+	var got endpointconversionv1alpha1.EndpointRecordSetConversion
+	if err := json.NewDecoder(response.Body).Decode(&got); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got.Status.Output == nil || len(got.Status.Output.Fragments) == 0 {
+		t.Fatalf("fragments = %#v, want output", got.Status.Output)
+	}
+	var options route53v1alpha1.Route53RecordSetOptions
+	if err := json.Unmarshal(got.Status.Output.Fragments[0].Options.Raw, &options); err != nil {
+		t.Fatalf("decode options: %v", err)
+	}
+	if options.Alias == nil || options.Alias.DNSName != "dualstack.k8s-public-123456.ap-northeast-1.elb.amazonaws.com." {
+		t.Fatalf("alias = %#v", options.Alias)
+	}
+}
+
 func TestHandlerRejectsUnknownHostnameTarget(t *testing.T) {
 	review := endpointconversionv1alpha1.EndpointRecordSetConversion{
 		Spec: endpointconversionv1alpha1.EndpointRecordSetConversionSpec{