Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

fix: refresh the load balancer object after updating backend pools to… #4839

Merged
merged 1 commit into from
Oct 26, 2023
Merged

fix: refresh the load balancer object after updating backend pools to… #4839

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
17 changes: 7 additions & 10 deletions pkg/provider/azure_loadbalancer.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1641,25 +1641,22 @@ func (az *Cloud) reconcileLoadBalancer(clusterName string, service *v1.Service,

// reconcile the load balancer's backend pool configuration.
if wantLb {
preConfig, changed, shouldRefreshLB, err := az.LoadBalancerBackendPool.ReconcileBackendPools(clusterName, service, lb)
var (
preConfig, backendPoolsUpdated bool
err error
)
preConfig, backendPoolsUpdated, lb, err = az.LoadBalancerBackendPool.ReconcileBackendPools(clusterName, service, lb)
if err != nil {
return lb, err
}
if changed {
if backendPoolsUpdated {
dirtyLb = true
}
isBackendPoolPreConfigured = preConfig

// If the LB is changed, refresh it to avoid etag mismatch error
// later when create or update the LB.
if shouldRefreshLB {
klog.V(4).Infof("reconcileLoadBalancer for service(%s): refreshing load balancer %s", serviceName, lbName)
lb, _, err = az.getAzureLoadBalancer(lbName, azcache.CacheReadTypeForceRefresh)
if err != nil {
return lb, fmt.Errorf("reconcileLoadBalancer for service (%s): failed to get load balancer %s: %w", serviceName, lbName, err)
}
addOrUpdateLBInList(existingLBs, lb)
}
addOrUpdateLBInList(existingLBs, lb)
}

// reconcile the load balancer's frontend IP configurations.
Expand Down
54 changes: 33 additions & 21 deletions pkg/provider/azure_loadbalancer_backendpool.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -52,7 +52,7 @@ type BackendPool interface {

// ReconcileBackendPools creates the inbound backend pool if it is not existed, and removes nodes that are supposed to be
// excluded from the load balancers.
ReconcileBackendPools(clusterName string, service *v1.Service, lb *network.LoadBalancer) (bool, bool, bool, error)
ReconcileBackendPools(clusterName string, service *v1.Service, lb *network.LoadBalancer) (bool, bool, *network.LoadBalancer, error)

// GetBackendPrivateIPs returns the private IPs of LoadBalancer's backend pool
GetBackendPrivateIPs(clusterName string, service *v1.Service, lb *network.LoadBalancer) ([]string, []string)
Expand Down Expand Up @@ -157,14 +157,18 @@ func (bc *backendPoolTypeNodeIPConfig) CleanupVMSetFromBackendPoolByCondition(sl
return slb, nil
}

func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string, service *v1.Service, lb *network.LoadBalancer) (bool, bool, bool, error) {
func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(
clusterName string,
service *v1.Service,
lb *network.LoadBalancer,
) (bool, bool, *network.LoadBalancer, error) {
var newBackendPools []network.BackendAddressPool
var err error
if lb.BackendAddressPools != nil {
newBackendPools = *lb.BackendAddressPools
}

var changed, shouldRefreshLB, isOperationSucceeded, isMigration bool
var backendPoolsCreated, backendPoolsUpdated, isOperationSucceeded, isMigration bool
foundBackendPools := map[bool]bool{}
lbName := *lb.Name

Expand Down Expand Up @@ -201,11 +205,11 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
bp.VirtualNetwork = nil
if err := bc.CreateOrUpdateLBBackendPool(lbName, bp); err != nil {
klog.Errorf("bc.ReconcileBackendPools for service (%s): failed to cleanup IP based backend pool %s: %s", serviceName, lbBackendPoolNames[isIPv6], err.Error())
return false, false, false, fmt.Errorf("bc.ReconcileBackendPools for service (%s): failed to cleanup IP based backend pool %s: %w", serviceName, lbBackendPoolNames[isIPv6], err)
return false, false, nil, fmt.Errorf("bc.ReconcileBackendPools for service (%s): failed to cleanup IP based backend pool %s: %w", serviceName, lbBackendPoolNames[isIPv6], err)
}
newBackendPools[i] = bp
lb.BackendAddressPools = &newBackendPools
shouldRefreshLB = true
backendPoolsUpdated = true
}
}

Expand All @@ -219,7 +223,7 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
klog.V(2).Infof("bc.ReconcileBackendPools for service (%s): vm not found for ipConfID %s", serviceName, ipConfID)
bipConfigNotFound = append(bipConfigNotFound, ipConf)
} else {
return false, false, false, err
return false, false, nil, err
}
}

