Use new Azure SDK APIs for load balancer and public IP operations

pkg/cloudprovider/providers/azure/azure_backoff.go

@@ -127,11 +127,12 @@ func (az *Cloud) CreateOrUpdateSGWithRetry(sg network.SecurityGroup) error {
 // CreateOrUpdateLBWithRetry invokes az.LoadBalancerClient.CreateOrUpdate with exponential backoff retry
 func (az *Cloud) CreateOrUpdateLBWithRetry(lb network.LoadBalancer) error {
 	return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
-		respChan, errChan := az.LoadBalancerClient.CreateOrUpdate(az.ResourceGroup, *lb.Name, lb, nil)
+		ctx, cancel := getContextWithCancel()
-		resp := <-respChan
+		defer cancel()
-		err := <-errChan
+
+		resp, err := az.LoadBalancerClient.CreateOrUpdate(ctx, az.ResourceGroup, *lb.Name, lb)
 		glog.V(10).Infof("LoadBalancerClient.CreateOrUpdate(%s): end", *lb.Name)
-		done, err := processRetryResponse(resp.Response, err)
+		done, err := processHTTPRetryResponse(resp, err)
 		if done && err == nil {
 			// Invalidate the cache right after updating
 			az.lbCache.Delete(*lb.Name)
@@ -142,20 +143,20 @@ func (az *Cloud) CreateOrUpdateLBWithRetry(lb network.LoadBalancer) error {
 
 // ListLBWithRetry invokes az.LoadBalancerClient.List with exponential backoff retry
 func (az *Cloud) ListLBWithRetry() ([]network.LoadBalancer, error) {
-	allLBs := []network.LoadBalancer{}
+	var allLBs []network.LoadBalancer
-	var result network.LoadBalancerListResult
-	var resultPage LoadBalancerListResultPage
 
 	err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
 		var retryErr error
-		resultPage, retryErr = az.LoadBalancerClient.List(az.ResourceGroup)
+		ctx, cancel := getContextWithCancel()
+		defer cancel()
+
+		allLBs, retryErr = az.LoadBalancerClient.List(ctx, az.ResourceGroup)
 		if retryErr != nil {
 			glog.Errorf("LoadBalancerClient.List(%v) - backoff: failure, will retry,err=%v",
 				az.ResourceGroup,
 				retryErr)
 			return false, retryErr
 		}
-		result = resultPage.Response()
 		glog.V(2).Infof("LoadBalancerClient.List(%v) - backoff: success", az.ResourceGroup)
 		return true, nil
 	})
@@ -163,52 +164,25 @@ func (az *Cloud) ListLBWithRetry() ([]network.LoadBalancer, error) {
 		return nil, err
 	}
 
-	appendResults := (result.Value != nil && len(*result.Value) > 0)
-	for appendResults {
-		allLBs = append(allLBs, *result.Value...)
-		appendResults = false
-
-		// follow the next link to get all the vms for resource group
-		if result.NextLink != nil {
-			err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
-				var retryErr error
-				resultPage, retryErr = az.LoadBalancerClient.ListNextResults(az.ResourceGroup, resultPage)
-				if retryErr != nil {
-					glog.Errorf("LoadBalancerClient.ListNextResults(%v) - backoff: failure, will retry,err=%v",
-						az.ResourceGroup,
-						retryErr)
-					return false, retryErr
-				}
-				result = resultPage.Response()
-				glog.V(2).Infof("LoadBalancerClient.ListNextResults(%v) - backoff: success", az.ResourceGroup)
-				return true, nil
-			})
-			if err != nil {
-				return allLBs, err
-			}
-			appendResults = (result.Value != nil && len(*result.Value) > 0)
-		}
-	}
-
 	return allLBs, nil
 }
 
 // ListPIPWithRetry list the PIP resources in the given resource group
 func (az *Cloud) ListPIPWithRetry(pipResourceGroup string) ([]network.PublicIPAddress, error) {
-	allPIPs := []network.PublicIPAddress{}
+	var allPIPs []network.PublicIPAddress
-	var result network.PublicIPAddressListResult
-	var resultPage PublicIPAddressListResultPage
 
 	err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
 		var retryErr error
-		resultPage, retryErr = az.PublicIPAddressesClient.List(pipResourceGroup)
+		ctx, cancel := getContextWithCancel()
+		defer cancel()
+
+		allPIPs, retryErr = az.PublicIPAddressesClient.List(ctx, pipResourceGroup)
 		if retryErr != nil {
 			glog.Errorf("PublicIPAddressesClient.List(%v) - backoff: failure, will retry,err=%v",
 				pipResourceGroup,
 				retryErr)
 			return false, retryErr
 		}
-		result = resultPage.Response()
 		glog.V(2).Infof("PublicIPAddressesClient.List(%v) - backoff: success", pipResourceGroup)
 		return true, nil
 	})
