wip: try restoring LB DNS check

Author: damdo

controllers/awscluster_controller.go

@@ -19,6 +19,7 @@ package controllers
 import (
 	"context"
 	"fmt"
+	"net"
 	"time"
 
 	"github.com/pkg/errors"
@@ -303,6 +304,14 @@ func (r *AWSClusterReconciler) reconcileLoadBalancer(ctx context.Context, cluste
 		return &retryAfterDuration, nil
 	}
 
+	clusterScope.Debug("Looking up IP address for DNS", "dns", awsCluster.Status.Network.APIServerELB.DNSName)
+	if _, err := net.LookupIP(awsCluster.Status.Network.APIServerELB.DNSName); err != nil {
+		clusterScope.Error(err, "failed to get IP address for dns name", "dns", awsCluster.Status.Network.APIServerELB.DNSName)
+		v1beta1conditions.MarkFalse(awsCluster, infrav1.LoadBalancerReadyCondition, infrav1.WaitForDNSNameResolveReason, clusterv1beta1.ConditionSeverityInfo, "")
+		clusterScope.Info("Waiting on API server ELB DNS name to resolve")
+		return &retryAfterDuration, nil
+	}
+
 	v1beta1conditions.MarkTrue(awsCluster, infrav1.LoadBalancerReadyCondition)
 
 	awsCluster.Spec.ControlPlaneEndpoint = clusterv1beta1.APIEndpoint{

controllers/awscluster_controller_unit_test.go

@@ -403,6 +403,31 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 				g.Expect(err).To(BeNil())
 				expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{{infrav1.LoadBalancerReadyCondition, corev1.ConditionFalse, clusterv1beta1.ConditionSeverityInfo, infrav1.WaitForDNSNameReason}})
 			})
+			t.Run("Should fail AWSCluster create with LoadBalancer reconcile failure with WaitForDNSNameResolve condition as false", func(t *testing.T) {
+				g := NewWithT(t)
+				awsCluster := getAWSCluster("test", "test")
+				runningCluster := func() {
+					networkSvc.EXPECT().ReconcileNetwork().Return(nil)
+					sgSvc.EXPECT().ReconcileSecurityGroups().Return(nil)
+					ec2Svc.EXPECT().ReconcileBastion().Return(nil)
+					elbSvc.EXPECT().ReconcileLoadbalancers(gomock.Any()).Return(nil)
+				}
+				csClient := setup(t, &awsCluster)
+				defer teardown()
+				runningCluster()
+				cs, err := scope.NewClusterScope(
+					scope.ClusterScopeParams{
+						Client:     csClient,
+						Cluster:    &clusterv1.Cluster{},
+						AWSCluster: &awsCluster,
+					},
+				)
+				awsCluster.Status.Network.APIServerELB.DNSName = "test-apiserver.us-east-1.aws"
+				g.Expect(err).To(BeNil())
+				_, err = reconciler.reconcileNormal(context.TODO(), cs)
+				g.Expect(err).To(BeNil())
+				expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{{infrav1.LoadBalancerReadyCondition, corev1.ConditionFalse, clusterv1beta1.ConditionSeverityInfo, infrav1.WaitForDNSNameResolveReason}})
+			})
 		})
 	})
 	t.Run("Reconcile delete AWSCluster", func(t *testing.T) {

controllers/helpers_test.go

@@ -302,9 +302,6 @@ func mockedCreateLBV2Calls(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 		LoadBalancerArn: lbArn,
 		SecurityGroups:  []string{"sg-apiserver-lb"},
 	})).MaxTimes(1)