Expand All @@ -230,7 +234,7 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
shouldExcludeLoadBalancer, err := bc.ShouldNodeExcludedFromLoadBalancer(nodeName)
if err != nil {
klog.Errorf("bc.ReconcileBackendPools: ShouldNodeExcludedFromLoadBalancer(%s) failed with error: %v", nodeName, err)
return false, false, false, err
return false, false, nil, err
}
if shouldExcludeLoadBalancer {
klog.V(2).Infof("bc.ReconcileBackendPools for service (%s): lb backendpool - found unwanted node %s, decouple it from the LB %s", serviceName, nodeName, lbName)
Expand All @@ -257,17 +261,18 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
// decouple the backendPool from the node
updated, err := bc.VMSet.EnsureBackendPoolDeleted(service, lbBackendPoolIDsSlice, vmSetName, &backendpoolToBeDeleted, false)
if err != nil {
return false, false, false, err
return false, false, nil, err
}
if updated {
shouldRefreshLB = true
backendPoolsUpdated = true
}
}

if shouldRefreshLB {
if backendPoolsUpdated {
klog.V(4).Infof("bc.ReconcileBackendPools for service(%s): refreshing load balancer %s", serviceName, lbName)
lb, _, err = bc.getAzureLoadBalancer(lbName, cache.CacheReadTypeForceRefresh)
if err != nil {
return false, false, false, fmt.Errorf("bc.ReconcileBackendPools for service (%s): failed to get loadbalancer %s: %w", serviceName, lbName, err)
return false, false, nil, fmt.Errorf("bc.ReconcileBackendPools for service (%s): failed to get loadbalancer %s: %w", serviceName, lbName, err)
}
}

Expand All @@ -278,7 +283,7 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
isBackendPoolPreConfigured = newBackendPool(lb, isBackendPoolPreConfigured,
bc.PreConfiguredBackendPoolLoadBalancerTypes, serviceName,
lbBackendPoolNames[ipFamily == v1.IPv6Protocol])
changed = true
backendPoolsCreated = true
}

if isMigration {
Expand All @@ -288,7 +293,7 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
}

isOperationSucceeded = true
return isBackendPoolPreConfigured, changed, false, err
return isBackendPoolPreConfigured, backendPoolsCreated, lb, err
}

func getBackendIPConfigurationsToBeDeleted(
Expand Down Expand Up @@ -561,13 +566,13 @@ func (bi *backendPoolTypeNodeIP) CleanupVMSetFromBackendPoolByCondition(slb *net
return slb, nil
}

func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, service *v1.Service, lb *network.LoadBalancer) (bool, bool, bool, error) {
func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, service *v1.Service, lb *network.LoadBalancer) (bool, bool, *network.LoadBalancer, error) {
var newBackendPools []network.BackendAddressPool
if lb.BackendAddressPools != nil {
newBackendPools = *lb.BackendAddressPools
}

var changed, shouldRefreshLB, isOperationSucceeded, isMigration, updated bool
var backendPoolsUpdated, shouldRefreshLB, isOperationSucceeded, isMigration, updated bool
foundBackendPools := map[bool]bool{}
lbName := *lb.Name
serviceName := getServiceName(service)
Expand Down Expand Up @@ -626,15 +631,15 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
name, err := getLBNameFromBackendPoolID(id)
if err != nil {
klog.Errorf("bi.ReconcileBackendPools for service (%s): failed to get LB name from backend pool ID: %s", serviceName, err.Error())
return false, false, false, err
return false, false, nil, err
}
backendPoolNames = append(backendPoolNames, name)
}

if err := bi.MigrateToIPBasedBackendPoolAndWaitForCompletion(lbName, backendPoolNames, nicsCountMap); err != nil {
backendPoolNamesStr := strings.Join(backendPoolNames, ",")
klog.Errorf("Failed to migrate to IP based backend pool for lb %s, backend pool %s: %s", lbName, backendPoolNamesStr, err.Error())
return false, false, false, err
return false, false, nil, err
}
}

Expand All @@ -651,7 +656,7 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
shouldRefreshLB, err = bi.VMSet.EnsureBackendPoolDeleted(service, lbBackendPoolIDsSlice, vmSetName, lb.BackendAddressPools, true)
if err != nil {
klog.Errorf("bi.ReconcileBackendPools for service (%s): failed to EnsureBackendPoolDeleted: %s", serviceName, err.Error())
return false, false, false, err
return false, false, nil, err
}

