fix: support tlsSecret from http.backends in ApisixRoute

internal/controller/apisixroute_controller.go

@@ -285,6 +285,43 @@ func (r *ApisixRouteReconciler) validateSecrets(ctx context.Context, tc *provide
 	return nil
 }
 
+func (r *ApisixRouteReconciler) processExternalNodes(ctx context.Context, tc *provider.TranslateContext, ups apiv2.ApisixUpstream) error {
+	for _, node := range ups.Spec.ExternalNodes {
+		if node.Type == apiv2.ExternalTypeService {
+			var (
+				service   corev1.Service
+				serviceNN = k8stypes.NamespacedName{Namespace: ups.GetNamespace(), Name: node.Name}
+			)
+			if err := r.Get(ctx, serviceNN, &service); err != nil {
+				r.Log.Error(err, "failed to get service in ApisixUpstream", "ApisixUpstream", ups.Name, "Service", serviceNN)
+				if client.IgnoreNotFound(err) == nil {
+					continue
+				}
+				return err
+			}
+			tc.Services[utils.NamespacedName(&service)] = &service
+		}
+	}
+	return nil
+}
+
+func (r *ApisixRouteReconciler) processTLSSecret(ctx context.Context, tc *provider.TranslateContext, ups apiv2.ApisixUpstream, secretNs string) error {
+	if ups.Spec.TLSSecret != nil && ups.Spec.TLSSecret.Name != "" {
+		var (
+			secret   corev1.Secret
+			secretNN = k8stypes.NamespacedName{Namespace: cmp.Or(ups.Spec.TLSSecret.Namespace, secretNs), Name: ups.Spec.TLSSecret.Name}
+		)
+		if err := r.Get(ctx, secretNN, &secret); err != nil {
+			r.Log.Error(err, "failed to get secret in ApisixUpstream", "ApisixUpstream", ups.Name, "Secret", secretNN)
+			if client.IgnoreNotFound(err) != nil {
+				return err
+			}
+		}
+		tc.Secrets[secretNN] = &secret
+	}
+	return nil
+}
+
 func (r *ApisixRouteReconciler) validateBackends(ctx context.Context, tc *provider.TranslateContext, in *apiv2.ApisixRoute, http apiv2.ApisixRouteHTTP) error {
 	var backends = make(map[k8stypes.NamespacedName]struct{})
 	for _, backend := range http.Backends {
@@ -321,6 +358,12 @@ func (r *ApisixRouteReconciler) validateBackends(ctx context.Context, tc *provid
 			}
 		} else {
 			tc.Upstreams[serviceNN] = &au
+			if err = r.processExternalNodes(ctx, tc, au); err != nil {
+				return err
+			}
+			if err := r.processTLSSecret(ctx, tc, au, in.GetNamespace()); err != nil {
+				return err
+			}
 		}
 
 		if service.Spec.Type == corev1.ServiceTypeExternalName {
@@ -384,35 +427,12 @@ func (r *ApisixRouteReconciler) validateUpstreams(ctx context.Context, tc *provi
 		}
 		tc.Upstreams[upsNN] = &ups
 
-		for _, node := range ups.Spec.ExternalNodes {
-			if node.Type == apiv2.ExternalTypeService {
-				var (
-					service   corev1.Service
-					serviceNN = k8stypes.NamespacedName{Namespace: ups.GetNamespace(), Name: node.Name}
-				)
-				if err := r.Get(ctx, serviceNN, &service); err != nil {
-					r.Log.Error(err, "failed to get service in ApisixUpstream", "ApisixUpstream", upsNN, "Service", serviceNN)
-					if client.IgnoreNotFound(err) == nil {
-						continue
-					}
-					return err
-				}
-				tc.Services[utils.NamespacedName(&service)] = &service
-			}
+		if err := r.processExternalNodes(ctx, tc, ups); err != nil {
+			return err
 		}
 
-		if ups.Spec.TLSSecret != nil && ups.Spec.TLSSecret.Name != "" {
-			var (
-				secret   corev1.Secret
-				secretNN = k8stypes.NamespacedName{Namespace: cmp.Or(ups.Spec.TLSSecret.Namespace, ar.GetNamespace()), Name: ups.Spec.TLSSecret.Name}
-			)
-			if err := r.Get(ctx, secretNN, &secret); err != nil {
-				r.Log.Error(err, "failed to get secret in ApisixUpstream", "ApisixUpstream", upsNN, "Secret", secretNN)
-				if client.IgnoreNotFound(err) != nil {
-					return err
-				}
-			}
-			tc.Secrets[secretNN] = &secret
+		if err := r.processTLSSecret(ctx, tc, ups, ar.GetNamespace()); err != nil {
+			return err
 		}
 	}
 

test/e2e/crds/v2/route.go

@@ -25,6 +25,7 @@ import (
 	"net"
 	"net/http"
 	"net/url"
+	"strings"
 	"time"
 
 	"github.com/gorilla/websocket"
@@ -1368,4 +1369,184 @@ spec:
 			})
 		})
 	})
