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

Cherry pick #4839 and #4821 to release-1.26 #4863

Merged
merged 2 commits into from
Oct 30, 2023
Merged

Cherry pick #4839 and #4821 to release-1.26 #4863

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
8d78c29
fix: refresh the load balancer object after updating backend pools to…
nilo19 Oct 25, 2023
133f58f
fix: pipName should be case-insensitive when querying pip cache
nilo19 Oct 20, 2023
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
18 changes: 6 additions & 12 deletions pkg/provider/azure_loadbalancer.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1605,24 +1605,18 @@ 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)
}
}
}

// 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 @@ -135,14 +135,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 foundBackendPool, changed, shouldRefreshLB, isOperationSucceeded, isMigration bool
var foundBackendPool, backendPoolsCreated, backendPoolsUpdated, isOperationSucceeded, isMigration bool
lbName := *lb.Name

serviceName := getServiceName(service)
Expand Down Expand Up @@ -175,11 +179,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, lbBackendPoolName, err.Error())
return false, false, false, fmt.Errorf("bc.ReconcileBackendPools for service (%s): failed to cleanup IP based backend pool %s: %w", serviceName, lbBackendPoolName, err)
return false, false, nil, fmt.Errorf("bc.ReconcileBackendPools for service (%s): failed to cleanup IP based backend pool %s: %w", serviceName, lbBackendPoolName, err)
}
newBackendPools[i] = bp
lb.BackendAddressPools = &newBackendPools
shouldRefreshLB = true
backendPoolsUpdated = true
}
}

Expand All @@ -193,7 +197,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 @@ -204,7 +208,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 @@ -226,10 +230,10 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
// decouple the backendPool from the node
updated, err := bc.VMSet.EnsureBackendPoolDeleted(service, lbBackendPoolID, vmSetName, backendpoolToBeDeleted, false)
if err != nil {
return false, false, false, err
return false, false, nil, err
}
if updated {
shouldRefreshLB = true
backendPoolsUpdated = true
}
}
break
Expand All @@ -238,16 +242,17 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
}
}

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)
}
}

if !foundBackendPool {
isBackendPoolPreConfigured = newBackendPool(lb, isBackendPoolPreConfigured, bc.PreConfiguredBackendPoolLoadBalancerTypes, getServiceName(service), getBackendPoolName(clusterName, service))
changed = true
backendPoolsCreated = true
}

if isMigration {
Expand All @@ -257,7 +262,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 @@ -514,13 +519,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 foundBackendPool, changed, shouldRefreshLB, isOperationSucceeded, isMigration, updated bool
var foundBackendPool, backendPoolsUpdated, shouldRefreshLB, isOperationSucceeded, isMigration, updated bool
lbName := *lb.Name
serviceName := getServiceName(service)
lbBackendPoolName := getBackendPoolName(clusterName, service)
Expand Down Expand Up @@ -569,22 +574,22 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
name, err := getLBNameFromBackendPoolID(lbBackendPoolID)
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
}
}

klog.V(2).Infof("bi.ReconcileBackendPools for service (%s) and vmSet (%s): ensuring the LB is decoupled from the VMSet", serviceName, vmSetName)
shouldRefreshLB, err = bi.VMSet.EnsureBackendPoolDeleted(service, lbBackendPoolID, 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
}
if shouldRefreshLB {
isMigration = true
Expand Down Expand Up @@ -631,7 +636,7 @@ 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, lbBackendPoolName, 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, lbBackendPoolName, lbName, err)
}
shouldRefreshLB = true
}
Expand All @@ -642,10 +647,17 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
}

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)
}
}

if !foundBackendPool {
isBackendPoolPreConfigured = newBackendPool(lb, isBackendPoolPreConfigured, bi.PreConfiguredBackendPoolLoadBalancerTypes, getServiceName(service), getBackendPoolName(clusterName, service))
changed = true
backendPoolsUpdated = true
}

if isMigration {
Expand All @@ -655,7 +667,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 @@ -304,10 +304,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 @@ -335,8 +335,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 @@ -363,9 +364,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 @@ -388,9 +390,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 @@ -452,14 +454,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 @@ -469,10 +472,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 @@ -486,15 +489,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 @@ -514,10 +521,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 @@ -545,9 +552,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 @@ -581,9 +591,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 @@ -600,7 +600,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 @@ -3444,9 +3446,11 @@ func TestReconcileLoadBalancer(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