for _, i := range bpIdxes {
Expand Down Expand Up @@ -696,14 +701,21 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
if updated {
(*lb.BackendAddressPools)[i] = bp
if err := bi.CreateOrUpdateLBBackendPool(lbName, bp); err != nil {
return false, false, false, fmt.Errorf("bi.ReconcileBackendPools for service (%s): lb backendpool - failed to update backend pool %s for load balancer %s: %w", serviceName, pointer.StringDeref(bp.Name, ""), lbName, err)
return false, false, nil, fmt.Errorf("bi.ReconcileBackendPools for service (%s): lb backendpool - failed to update backend pool %s for load balancer %s: %w", serviceName, pointer.StringDeref(bp.Name, ""), lbName, err)
}
shouldRefreshLB = true
}
}
}

shouldRefreshLB = shouldRefreshLB || isMigration
if shouldRefreshLB {
klog.V(4).Infof("bi.ReconcileBackendPools for service(%s): refreshing load balancer %s", serviceName, lbName)
lb, _, err = bi.getAzureLoadBalancer(lbName, cache.CacheReadTypeForceRefresh)
if err != nil {
return false, false, nil, fmt.Errorf("bi.ReconcileBackendPools for service (%s): failed to get loadbalancer %s: %w", serviceName, lbName, err)
}
}

for _, ipFamily := range service.Spec.IPFamilies {
if foundBackendPools[ipFamily == v1.IPv6Protocol] {
Expand All @@ -712,7 +724,7 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
isBackendPoolPreConfigured = newBackendPool(lb, isBackendPoolPreConfigured,
bi.PreConfiguredBackendPoolLoadBalancerTypes, serviceName,
lbBackendPoolNames[ipFamily == v1.IPv6Protocol])
changed = true
backendPoolsUpdated = true
}

if isMigration {
Expand All @@ -722,7 +734,7 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
}

isOperationSucceeded = true
return isBackendPoolPreConfigured, changed, shouldRefreshLB, nil
return isBackendPoolPreConfigured, backendPoolsUpdated, lb, nil
}