+	Context("Test tls secret processed from ApisixUpstream with matching backend", func() {
+		var Cert = strings.TrimSpace(framework.TestServerCert)
+		var Key = strings.TrimSpace(framework.TestServerKey)
+		createSecret := func(s *scaffold.Scaffold, secretName string) {
+			err := s.NewKubeTlsSecret(secretName, Cert, Key)
+			assert.Nil(GinkgoT(), err, "create secret error")
+		}
+		const apisixRouteSpec = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixRoute
+metadata:
+  name: default
+  namespace: %s
+spec:
+  ingressClassName: %s
+  http:
+  - name: rule0
+    match:
+      hosts:
+      - httpbin
+      paths:
+      - /*
+    backends:
+    - serviceName: httpbin-service-e2e-test
+      servicePort: 80
+
+`
+		const apisixUpstreamSpec = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixUpstream
+metadata:
+  name: httpbin-service-e2e-test
+  namespace: %s
+spec:
+  tlsSecret:
+    name: %s
+    namespace: %s
+`
+
+		It("create ApisixRoute and upstream with tlsSecret", func() {
+			secretName := fmt.Sprintf("test-tls-secret-%s", s.Namespace())
+			createSecret(s, secretName)
+			By("apply apisixupstream")
+			applier.MustApplyAPIv2(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin-service-e2e-test"},
+				new(apiv2.ApisixUpstream), fmt.Sprintf(apisixUpstreamSpec, s.Namespace(), secretName, s.Namespace()))
+			By("apply apisixroute")
+			applier.MustApplyAPIv2(types.NamespacedName{Namespace: s.Namespace(), Name: "default"},
+				new(apiv2.ApisixRoute), fmt.Sprintf(apisixRouteSpec, s.Namespace(), s.Namespace()))
+			time.Sleep(6 * time.Second)
+			services, err := s.DefaultDataplaneResource().Service().List(context.Background())
+			Expect(err).ShouldNot(HaveOccurred(), "list services")
+			service := services[0]
+			Expect(service.Upstream.TLS).ShouldNot(BeNil(), "check tls in service")
+		})
+	})
+
+	Context("Test tls secret processed from ApisixUpstream with matching upstream", func() {
+		var Cert = strings.TrimSpace(framework.TestServerCert)
+		var Key = strings.TrimSpace(framework.TestServerKey)
+		createSecret := func(s *scaffold.Scaffold, secretName string) {
+			err := s.NewKubeTlsSecret(secretName, Cert, Key)
+			assert.Nil(GinkgoT(), err, "create secret error")
+		}
+		const apisixRouteSpec = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixRoute
+metadata:
+  name: default
+  namespace: %s
+spec:
+  ingressClassName: %s
+  http:
+  - name: rule0
+    match:
+      hosts:
+      - httpbin
+      paths:
+      - /*
+    upstreams:
+    - name: httpbin-service-e2e-test
+`
+		const apisixUpstreamSpec = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixUpstream
+metadata:
+  name: httpbin-service-e2e-test
+  namespace: %s
+spec:
+  tlsSecret:
+    name: %s
+    namespace: %s
+`
+
+		It("create ApisixRoute and upstream with tlsSecret", func() {
+			secretName := fmt.Sprintf("test-tls-secret-%s", s.Namespace())
+			createSecret(s, secretName)
+			By("apply apisixupstream")
+			applier.MustApplyAPIv2(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin-service-e2e-test"},
+				new(apiv2.ApisixUpstream), fmt.Sprintf(apisixUpstreamSpec, s.Namespace(), secretName, s.Namespace()))
+			By("apply apisixroute")
+			applier.MustApplyAPIv2(types.NamespacedName{Namespace: s.Namespace(), Name: "default"},
+				new(apiv2.ApisixRoute), fmt.Sprintf(apisixRouteSpec, s.Namespace(), s.Namespace()))
+			time.Sleep(6 * time.Second)
+			services, err := s.DefaultDataplaneResource().Service().List(context.Background())
+			Expect(err).ShouldNot(HaveOccurred(), "list services")
+			service := services[0]
+			Expect(service.Upstream.TLS).ShouldNot(BeNil(), "check tls in service")
+		})
+	})
+
+	Context("Test external nodes processed from ApisixUpstream with matching backend", func() {
+		It("Test reference ApisixUpstream", func() {
+			const apisixRouteSpec = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixRoute
+metadata:
+  name: default
+  namespace: %s
+spec:
+  ingressClassName: %s
+  http:
+  - name: rule0
+    match:
+      paths:
+      - /*
+    backends:
+    - serviceName: httpbin-service-e2e-test
+      servicePort: 80
+`
+			const apisixUpstreamSpec0 = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixUpstream
+metadata:
+  name: default-upstream
+  namespace: %s
+spec:
+  ingressClassName: %s
+  externalNodes:
+  - type: Service
+    name: httpbin-service-e2e-test
+`
+			const apisixUpstreamSpec1 = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixUpstream
+metadata:
+  name: default-upstream
+  namespace: %s
+spec:
+  ingressClassName: %s
+  externalNodes:
+  - type: Service
+    name: alias-httpbin-service-e2e-test
+`
+			const serviceSpec = `
+apiVersion: v1
+kind: Service
+metadata:
+  name: alias-httpbin-service-e2e-test
+spec:
+  type: ExternalName
+  externalName: httpbin-service-e2e-test
+`
+			By("create Service, ApisixUpstream and ApisixRoute")
+			err := s.CreateResourceFromStringWithNamespace(serviceSpec, s.Namespace())
+			Expect(err).ShouldNot(HaveOccurred(), "apply service")
+			applier.MustApplyAPIv2(types.NamespacedName{Namespace: s.Namespace(), Name: "default-upstream"},
+				new(apiv2.ApisixUpstream), fmt.Sprintf(apisixUpstreamSpec0, s.Namespace(), s.Namespace()))
+
+			applier.MustApplyAPIv2(types.NamespacedName{Namespace: s.Namespace(), Name: "default"},
+				new(apiv2.ApisixRoute), fmt.Sprintf(apisixRouteSpec, s.Namespace(), s.Namespace()))
+
+			request := func(path string) int {
+				return s.NewAPISIXClient().GET(path).WithHost("httpbin").Expect().Raw().StatusCode
+			}
+			By("verify that ApisixUpstream reference a Service which is ExternalName should request OK")
+			applier.MustApplyAPIv2(types.NamespacedName{Namespace: s.Namespace(), Name: "default-upstream"},
+				new(apiv2.ApisixUpstream), fmt.Sprintf(apisixUpstreamSpec1, s.Namespace(), s.Namespace()))
+			Eventually(request).WithArguments("/get").WithTimeout(30 * time.Second).ProbeEvery(1 * time.Second).Should(Equal(http.StatusOK))
+		})
+	})
 })