@@ -216,44 +190,18 @@ func (az *Cloud) ListPIPWithRetry(pipResourceGroup string) ([]network.PublicIPAd
 		return nil, err
 	}
 
-	appendResults := (result.Value != nil && len(*result.Value) > 0)
-	for appendResults {
-		allPIPs = append(allPIPs, *result.Value...)
-		appendResults = false
-
-		// follow the next link to get all the pip resources for resource group
-		if result.NextLink != nil {
-			err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
-				var retryErr error
-				resultPage, retryErr = az.PublicIPAddressesClient.ListNextResults(az.ResourceGroup, resultPage)
-				if retryErr != nil {
-					glog.Errorf("PublicIPAddressesClient.ListNextResults(%v) - backoff: failure, will retry,err=%v",
-						pipResourceGroup,
-						retryErr)
-					return false, retryErr
-				}
-				result = resultPage.Response()
-				glog.V(2).Infof("PublicIPAddressesClient.ListNextResults(%v) - backoff: success", pipResourceGroup)
-				return true, nil
-			})
-			if err != nil {
-				return allPIPs, err
-			}
-			appendResults = (result.Value != nil && len(*result.Value) > 0)
-		}
-	}
-
 	return allPIPs, nil
 }
 
 // CreateOrUpdatePIPWithRetry invokes az.PublicIPAddressesClient.CreateOrUpdate with exponential backoff retry
 func (az *Cloud) CreateOrUpdatePIPWithRetry(pipResourceGroup string, pip network.PublicIPAddress) error {
 	return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
-		respChan, errChan := az.PublicIPAddressesClient.CreateOrUpdate(pipResourceGroup, *pip.Name, pip, nil)
+		ctx, cancel := getContextWithCancel()
-		resp := <-respChan
+		defer cancel()
-		err := <-errChan
+
+		resp, err := az.PublicIPAddressesClient.CreateOrUpdate(ctx, pipResourceGroup, *pip.Name, pip)
 		glog.V(10).Infof("PublicIPAddressesClient.CreateOrUpdate(%s, %s): end", pipResourceGroup, *pip.Name)
-		return processRetryResponse(resp.Response, err)
+		return processHTTPRetryResponse(resp, err)
 	})
 }
 