func (bi *backendPoolTypeNodeIP) GetBackendPrivateIPs(clusterName string, service *v1.Service, lb *network.LoadBalancer) ([]string, []string) {
Expand Down
47 changes: 29 additions & 18 deletions pkg/provider/azure_loadbalancer_backendpool_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -661,10 +661,10 @@ func TestReconcileBackendPoolsNodeIPConfig(t *testing.T) {
az = GetTestCloud(ctrl)
az.PreConfiguredBackendPoolLoadBalancerTypes = consts.PreConfiguredBackendPoolLoadBalancerTypesAll
bc = newBackendPoolTypeNodeIPConfig(az)
preConfigured, changed, shouldRefresh, err := bc.ReconcileBackendPools(testClusterName, &svc, &lb)
preConfigured, changed, updatedLB, err := bc.ReconcileBackendPools(testClusterName, &svc, &lb)
assert.NoError(t, err)
assert.False(t, preConfigured)
assert.False(t, shouldRefresh)
assert.Equal(t, lb, *updatedLB)
assert.True(t, changed)
}

Expand Down Expand Up @@ -692,8 +692,9 @@ func TestReconcileBackendPoolsNodeIPConfigRemoveIPConfig(t *testing.T) {

bc := newBackendPoolTypeNodeIPConfig(az)
svc := getTestService("test", v1.ProtocolTCP, nil, false, 80)
_, _, _, err := bc.ReconcileBackendPools(testClusterName, &svc, &lb)
_, _, updatedLB, err := bc.ReconcileBackendPools(testClusterName, &svc, &lb)
assert.NoError(t, err)
assert.Equal(t, lb, *updatedLB)

mockVMSet.EXPECT().GetNodeNameByIPConfigurationID("/subscriptions/subscription/resourceGroups/rg/providers/Microsoft.Network/networkInterfaces/k8s-agentpool1-00000000-nic-1/ipConfigurations/ipconfig1").Return("k8s-agentpool1-00000000", "", errors.New("error"))
_, _, _, err = bc.ReconcileBackendPools(testClusterName, &svc, &lb)
Expand All @@ -720,9 +721,10 @@ func TestReconcileBackendPoolsNodeIPConfigPreConfigured(t *testing.T) {

svc := getTestService("test", v1.ProtocolTCP, nil, false, 80)
bc := newBackendPoolTypeNodeIPConfig(az)
preConfigured, changed, _, err := bc.ReconcileBackendPools(testClusterName, &svc, &lb)
preConfigured, changed, updatedLB, err := bc.ReconcileBackendPools(testClusterName, &svc, &lb)
assert.True(t, preConfigured)
assert.False(t, changed)
assert.Equal(t, lb, *updatedLB)
assert.NoError(t, err)
}

Expand All @@ -745,9 +747,9 @@ func TestReconcileBackendPoolsNodeIPToIPConfig(t *testing.T) {

lb = buildLBWithVMIPs(testClusterName, []string{"10.0.0.1", "10.0.0.2"})
mockLBClient.EXPECT().CreateOrUpdateBackendPools(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
_, _, shouldRefresh, err := bc.ReconcileBackendPools(testClusterName, &svc, lb)
_, _, updatedLB, err := bc.ReconcileBackendPools(testClusterName, &svc, lb)
assert.NoError(t, err)
assert.False(t, shouldRefresh)
assert.Equal(t, network.LoadBalancer{}, *updatedLB)
assert.Empty(t, (*lb.BackendAddressPools)[0].LoadBalancerBackendAddresses)
}

Expand Down Expand Up @@ -809,14 +811,15 @@ func TestReconcileBackendPoolsNodeIP(t *testing.T) {

lbClient := mockloadbalancerclient.NewMockInterface(ctrl)
lbClient.EXPECT().CreateOrUpdateBackendPools(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), bp, gomock.Any()).Return(nil)
lbClient.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(network.LoadBalancer{}, nil)
az.LoadBalancerClient = lbClient

bi := newBackendPoolTypeNodeIP(az)

service := getTestService("test", v1.ProtocolTCP, nil, false, 80)

_, _, shouldRefresh, err := bi.ReconcileBackendPools("kubernetes", &service, lb)
assert.True(t, shouldRefresh)
_, _, updatedLB, err := bi.ReconcileBackendPools("kubernetes", &service, lb)
assert.Equal(t, network.LoadBalancer{}, *updatedLB)
assert.NoError(t, err)

lb = &network.LoadBalancer{
Expand All @@ -826,10 +829,10 @@ func TestReconcileBackendPoolsNodeIP(t *testing.T) {
az = GetTestCloud(ctrl)
az.PreConfiguredBackendPoolLoadBalancerTypes = consts.PreConfiguredBackendPoolLoadBalancerTypesAll
bi = newBackendPoolTypeNodeIP(az)
preConfigured, changed, shouldRefresh, err := bi.ReconcileBackendPools(testClusterName, &service, lb)
preConfigured, changed, updatedLB, err := bi.ReconcileBackendPools(testClusterName, &service, lb)
assert.NoError(t, err)
assert.False(t, preConfigured)
assert.False(t, shouldRefresh)
assert.Equal(t, lb, updatedLB)
assert.True(t, changed)
}

Expand All @@ -843,15 +846,19 @@ func TestReconcileBackendPoolsNodeIPEmptyPool(t *testing.T) {
mockVMSet.EXPECT().EnsureBackendPoolDeleted(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(true, nil)
mockVMSet.EXPECT().GetPrimaryVMSetName().Return("k8s-agentpool1-00000000")

mockLBClient := mockloadbalancerclient.NewMockInterface(ctrl)
mockLBClient.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(network.LoadBalancer{}, nil)

az := GetTestCloud(ctrl)
az.LoadBalancerBackendPoolConfigurationType = consts.LoadBalancerBackendPoolConfigurationTypeNodeIP
az.VMSet = mockVMSet
az.LoadBalancerClient = mockLBClient
bi := newBackendPoolTypeNodeIP(az)

service := getTestService("test", v1.ProtocolTCP, nil, false, 80)

_, _, shouldRefresh, err := bi.ReconcileBackendPools("kubernetes", &service, lb)
assert.True(t, shouldRefresh)
_, _, updatedLB, err := bi.ReconcileBackendPools("kubernetes", &service, lb)
assert.Equal(t, network.LoadBalancer{}, *updatedLB)
assert.NoError(t, err)
}

Expand All @@ -871,10 +878,10 @@ func TestReconcileBackendPoolsNodeIPPreConfigured(t *testing.T) {

service := getTestService("test", v1.ProtocolTCP, nil, false, 80)
bi := newBackendPoolTypeNodeIP(az)
preConfigured, changed, shouldRefresh, err := bi.ReconcileBackendPools("kubernetes", &service, lb)
preConfigured, changed, updatedLB, err := bi.ReconcileBackendPools("kubernetes", &service, lb)
assert.True(t, preConfigured)
assert.False(t, changed)
assert.False(t, shouldRefresh)
assert.Equal(t, lb, updatedLB)
assert.NoError(t, err)
}

Expand Down Expand Up @@ -902,9 +909,12 @@ func TestReconcileBackendPoolsNodeIPConfigToIP(t *testing.T) {
"/subscriptions/subscription/resourceGroups/rg/providers/Microsoft.Network/networkInterfaces/k8s-agentpool2-00000000-nic-1/ipConfigurations/ipconfig1",
})
mockVMSet.EXPECT().EnsureBackendPoolDeleted(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil)
_, _, shouldRefresh, err := bi.ReconcileBackendPools(testClusterName, &svc, &lb)
mockLBClient := mockloadbalancerclient.NewMockInterface(ctrl)
mockLBClient.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(network.LoadBalancer{}, nil)
az.LoadBalancerClient = mockLBClient
_, _, updatedLB, err := bi.ReconcileBackendPools(testClusterName, &svc, &lb)
assert.NoError(t, err)
assert.True(t, shouldRefresh)
assert.Equal(t, network.LoadBalancer{}, *updatedLB)
assert.Empty(t, (*lb.BackendAddressPools)[0].LoadBalancerBackendAddresses)
}

Expand Down Expand Up @@ -938,9 +948,10 @@ func TestReconcileBackendPoolsNodeIPConfigToIPWithMigrationAPI(t *testing.T) {
mockLBClient.EXPECT().MigrateToIPBasedBackendPool(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
bps := buildLBWithVMIPs(testClusterName, []string{"1.2.3.4", "2.3.4.5"}).BackendAddressPools
mockLBClient.EXPECT().GetLBBackendPool(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return((*bps)[0], nil)
_, _, shouldRefresh, err := bi.ReconcileBackendPools(testClusterName, &svc, &lb)
mockLBClient.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(network.LoadBalancer{}, nil)
_, _, updatedLB, err := bi.ReconcileBackendPools(testClusterName, &svc, &lb)
assert.NoError(t, err)
assert.True(t, shouldRefresh)
assert.Equal(t, network.LoadBalancer{}, *updatedLB)
}

func buildTestLoadBalancerBackendPoolWithIPs(name string, ips []string) network.BackendAddressPool {
Expand Down
10 changes: 7 additions & 3 deletions pkg/provider/azure_loadbalancer_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -727,7 +727,9 @@ func TestEnsureLoadBalancerDeleted(t *testing.T) {
defer ctrl.Finish()
az := GetTestCloud(ctrl)
mockLBBackendPool := az.LoadBalancerBackendPool.(*MockBackendPool)
mockLBBackendPool.EXPECT().ReconcileBackendPools(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, false, false, nil).AnyTimes()
mockLBBackendPool.EXPECT().ReconcileBackendPools(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(clusterName string, service *v1.Service, lb *network.LoadBalancer) (bool, bool, *network.LoadBalancer, error) {
return false, false, lb, nil
}).AnyTimes()
mockLBBackendPool.EXPECT().EnsureHostsInPool(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
mockLBBackendPool.EXPECT().GetBackendPrivateIPs(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()

Expand Down Expand Up @@ -3915,9 +3917,11 @@ func TestReconcileLoadBalancerCommon(t *testing.T) {

mockLBBackendPool := az.LoadBalancerBackendPool.(*MockBackendPool)
if test.shouldRefreshLBAfterReconcileBackendPools {
mockLBBackendPool.EXPECT().ReconcileBackendPools(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, false, true, nil)
mockLBBackendPool.EXPECT().ReconcileBackendPools(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, false, &test.expectedLB, test.expectedError)
}
mockLBBackendPool.EXPECT().ReconcileBackendPools(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, false, false, nil).AnyTimes()
mockLBBackendPool.EXPECT().ReconcileBackendPools(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(clusterName string, service *v1.Service, lb *network.LoadBalancer) (bool, bool, *network.LoadBalancer, error) {
return false, false, lb, nil
}).AnyTimes()
mockLBBackendPool.EXPECT().EnsureHostsInPool(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()

lb, rerr := az.reconcileLoadBalancer("testCluster", &service, clusterResources.nodes, test.wantLb)
Expand Down