-	m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-		LoadBalancerArns: []string{aws.ToString(lbArn)},
-	}), maxWaitActiveUpdateDelete).MaxTimes(1)
 }
 
 func mockedDescribeTargetGroupsCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {

pkg/cloud/services/elb/loadbalancer.go

@@ -157,17 +157,6 @@ func (s *Service) getOrCreateV2LB(ctx context.Context, lbSpec *infrav1.AWSLoadBa
 }
 
 func (s *Service) reconcileV2LB(ctx context.Context, lb *infrav1.LoadBalancer, desiredLB *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBalancerSpec) error {
-	wReq := &elbv2.DescribeLoadBalancersInput{
-		LoadBalancerArns: []string{lb.ARN},
-	}
-	s.scope.Debug("Waiting for LB to become active", "api-server-lb-name", lb.Name)
-	waitStart := time.Now()
-	if err := s.ELBV2Client.WaitUntilLoadBalancerAvailable(ctx, wReq, s.scope.MaxWaitDuration()); err != nil {
-		s.scope.Error(err, "failed to wait for LB to become available", "time", time.Since(waitStart))
-		return err
-	}
-	s.scope.Debug("LB reports active state", "api-server-lb-name", lb.Name, "time", time.Since(waitStart))
-
 	// set up the type for later processing
 	lb.LoadBalancerType = lbSpec.LoadBalancerType
 	if lb.IsManaged(s.scope.Name()) {

pkg/cloud/services/elb/loadbalancer_test.go

@@ -2361,9 +2361,6 @@ func TestReconcileV2LB(t *testing.T) {
 					},
 					nil,
 				)
-				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: []string{elbArn},
-				}), maxWaitActiveUpdateDelete).Return(nil)
 			},
 			check: func(t *testing.T, lb *infrav1.LoadBalancer, err error) {
 				t.Helper()
@@ -2575,10 +2572,6 @@ func TestReconcileV2LB(t *testing.T) {
 				m.SetSubnets(gomock.Any(), gomock.Eq(&elbv2.SetSubnetsInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).Return(&elbv2.SetSubnetsOutput{}, nil)
-
-				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: []string{elbArn},
-				}), maxWaitActiveUpdateDelete).Return(nil)
 			},
 			check: func(t *testing.T, lb *infrav1.LoadBalancer, err error) {
 				t.Helper()
@@ -2773,12 +2766,6 @@ func TestReconcileLoadbalancers(t *testing.T) {
 					},
 					nil,
 				)
-				m.WaitUntilLoadBalancerAvailable(gomock.Any(), &elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: []string{elbArn},
-				}, maxWaitActiveUpdateDelete).Return(nil)
-				m.WaitUntilLoadBalancerAvailable(gomock.Any(), &elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: []string{secondElbArn},
-				}, maxWaitActiveUpdateDelete).Return(nil)
 			},
 			check: func(t *testing.T, firstLB *infrav1.LoadBalancer, secondLB *infrav1.LoadBalancer, err error) {
 				t.Helper()
@@ -2815,7 +2802,7 @@ func TestReconcileLoadbalancers(t *testing.T) {
 				})).Return(&elbv2.DescribeLoadBalancersOutput{}, nil)
 
 				// Create both load balancers
-				createLB1 := m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
+				m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
 					Name:           aws.String(elbName),
 					Scheme:         SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
 					SecurityGroups: []string{""},
@@ -2838,7 +2825,7 @@ func TestReconcileLoadbalancers(t *testing.T) {
 					LoadBalancers: []elbv2types.LoadBalancer{primaryELB()},
 				}, nil)
 
-				createLB2 := m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
+				m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
 					Name:           aws.String(secondElbName),
 					Scheme:         SchemeToSDKScheme(infrav1.ELBSchemeInternal),
 					SecurityGroups: []string{""},
@@ -2861,15 +2848,6 @@ func TestReconcileLoadbalancers(t *testing.T) {
 					LoadBalancers: []elbv2types.LoadBalancer{secondaryELB()},
 				}, nil)
 
-				// Assert that we don't wait for either load balancer to be
-				// available until both load balancers have been created
-				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: []string{elbArn},
-				}), maxWaitActiveUpdateDelete).Return(nil).After(createLB1).After(createLB2)
-				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: []string{secondElbArn},
-				}), maxWaitActiveUpdateDelete).Return(nil).After(createLB1).After(createLB2)
-
 				// Make minimal assertions on other calls not under test
 				m.DescribeTargetGroups(gomock.Any(), gomock.Any()).Return(&elbv2.DescribeTargetGroupsOutput{}, nil).AnyTimes()
 				m.DescribeListeners(gomock.Any(), gomock.Any()).Return(&elbv2.DescribeListenersOutput{}, nil).AnyTimes()