@@ -271,20 +219,22 @@ func (az *Cloud) CreateOrUpdateInterfaceWithRetry(nic network.Interface) error {
 // DeletePublicIPWithRetry invokes az.PublicIPAddressesClient.Delete with exponential backoff retry
 func (az *Cloud) DeletePublicIPWithRetry(pipResourceGroup string, pipName string) error {
 	return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
-		respChan, errChan := az.PublicIPAddressesClient.Delete(pipResourceGroup, pipName, nil)
+		ctx, cancel := getContextWithCancel()
-		resp := <-respChan
+		defer cancel()
-		err := <-errChan
+
-		return processRetryResponse(resp, err)
+		resp, err := az.PublicIPAddressesClient.Delete(ctx, pipResourceGroup, pipName)
+		return processHTTPRetryResponse(resp, err)
 	})
 }
 
 // DeleteLBWithRetry invokes az.LoadBalancerClient.Delete with exponential backoff retry
 func (az *Cloud) DeleteLBWithRetry(lbName string) error {
 	return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) {
-		respChan, errChan := az.LoadBalancerClient.Delete(az.ResourceGroup, lbName, nil)
+		ctx, cancel := getContextWithCancel()
-		resp := <-respChan
+		defer cancel()
-		err := <-errChan
+
-		done, err := processRetryResponse(resp, err)
+		resp, err := az.LoadBalancerClient.Delete(ctx, az.ResourceGroup, lbName)
+		done, err := processHTTPRetryResponse(resp, err)
 		if done && err == nil {
 			// Invalidate the cache right after deleting
 			az.lbCache.Delete(lbName)

pkg/cloudprovider/providers/azure/azure_client.go

@@ -96,20 +96,18 @@ type InterfacesClient interface {
 
 // LoadBalancersClient defines needed functions for azure network.LoadBalancersClient
 type LoadBalancersClient interface {
-	CreateOrUpdate(resourceGroupName string, loadBalancerName string, parameters network.LoadBalancer, cancel <-chan struct{}) (<-chan network.LoadBalancer, <-chan error)
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters network.LoadBalancer) (resp *http.Response, err error)
-	Delete(resourceGroupName string, loadBalancerName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error)
+	Delete(ctx context.Context, resourceGroupName string, loadBalancerName string) (resp *http.Response, err error)
-	Get(resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error)
+	Get(ctx context.Context, resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error)
-	List(resourceGroupName string) (result LoadBalancerListResultPage, err error)
+	List(ctx context.Context, resourceGroupName string) (result []network.LoadBalancer, err error)
-	ListNextResults(resourceGroupName string, lastResult LoadBalancerListResultPage) (result LoadBalancerListResultPage, err error)
 }
 
 // PublicIPAddressesClient defines needed functions for azure network.PublicIPAddressesClient
 type PublicIPAddressesClient interface {
-	CreateOrUpdate(resourceGroupName string, publicIPAddressName string, parameters network.PublicIPAddress, cancel <-chan struct{}) (<-chan network.PublicIPAddress, <-chan error)
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters network.PublicIPAddress) (resp *http.Response, err error)
-	Delete(resourceGroupName string, publicIPAddressName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error)
+	Delete(ctx context.Context, resourceGroupName string, publicIPAddressName string) (resp *http.Response, err error)
-	Get(resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error)
+	Get(ctx context.Context, resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error)
-	List(resourceGroupName string) (result PublicIPAddressListResultPage, err error)
+	List(ctx context.Context, resourceGroupName string) (result []network.PublicIPAddress, err error)
-	ListNextResults(resourceGroupName string, lastResults PublicIPAddressListResultPage) (result PublicIPAddressListResultPage, err error)
 }
 
 // SubnetsClient defines needed functions for azure network.SubnetsClient
@@ -392,13 +390,11 @@ func newAzLoadBalancersClient(config *azClientConfig) *azLoadBalancersClient {
 	}
 }
 
-func (az *azLoadBalancersClient) CreateOrUpdate(resourceGroupName string, loadBalancerName string, parameters network.LoadBalancer, cancel <-chan struct{}) (<-chan network.LoadBalancer, <-chan error) {
+func (az *azLoadBalancersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters network.LoadBalancer) (resp *http.Response, err error) {
 	/* Write rate limiting */
 	if !az.rateLimiterWriter.TryAccept() {
-		errChan := createARMRateLimitErrChannel(true, "LBCreateOrUpdate")
+		err = createARMRateLimitErr(true, "LBCreateOrUpdate")
-		resultChan := make(chan network.LoadBalancer, 1)
+		return nil, err
-		resultChan <- network.LoadBalancer{}
-		return resultChan, errChan
 	}
 
 	glog.V(10).Infof("azLoadBalancersClient.CreateOrUpdate(%q,%q): start", resourceGroupName, loadBalancerName)
@@ -406,37 +402,23 @@ func (az *azLoadBalancersClient) CreateOrUpdate(resourceGroupName string, loadBa
 		glog.V(10).Infof("azLoadBalancersClient.CreateOrUpdate(%q,%q): end", resourceGroupName, loadBalancerName)
 	}()
 
-	ctx := context.TODO()
-	errChan := make(chan error, 1)
-	resultChan := make(chan network.LoadBalancer, 1)
 	mc := newMetricContext("load_balancers", "create_or_update", resourceGroupName, az.client.SubscriptionID)
 	future, err := az.client.CreateOrUpdate(ctx, resourceGroupName, loadBalancerName, parameters)
+	mc.Observe(err)
 	if err != nil {
-		mc.Observe(err)
+		return future.Response(), err
-		errChan <- err
-		return resultChan, errChan
 	}
-	go func() {
+
-		if err := future.WaitForCompletion(ctx, az.client.Client); err != nil {
+	err = future.WaitForCompletion(ctx, az.client.Client)
-			mc.Observe(err)
+	mc.Observe(err)
-			errChan <- err
+	return future.Response(), err
-			return
-		}
-		result, err := future.Result(az.client)
-		mc.Observe(err)
-		errChan <- err
-		resultChan <- result
-	}()
-	return resultChan, errChan
 }
 
-func (az *azLoadBalancersClient) Delete(resourceGroupName string, loadBalancerName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
+func (az *azLoadBalancersClient) Delete(ctx context.Context, resourceGroupName string, loadBalancerName string) (resp *http.Response, err error) {
 	/* Write rate limiting */
 	if !az.rateLimiterWriter.TryAccept() {
-		errChan := createARMRateLimitErrChannel(true, "LBDelete")
+		err = createARMRateLimitErr(true, "LBDelete")
-		resultChan := make(chan autorest.Response, 1)
+		return nil, err
-		resultChan <- autorest.Response{}
-		return resultChan, errChan
 	}
 
 	glog.V(10).Infof("azLoadBalancersClient.Delete(%q,%q): start", resourceGroupName, loadBalancerName)
@@ -444,31 +426,19 @@ func (az *azLoadBalancersClient) Delete(resourceGroupName string, loadBalancerNa
 		glog.V(10).Infof("azLoadBalancersClient.Delete(%q,%q): end", resourceGroupName, loadBalancerName)
 	}()
 
-	ctx := context.TODO()
-	errChan := make(chan error, 1)
-	resultChan := make(chan autorest.Response, 1)
 	mc := newMetricContext("load_balancers", "delete", resourceGroupName, az.client.SubscriptionID)
-	future, err := az.client.Delete(context.TODO(), resourceGroupName, loadBalancerName)
+	future, err := az.client.Delete(ctx, resourceGroupName, loadBalancerName)
+	mc.Observe(err)
 	if err != nil {
-		mc.Observe(err)
+		return future.Response(), err
-		errChan <- err
-		return resultChan, errChan
 	}
-	go func() {
+
-		if err := future.WaitForCompletion(ctx, az.client.Client); err != nil {
+	err = future.WaitForCompletion(ctx, az.client.Client)
-			mc.Observe(err)
+	mc.Observe(err)
-			errChan <- err
+	return future.Response(), err
-			return
-		}
-		result, err := future.Result(az.client)
-		mc.Observe(err)
-		errChan <- err
-		resultChan <- result
-	}()
-	return resultChan, errChan
 }
 
-func (az *azLoadBalancersClient) Get(resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error) {
+func (az *azLoadBalancersClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error) {
 	if !az.rateLimiterReader.TryAccept() {
 		err = createARMRateLimitErr(false, "LBGet")
 		return
@@ -480,15 +450,15 @@ func (az *azLoadBalancersClient) Get(resourceGroupName string, loadBalancerName
 	}()
 
 	mc := newMetricContext("load_balancers", "get", resourceGroupName, az.client.SubscriptionID)
-	result, err = az.client.Get(context.TODO(), resourceGroupName, loadBalancerName, expand)
+	result, err = az.client.Get(ctx, resourceGroupName, loadBalancerName, expand)
 	mc.Observe(err)
 	return
 }
 
-func (az *azLoadBalancersClient) List(resourceGroupName string) (LoadBalancerListResultPage, error) {
+func (az *azLoadBalancersClient) List(ctx context.Context, resourceGroupName string) ([]network.LoadBalancer, error) {
 	if !az.rateLimiterReader.TryAccept() {
 		err := createARMRateLimitErr(false, "LBList")
-		return &network.LoadBalancerListResultPage{}, err
+		return nil, err
 	}
 
 	glog.V(10).Infof("azLoadBalancersClient.List(%q): start", resourceGroupName)
@@ -497,26 +467,22 @@ func (az *azLoadBalancersClient) List(resourceGroupName string) (LoadBalancerLis
 	}()
 
 	mc := newMetricContext("load_balancers", "list", resourceGroupName, az.client.SubscriptionID)
-	result, err := az.client.List(context.TODO(), resourceGroupName)
+	iterator, err := az.client.ListComplete(ctx, resourceGroupName)
 	mc.Observe(err)
-	return &result, err
+	if err != nil {
-}
+		return nil, err
-
-func (az *azLoadBalancersClient) ListNextResults(resourceGroupName string, lastResult LoadBalancerListResultPage) (result LoadBalancerListResultPage, err error) {
-	if !az.rateLimiterReader.TryAccept() {
-		err = createARMRateLimitErr(false, "LBListNextResults")
-		return
 	}
 
-	glog.V(10).Infof("azLoadBalancersClient.ListNextResults(%q): start", lastResult)
+	result := make([]network.LoadBalancer, 0)
-	defer func() {
+	for ; iterator.NotDone(); err = iterator.Next() {
-		glog.V(10).Infof("azLoadBalancersClient.ListNextResults(%q): end", lastResult)
+		if err != nil {
-	}()
+			return nil, err
+		}
 
-	mc := newMetricContext("load_balancers", "list_next_results", resourceGroupName, az.client.SubscriptionID)
+		result = append(result, iterator.Value())
-	err = lastResult.Next()
+	}
-	mc.Observe(err)
+
-	return lastResult, err
+	return result, nil
 }
 
 // azPublicIPAddressesClient implements PublicIPAddressesClient.
@@ -540,13 +506,11 @@ func newAzPublicIPAddressesClient(config *azClientConfig) *azPublicIPAddressesCl
 	}
 }
 
-func (az *azPublicIPAddressesClient) CreateOrUpdate(resourceGroupName string, publicIPAddressName string, parameters network.PublicIPAddress, cancel <-chan struct{}) (<-chan network.PublicIPAddress, <-chan error) {
+func (az *azPublicIPAddressesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters network.PublicIPAddress) (resp *http.Response, err error) {
 	/* Write rate limiting */
 	if !az.rateLimiterWriter.TryAccept() {
-		errChan := createARMRateLimitErrChannel(true, "PublicIPCreateOrUpdate")
+		err = createARMRateLimitErr(true, "PublicIPCreateOrUpdate")
-		resultChan := make(chan network.PublicIPAddress, 1)
+		return nil, err
-		resultChan <- network.PublicIPAddress{}
-		return resultChan, errChan
 	}
 
 	glog.V(10).Infof("azPublicIPAddressesClient.CreateOrUpdate(%q,%q): start", resourceGroupName, publicIPAddressName)
@@ -554,37 +518,23 @@ func (az *azPublicIPAddressesClient) CreateOrUpdate(resourceGroupName string, pu
 		glog.V(10).Infof("azPublicIPAddressesClient.CreateOrUpdate(%q,%q): end", resourceGroupName, publicIPAddressName)
 	}()
 
-	ctx := context.TODO()
-	errChan := make(chan error, 1)
-	resultChan := make(chan network.PublicIPAddress, 1)
 	mc := newMetricContext("public_ip_addresses", "create_or_update", resourceGroupName, az.client.SubscriptionID)
-	future, err := az.client.CreateOrUpdate(context.TODO(), resourceGroupName, publicIPAddressName, parameters)
+	future, err := az.client.CreateOrUpdate(ctx, resourceGroupName, publicIPAddressName, parameters)
+	mc.Observe(err)
 	if err != nil {
-		mc.Observe(err)
+		return future.Response(), err
-		errChan <- err
-		return resultChan, errChan
 	}
-	go func() {
+
-		if err := future.WaitForCompletion(ctx, az.client.Client); err != nil {
+	err = future.WaitForCompletion(ctx, az.client.Client)
-			mc.Observe(err)
+	mc.Observe(err)
-			errChan <- err
+	return future.Response(), err
-			return
-		}
-		result, err := future.Result(az.client)
-		mc.Observe(err)
-		errChan <- err
-		resultChan <- result
-	}()
-	return resultChan, errChan
 }
 
-func (az *azPublicIPAddressesClient) Delete(resourceGroupName string, publicIPAddressName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
+func (az *azPublicIPAddressesClient) Delete(ctx context.Context, resourceGroupName string, publicIPAddressName string) (resp *http.Response, err error) {
 	/* Write rate limiting */
 	if !az.rateLimiterWriter.TryAccept() {
-		errChan := createARMRateLimitErrChannel(true, "PublicIPDelete")
+		err = createARMRateLimitErr(true, "PublicIPDelete")
-		resultChan := make(chan autorest.Response, 1)
+		return nil, err
-		resultChan <- autorest.Response{}
-		return resultChan, errChan
 	}
 
 	glog.V(10).Infof("azPublicIPAddressesClient.Delete(%q,%q): start", resourceGroupName, publicIPAddressName)
@@ -592,31 +542,19 @@ func (az *azPublicIPAddressesClient) Delete(resourceGroupName string, publicIPAd
 		glog.V(10).Infof("azPublicIPAddressesClient.Delete(%q,%q): end", resourceGroupName, publicIPAddressName)
 	}()
 
-	ctx := context.TODO()
-	resultChan := make(chan autorest.Response, 1)
-	errChan := make(chan error, 1)
 	mc := newMetricContext("public_ip_addresses", "delete", resourceGroupName, az.client.SubscriptionID)
 	future, err := az.client.Delete(ctx, resourceGroupName, publicIPAddressName)
+	mc.Observe(err)
 	if err != nil {
-		mc.Observe(err)
+		return future.Response(), err
-		errChan <- err
-		return resultChan, errChan
 	}
-	go func() {
+
-		if err := future.WaitForCompletion(ctx, az.client.Client); err != nil {
+	err = future.WaitForCompletion(ctx, az.client.Client)
-			mc.Observe(err)
+	mc.Observe(err)
-			errChan <- err
+	return future.Response(), err
-			return
-		}
-		result, err := future.Result(az.client)
-		mc.Observe(err)
-		errChan <- err
-		resultChan <- result
-	}()
-	return resultChan, errChan
 }
 
-func (az *azPublicIPAddressesClient) Get(resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error) {
+func (az *azPublicIPAddressesClient) Get(ctx context.Context, resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error) {
 	if !az.rateLimiterReader.TryAccept() {
 		err = createARMRateLimitErr(false, "PublicIPGet")
 		return
@@ -628,13 +566,12 @@ func (az *azPublicIPAddressesClient) Get(resourceGroupName string, publicIPAddre
 	}()
 
 	mc := newMetricContext("public_ip_addresses", "get", resourceGroupName, az.client.SubscriptionID)
-	ctx := context.TODO()
 	result, err = az.client.Get(ctx, resourceGroupName, publicIPAddressName, expand)
 	mc.Observe(err)
 	return
 }
 
-func (az *azPublicIPAddressesClient) List(resourceGroupName string) (PublicIPAddressListResultPage, error) {
+func (az *azPublicIPAddressesClient) List(ctx context.Context, resourceGroupName string) ([]network.PublicIPAddress, error) {
 	if !az.rateLimiterReader.TryAccept() {
 		return nil, createARMRateLimitErr(false, "PublicIPList")
 	}
@@ -645,27 +582,22 @@ func (az *azPublicIPAddressesClient) List(resourceGroupName string) (PublicIPAdd
 	}()
 
 	mc := newMetricContext("public_ip_addresses", "list", resourceGroupName, az.client.SubscriptionID)
-	ctx := context.TODO()
+	iterator, err := az.client.ListComplete(ctx, resourceGroupName)
-	result, err := az.client.List(ctx, resourceGroupName)
 	mc.Observe(err)
-	return &result, err
+	if err != nil {
-}
+		return nil, err
-
-func (az *azPublicIPAddressesClient) ListNextResults(resourceGroupName string, lastResults PublicIPAddressListResultPage) (result PublicIPAddressListResultPage, err error) {
-	if !az.rateLimiterReader.TryAccept() {
-		err = createARMRateLimitErr(false, "PublicIPListNextResults")
-		return
 	}
 
-	glog.V(10).Infof("azPublicIPAddressesClient.ListNextResults(%q): start", lastResults)
+	result := make([]network.PublicIPAddress, 0)
-	defer func() {
+	for ; iterator.NotDone(); err = iterator.Next() {
-		glog.V(10).Infof("azPublicIPAddressesClient.ListNextResults(%q): end", lastResults)
+		if err != nil {
-	}()
+			return nil, err
+		}
 
-	mc := newMetricContext("public_ip_addresses", "list_next_results", resourceGroupName, az.client.SubscriptionID)
+		result = append(result, iterator.Value())
-	err = lastResults.Next()
+	}
-	mc.Observe(err)
+
-	return lastResults, err
+	return result, nil
 }
 
 // azSubnetsClient implements SubnetsClient.

pkg/cloudprovider/providers/azure/azure_loadbalancer.go

@@ -454,7 +454,9 @@ func (az *Cloud) ensurePublicIPExists(service *v1.Service, pipName string, domai
 	}
 	glog.V(10).Infof("CreateOrUpdatePIPWithRetry(%s, %q): end", pipResourceGroup, *pip.Name)
 
-	pip, err = az.PublicIPAddressesClient.Get(pipResourceGroup, *pip.Name, "")
+	ctx, cancel := getContextWithCancel()
+	defer cancel()
+	pip, err = az.PublicIPAddressesClient.Get(ctx, pipResourceGroup, *pip.Name, "")
 	if err != nil {
 		return nil, err
 	}

pkg/cloudprovider/providers/azure/azure_wrap.go

@@ -104,7 +104,9 @@ func (az *Cloud) getPublicIPAddress(pipResourceGroup string, pipName string) (pi
 	}
 
 	var realErr error
-	pip, err = az.PublicIPAddressesClient.Get(resourceGroup, pipName, "")
+	ctx, cancel := getContextWithCancel()
+	defer cancel()
+	pip, err = az.PublicIPAddressesClient.Get(ctx, resourceGroup, pipName, "")
 	exists, realErr = checkResourceExistsFromError(err)
 	if realErr != nil {
 		return pip, false, realErr
@@ -194,7 +196,10 @@ func (az *Cloud) newVMCache() (*timedCache, error) {
 
 func (az *Cloud) newLBCache() (*timedCache, error) {
 	getter := func(key string) (interface{}, error) {
-		lb, err := az.LoadBalancerClient.Get(az.ResourceGroup, key, "")
+		ctx, cancel := getContextWithCancel()
+		defer cancel()
+
+		lb, err := az.LoadBalancerClient.Get(ctx, az.ResourceGroup, key, "")
 		exists, realErr := checkResourceExistsFromError(err)
 		if realErr != nil {
 			return nil, realErr