diff --git a/pkg/cloudprovider/providers/azure/BUILD b/pkg/cloudprovider/providers/azure/BUILD index fe131367e0c..d796860b662 100644 --- a/pkg/cloudprovider/providers/azure/BUILD +++ b/pkg/cloudprovider/providers/azure/BUILD @@ -12,6 +12,7 @@ go_library( "azure.go", "azure_backoff.go", "azure_blobDiskController.go", + "azure_client.go", "azure_controllerCommon.go", "azure_fakes.go", "azure_file.go", @@ -42,6 +43,7 @@ go_library( "//vendor/github.com/Azure/azure-sdk-for-go/arm/storage:go_default_library", "//vendor/github.com/Azure/azure-sdk-for-go/storage:go_default_library", "//vendor/github.com/Azure/go-autorest/autorest:go_default_library", + "//vendor/github.com/Azure/go-autorest/autorest/adal:go_default_library", "//vendor/github.com/Azure/go-autorest/autorest/azure:go_default_library", "//vendor/github.com/Azure/go-autorest/autorest/to:go_default_library", "//vendor/github.com/ghodss/yaml:go_default_library", @@ -80,7 +82,6 @@ go_test( "//vendor/k8s.io/api/core/v1:go_default_library", "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//vendor/k8s.io/apimachinery/pkg/types:go_default_library", - "//vendor/k8s.io/client-go/util/flowcontrol:go_default_library", ], ) diff --git a/pkg/cloudprovider/providers/azure/azure.go b/pkg/cloudprovider/providers/azure/azure.go index 8f31f013508..9070be894d4 100644 --- a/pkg/cloudprovider/providers/azure/azure.go +++ b/pkg/cloudprovider/providers/azure/azure.go @@ -30,10 +30,6 @@ import ( "k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/version" - "github.com/Azure/azure-sdk-for-go/arm/compute" - "github.com/Azure/azure-sdk-for-go/arm/disk" - "github.com/Azure/azure-sdk-for-go/arm/network" - "github.com/Azure/azure-sdk-for-go/arm/storage" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/ghodss/yaml" @@ -110,117 +106,22 @@ type Config struct { MaximumLoadBalancerRuleCount int `json:"maximumLoadBalancerRuleCount"` } -// VirtualMachinesClient defines needed functions for azure compute.VirtualMachinesClient -type VirtualMachinesClient interface { - CreateOrUpdate(resourceGroupName string, VMName string, parameters compute.VirtualMachine, cancel <-chan struct{}) (<-chan compute.VirtualMachine, <-chan error) - Get(resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (result compute.VirtualMachine, err error) - List(resourceGroupName string) (result compute.VirtualMachineListResult, err error) - ListNextResults(lastResults compute.VirtualMachineListResult) (result compute.VirtualMachineListResult, err error) -} - -// InterfacesClient defines needed functions for azure network.InterfacesClient -type InterfacesClient interface { - CreateOrUpdate(resourceGroupName string, networkInterfaceName string, parameters network.Interface, cancel <-chan struct{}) (<-chan network.Interface, <-chan error) - Get(resourceGroupName string, networkInterfaceName string, expand string) (result network.Interface, err error) - GetVirtualMachineScaleSetNetworkInterface(resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result network.Interface, err error) -} - -// 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) - Delete(resourceGroupName string, loadBalancerName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) - Get(resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error) - List(resourceGroupName string) (result network.LoadBalancerListResult, err error) - ListNextResults(lastResult network.LoadBalancerListResult) (result network.LoadBalancerListResult, 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) - Delete(resourceGroupName string, publicIPAddressName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) - Get(resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error) - List(resourceGroupName string) (result network.PublicIPAddressListResult, err error) - ListNextResults(lastResults network.PublicIPAddressListResult) (result network.PublicIPAddressListResult, err error) -} - -// SubnetsClient defines needed functions for azure network.SubnetsClient -type SubnetsClient interface { - CreateOrUpdate(resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters network.Subnet, cancel <-chan struct{}) (<-chan network.Subnet, <-chan error) - Delete(resourceGroupName string, virtualNetworkName string, subnetName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) - Get(resourceGroupName string, virtualNetworkName string, subnetName string, expand string) (result network.Subnet, err error) - List(resourceGroupName string, virtualNetworkName string) (result network.SubnetListResult, err error) -} - -// SecurityGroupsClient defines needed functions for azure network.SecurityGroupsClient -type SecurityGroupsClient interface { - CreateOrUpdate(resourceGroupName string, networkSecurityGroupName string, parameters network.SecurityGroup, cancel <-chan struct{}) (<-chan network.SecurityGroup, <-chan error) - Delete(resourceGroupName string, networkSecurityGroupName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) - Get(resourceGroupName string, networkSecurityGroupName string, expand string) (result network.SecurityGroup, err error) - List(resourceGroupName string) (result network.SecurityGroupListResult, err error) -} - -// VirtualMachineScaleSetsClient defines needed functions for azure compute.VirtualMachineScaleSetsClient -type VirtualMachineScaleSetsClient interface { - CreateOrUpdate(resourceGroupName string, VMScaleSetName string, parameters compute.VirtualMachineScaleSet, cancel <-chan struct{}) (<-chan compute.VirtualMachineScaleSet, <-chan error) - Get(resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSet, err error) - List(resourceGroupName string) (result compute.VirtualMachineScaleSetListResult, err error) - ListNextResults(lastResults compute.VirtualMachineScaleSetListResult) (result compute.VirtualMachineScaleSetListResult, err error) - UpdateInstances(resourceGroupName string, VMScaleSetName string, VMInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs, cancel <-chan struct{}) (<-chan compute.OperationStatusResponse, <-chan error) -} - -// VirtualMachineScaleSetVMsClient defines needed functions for azure compute.VirtualMachineScaleSetVMsClient -type VirtualMachineScaleSetVMsClient interface { - Get(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVM, err error) - GetInstanceView(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMInstanceView, err error) - List(resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result compute.VirtualMachineScaleSetVMListResult, err error) - ListNextResults(lastResults compute.VirtualMachineScaleSetVMListResult) (result compute.VirtualMachineScaleSetVMListResult, err error) -} - -// RoutesClient defines needed functions for azure network.RoutesClient -type RoutesClient interface { - CreateOrUpdate(resourceGroupName string, routeTableName string, routeName string, routeParameters network.Route, cancel <-chan struct{}) (<-chan network.Route, <-chan error) - Delete(resourceGroupName string, routeTableName string, routeName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) -} - -// RouteTablesClient defines needed functions for azure network.RouteTablesClient -type RouteTablesClient interface { - CreateOrUpdate(resourceGroupName string, routeTableName string, parameters network.RouteTable, cancel <-chan struct{}) (<-chan network.RouteTable, <-chan error) - Get(resourceGroupName string, routeTableName string, expand string) (result network.RouteTable, err error) -} - -// StorageAccountClient defines needed functions for azure storage.AccountsClient -type StorageAccountClient interface { - Create(resourceGroupName string, accountName string, parameters storage.AccountCreateParameters, cancel <-chan struct{}) (<-chan storage.Account, <-chan error) - Delete(resourceGroupName string, accountName string) (result autorest.Response, err error) - ListKeys(resourceGroupName string, accountName string) (result storage.AccountListKeysResult, err error) - ListByResourceGroup(resourceGroupName string) (result storage.AccountListResult, err error) - GetProperties(resourceGroupName string, accountName string) (result storage.Account, err error) -} - -// DisksClient defines needed functions for azure disk.DisksClient -type DisksClient interface { - CreateOrUpdate(resourceGroupName string, diskName string, diskParameter disk.Model, cancel <-chan struct{}) (<-chan disk.Model, <-chan error) - Delete(resourceGroupName string, diskName string, cancel <-chan struct{}) (<-chan disk.OperationStatusResponse, <-chan error) - Get(resourceGroupName string, diskName string) (result disk.Model, err error) -} - // Cloud holds the config and clients type Cloud struct { Config - Environment azure.Environment - RoutesClient RoutesClient - SubnetsClient SubnetsClient - InterfacesClient InterfacesClient - RouteTablesClient RouteTablesClient - LoadBalancerClient LoadBalancersClient - PublicIPAddressesClient PublicIPAddressesClient - SecurityGroupsClient SecurityGroupsClient - VirtualMachinesClient VirtualMachinesClient - StorageAccountClient StorageAccountClient - DisksClient DisksClient - operationPollRateLimiter flowcontrol.RateLimiter - resourceRequestBackoff wait.Backoff - vmSet VMSet + Environment azure.Environment + RoutesClient RoutesClient + SubnetsClient SubnetsClient + InterfacesClient InterfacesClient + RouteTablesClient RouteTablesClient + LoadBalancerClient LoadBalancersClient + PublicIPAddressesClient PublicIPAddressesClient + SecurityGroupsClient SecurityGroupsClient + VirtualMachinesClient VirtualMachinesClient + StorageAccountClient StorageAccountClient + DisksClient DisksClient + resourceRequestBackoff wait.Backoff + vmSet VMSet // Clients for vmss. VirtualMachineScaleSetsClient VirtualMachineScaleSetsClient @@ -247,116 +148,51 @@ func NewCloud(configReader io.Reader) (cloudprovider.Interface, error) { return nil, err } - az := Cloud{ - Config: *config, - Environment: *env, - } - servicePrincipalToken, err := auth.GetServicePrincipalToken(&config.AzureAuthConfig, env) if err != nil { return nil, err } - subnetsClient := network.NewSubnetsClient(az.SubscriptionID) - subnetsClient.BaseURI = az.Environment.ResourceManagerEndpoint - subnetsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - subnetsClient.PollingDelay = 5 * time.Second - configureUserAgent(&subnetsClient.Client) - az.SubnetsClient = subnetsClient - - routeTablesClient := network.NewRouteTablesClient(az.SubscriptionID) - routeTablesClient.BaseURI = az.Environment.ResourceManagerEndpoint - routeTablesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - routeTablesClient.PollingDelay = 5 * time.Second - configureUserAgent(&routeTablesClient.Client) - az.RouteTablesClient = routeTablesClient - - routesClient := network.NewRoutesClient(az.SubscriptionID) - routesClient.BaseURI = az.Environment.ResourceManagerEndpoint - routesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - routesClient.PollingDelay = 5 * time.Second - configureUserAgent(&routesClient.Client) - az.RoutesClient = routesClient - - interfacesClient := network.NewInterfacesClient(az.SubscriptionID) - interfacesClient.BaseURI = az.Environment.ResourceManagerEndpoint - interfacesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - interfacesClient.PollingDelay = 5 * time.Second - configureUserAgent(&interfacesClient.Client) - az.InterfacesClient = interfacesClient - - loadBalancerClient := network.NewLoadBalancersClient(az.SubscriptionID) - loadBalancerClient.BaseURI = az.Environment.ResourceManagerEndpoint - loadBalancerClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - loadBalancerClient.PollingDelay = 5 * time.Second - configureUserAgent(&loadBalancerClient.Client) - az.LoadBalancerClient = loadBalancerClient - - virtualMachinesClient := compute.NewVirtualMachinesClient(az.SubscriptionID) - virtualMachinesClient.BaseURI = az.Environment.ResourceManagerEndpoint - virtualMachinesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - virtualMachinesClient.PollingDelay = 5 * time.Second - configureUserAgent(&virtualMachinesClient.Client) - az.VirtualMachinesClient = virtualMachinesClient - - publicIPAddressClient := network.NewPublicIPAddressesClient(az.SubscriptionID) - publicIPAddressClient.BaseURI = az.Environment.ResourceManagerEndpoint - publicIPAddressClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - publicIPAddressClient.PollingDelay = 5 * time.Second - configureUserAgent(&publicIPAddressClient.Client) - az.PublicIPAddressesClient = publicIPAddressClient - - securityGroupsClient := network.NewSecurityGroupsClient(az.SubscriptionID) - securityGroupsClient.BaseURI = az.Environment.ResourceManagerEndpoint - securityGroupsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - securityGroupsClient.PollingDelay = 5 * time.Second - configureUserAgent(&securityGroupsClient.Client) - az.SecurityGroupsClient = securityGroupsClient - - virtualMachineScaleSetVMsClient := compute.NewVirtualMachineScaleSetVMsClient(az.SubscriptionID) - virtualMachineScaleSetVMsClient.BaseURI = az.Environment.ResourceManagerEndpoint - virtualMachineScaleSetVMsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - virtualMachineScaleSetVMsClient.PollingDelay = 5 * time.Second - configureUserAgent(&virtualMachineScaleSetVMsClient.Client) - az.VirtualMachineScaleSetVMsClient = virtualMachineScaleSetVMsClient - - virtualMachineScaleSetsClient := compute.NewVirtualMachineScaleSetsClient(az.SubscriptionID) - virtualMachineScaleSetsClient.BaseURI = az.Environment.ResourceManagerEndpoint - virtualMachineScaleSetsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - virtualMachineScaleSetsClient.PollingDelay = 5 * time.Second - configureUserAgent(&virtualMachineScaleSetsClient.Client) - az.VirtualMachineScaleSetsClient = virtualMachineScaleSetsClient - - storageAccountClient := storage.NewAccountsClientWithBaseURI(az.Environment.ResourceManagerEndpoint, az.SubscriptionID) - storageAccountClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - storageAccountClient.PollingDelay = 5 * time.Second - configureUserAgent(&storageAccountClient.Client) - az.StorageAccountClient = storageAccountClient - - disksClient := disk.NewDisksClientWithBaseURI(az.Environment.ResourceManagerEndpoint, az.SubscriptionID) - disksClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken) - disksClient.PollingDelay = 5 * time.Second - configureUserAgent(&disksClient.Client) - az.DisksClient = disksClient - - // Conditionally configure rate limits - if az.CloudProviderRateLimit { + // operationPollRateLimiter.Accept() is a no-op if rate limits are configured off. + operationPollRateLimiter := flowcontrol.NewFakeAlwaysRateLimiter() + if config.CloudProviderRateLimit { // Assign rate limit defaults if no configuration was passed in - if az.CloudProviderRateLimitQPS == 0 { - az.CloudProviderRateLimitQPS = rateLimitQPSDefault + if config.CloudProviderRateLimitQPS == 0 { + config.CloudProviderRateLimitQPS = rateLimitQPSDefault } - if az.CloudProviderRateLimitBucket == 0 { - az.CloudProviderRateLimitBucket = rateLimitBucketDefault + if config.CloudProviderRateLimitBucket == 0 { + config.CloudProviderRateLimitBucket = rateLimitBucketDefault } - az.operationPollRateLimiter = flowcontrol.NewTokenBucketRateLimiter( - az.CloudProviderRateLimitQPS, - az.CloudProviderRateLimitBucket) + operationPollRateLimiter = flowcontrol.NewTokenBucketRateLimiter( + config.CloudProviderRateLimitQPS, + config.CloudProviderRateLimitBucket) glog.V(2).Infof("Azure cloudprovider using rate limit config: QPS=%g, bucket=%d", - az.CloudProviderRateLimitQPS, - az.CloudProviderRateLimitBucket) - } else { - // if rate limits are configured off, az.operationPollRateLimiter.Accept() is a no-op - az.operationPollRateLimiter = flowcontrol.NewFakeAlwaysRateLimiter() + config.CloudProviderRateLimitQPS, + config.CloudProviderRateLimitBucket) + } + + azClientConfig := &azClientConfig{ + subscriptionID: config.SubscriptionID, + resourceManagerEndpoint: env.ResourceManagerEndpoint, + servicePrincipalToken: servicePrincipalToken, + rateLimiter: operationPollRateLimiter, + } + az := Cloud{ + Config: *config, + Environment: *env, + + DisksClient: newAzDisksClient(azClientConfig), + RoutesClient: newAzRoutesClient(azClientConfig), + SubnetsClient: newAzSubnetsClient(azClientConfig), + InterfacesClient: newAzInterfacesClient(azClientConfig), + RouteTablesClient: newAzRouteTablesClient(azClientConfig), + LoadBalancerClient: newAzLoadBalancersClient(azClientConfig), + SecurityGroupsClient: newAzSecurityGroupsClient(azClientConfig), + StorageAccountClient: newAzStorageAccountClient(azClientConfig), + VirtualMachinesClient: newAzVirtualMachinesClient(azClientConfig), + PublicIPAddressesClient: newAzPublicIPAddressesClient(azClientConfig), + VirtualMachineScaleSetsClient: newAzVirtualMachineScaleSetsClient(azClientConfig), + VirtualMachineScaleSetVMsClient: newAzVirtualMachineScaleSetVMsClient(azClientConfig), } // Conditionally configure resource request backoff diff --git a/pkg/cloudprovider/providers/azure/azure_backoff.go b/pkg/cloudprovider/providers/azure/azure_backoff.go index 099fea81fe1..ff0e16bfd7d 100644 --- a/pkg/cloudprovider/providers/azure/azure_backoff.go +++ b/pkg/cloudprovider/providers/azure/azure_backoff.go @@ -67,10 +67,7 @@ func (az *Cloud) VirtualMachineClientListWithRetry() ([]compute.VirtualMachine, var result compute.VirtualMachineListResult err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { var retryErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachinesClient.List(%v): start", az.ResourceGroup) result, retryErr = az.VirtualMachinesClient.List(az.ResourceGroup) - glog.V(10).Infof("VirtualMachinesClient.List(%v): end", az.ResourceGroup) if retryErr != nil { glog.Errorf("VirtualMachinesClient.List(%v) - backoff: failure, will retry,err=%v", az.ResourceGroup, @@ -92,10 +89,7 @@ func (az *Cloud) VirtualMachineClientListWithRetry() ([]compute.VirtualMachine, if result.NextLink != nil { err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { var retryErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachinesClient.ListNextResults(%v): start", az.ResourceGroup) result, retryErr = az.VirtualMachinesClient.ListNextResults(result) - glog.V(10).Infof("VirtualMachinesClient.ListNextResults(%v): end", az.ResourceGroup) if retryErr != nil { glog.Errorf("VirtualMachinesClient.ListNextResults(%v) - backoff: failure, will retry,err=%v", az.ResourceGroup, retryErr) @@ -133,8 +127,6 @@ func (az *Cloud) GetIPForMachineWithRetry(name types.NodeName) (string, error) { // CreateOrUpdateSGWithRetry invokes az.SecurityGroupsClient.CreateOrUpdate with exponential backoff retry func (az *Cloud) CreateOrUpdateSGWithRetry(sg network.SecurityGroup) error { return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("SecurityGroupsClient.CreateOrUpdate(%s): start", *sg.Name) respChan, errChan := az.SecurityGroupsClient.CreateOrUpdate(az.ResourceGroup, *sg.Name, sg, nil) resp := <-respChan err := <-errChan @@ -146,8 +138,6 @@ 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) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("LoadBalancerClient.CreateOrUpdate(%s): start", *lb.Name) respChan, errChan := az.LoadBalancerClient.CreateOrUpdate(az.ResourceGroup, *lb.Name, lb, nil) resp := <-respChan err := <-errChan @@ -163,10 +153,7 @@ func (az *Cloud) ListLBWithRetry() ([]network.LoadBalancer, error) { err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { var retryErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("LoadBalancerClient.List(%v): start", az.ResourceGroup) result, retryErr = az.LoadBalancerClient.List(az.ResourceGroup) - glog.V(10).Infof("LoadBalancerClient.List(%v): end", az.ResourceGroup) if retryErr != nil { glog.Errorf("LoadBalancerClient.List(%v) - backoff: failure, will retry,err=%v", az.ResourceGroup, @@ -189,10 +176,7 @@ func (az *Cloud) ListLBWithRetry() ([]network.LoadBalancer, error) { if result.NextLink != nil { err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { var retryErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("LoadBalancerClient.ListNextResults(%v): start", az.ResourceGroup) result, retryErr = az.LoadBalancerClient.ListNextResults(result) - glog.V(10).Infof("LoadBalancerClient.ListNextResults(%v): end", az.ResourceGroup) if retryErr != nil { glog.Errorf("LoadBalancerClient.ListNextResults(%v) - backoff: failure, will retry,err=%v", az.ResourceGroup, @@ -218,10 +202,7 @@ func (az *Cloud) ListPIPWithRetry(pipResourceGroup string) ([]network.PublicIPAd var result network.PublicIPAddressListResult err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { var retryErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("PublicIPAddressesClient.List(%v): start", pipResourceGroup) result, retryErr = az.PublicIPAddressesClient.List(pipResourceGroup) - glog.V(10).Infof("PublicIPAddressesClient.List(%v): end", pipResourceGroup) if retryErr != nil { glog.Errorf("PublicIPAddressesClient.List(%v) - backoff: failure, will retry,err=%v", pipResourceGroup, @@ -244,10 +225,7 @@ func (az *Cloud) ListPIPWithRetry(pipResourceGroup string) ([]network.PublicIPAd if result.NextLink != nil { err := wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { var retryErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("PublicIPAddressesClient.ListNextResults(%v): start", pipResourceGroup) result, retryErr = az.PublicIPAddressesClient.ListNextResults(result) - glog.V(10).Infof("PublicIPAddressesClient.ListNextResults(%v): end", pipResourceGroup) if retryErr != nil { glog.Errorf("PublicIPAddressesClient.ListNextResults(%v) - backoff: failure, will retry,err=%v", pipResourceGroup, @@ -270,8 +248,6 @@ func (az *Cloud) ListPIPWithRetry(pipResourceGroup string) ([]network.PublicIPAd // 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) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("PublicIPAddressesClient.CreateOrUpdate(%s, %s): start", pipResourceGroup, *pip.Name) respChan, errChan := az.PublicIPAddressesClient.CreateOrUpdate(pipResourceGroup, *pip.Name, pip, nil) resp := <-respChan err := <-errChan @@ -283,8 +259,6 @@ func (az *Cloud) CreateOrUpdatePIPWithRetry(pipResourceGroup string, pip network // CreateOrUpdateInterfaceWithRetry invokes az.PublicIPAddressesClient.CreateOrUpdate with exponential backoff retry func (az *Cloud) CreateOrUpdateInterfaceWithRetry(nic network.Interface) error { return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("InterfacesClient.CreateOrUpdate(%s): start", *nic.Name) respChan, errChan := az.InterfacesClient.CreateOrUpdate(az.ResourceGroup, *nic.Name, nic, nil) resp := <-respChan err := <-errChan @@ -296,12 +270,9 @@ 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) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("PublicIPAddressesClient.Delete(%s, %s): start", pipResourceGroup, pipName) respChan, errChan := az.PublicIPAddressesClient.Delete(pipResourceGroup, pipName, nil) resp := <-respChan err := <-errChan - glog.V(10).Infof("PublicIPAddressesClient.Delete(%s, %s): end", pipResourceGroup, pipName) return processRetryResponse(resp, err) }) } @@ -309,12 +280,9 @@ func (az *Cloud) DeletePublicIPWithRetry(pipResourceGroup string, pipName string // DeleteLBWithRetry invokes az.LoadBalancerClient.Delete with exponential backoff retry func (az *Cloud) DeleteLBWithRetry(lbName string) error { return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("LoadBalancerClient.Delete(%s): start", lbName) respChan, errChan := az.LoadBalancerClient.Delete(az.ResourceGroup, lbName, nil) resp := <-respChan err := <-errChan - glog.V(10).Infof("LoadBalancerClient.Delete(%s): end", lbName) return processRetryResponse(resp, err) }) } @@ -322,12 +290,9 @@ func (az *Cloud) DeleteLBWithRetry(lbName string) error { // CreateOrUpdateRouteTableWithRetry invokes az.RouteTablesClient.CreateOrUpdate with exponential backoff retry func (az *Cloud) CreateOrUpdateRouteTableWithRetry(routeTable network.RouteTable) error { return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("RouteTablesClient.CreateOrUpdate(%s): start", *routeTable.Name) respChan, errChan := az.RouteTablesClient.CreateOrUpdate(az.ResourceGroup, az.RouteTableName, routeTable, nil) resp := <-respChan err := <-errChan - glog.V(10).Infof("RouteTablesClient.CreateOrUpdate(%s): end", *routeTable.Name) return processRetryResponse(resp.Response, err) }) } @@ -335,8 +300,6 @@ func (az *Cloud) CreateOrUpdateRouteTableWithRetry(routeTable network.RouteTable // CreateOrUpdateRouteWithRetry invokes az.RoutesClient.CreateOrUpdate with exponential backoff retry func (az *Cloud) CreateOrUpdateRouteWithRetry(route network.Route) error { return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("RoutesClient.CreateOrUpdate(%s): start", *route.Name) respChan, errChan := az.RoutesClient.CreateOrUpdate(az.ResourceGroup, az.RouteTableName, *route.Name, route, nil) resp := <-respChan err := <-errChan @@ -348,8 +311,6 @@ func (az *Cloud) CreateOrUpdateRouteWithRetry(route network.Route) error { // DeleteRouteWithRetry invokes az.RoutesClient.Delete with exponential backoff retry func (az *Cloud) DeleteRouteWithRetry(routeName string) error { return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("RoutesClient.Delete(%s): start", az.RouteTableName) respChan, errChan := az.RoutesClient.Delete(az.ResourceGroup, az.RouteTableName, routeName, nil) resp := <-respChan err := <-errChan @@ -361,8 +322,6 @@ func (az *Cloud) DeleteRouteWithRetry(routeName string) error { // CreateOrUpdateVMWithRetry invokes az.VirtualMachinesClient.CreateOrUpdate with exponential backoff retry func (az *Cloud) CreateOrUpdateVMWithRetry(vmName string, newVM compute.VirtualMachine) error { return wait.ExponentialBackoff(az.requestBackoff(), func() (bool, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachinesClient.CreateOrUpdate(%s): start", vmName) respChan, errChan := az.VirtualMachinesClient.CreateOrUpdate(az.ResourceGroup, vmName, newVM, nil) resp := <-respChan err := <-errChan diff --git a/pkg/cloudprovider/providers/azure/azure_client.go b/pkg/cloudprovider/providers/azure/azure_client.go new file mode 100644 index 00000000000..7cf65fe13e9 --- /dev/null +++ b/pkg/cloudprovider/providers/azure/azure_client.go @@ -0,0 +1,819 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package azure + +import ( + "time" + + "github.com/Azure/azure-sdk-for-go/arm/compute" + "github.com/Azure/azure-sdk-for-go/arm/disk" + "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/arm/storage" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/adal" + "github.com/golang/glog" + + "k8s.io/client-go/util/flowcontrol" +) + +// VirtualMachinesClient defines needed functions for azure compute.VirtualMachinesClient +type VirtualMachinesClient interface { + CreateOrUpdate(resourceGroupName string, VMName string, parameters compute.VirtualMachine, cancel <-chan struct{}) (<-chan compute.VirtualMachine, <-chan error) + Get(resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (result compute.VirtualMachine, err error) + List(resourceGroupName string) (result compute.VirtualMachineListResult, err error) + ListNextResults(lastResults compute.VirtualMachineListResult) (result compute.VirtualMachineListResult, err error) +} + +// InterfacesClient defines needed functions for azure network.InterfacesClient +type InterfacesClient interface { + CreateOrUpdate(resourceGroupName string, networkInterfaceName string, parameters network.Interface, cancel <-chan struct{}) (<-chan network.Interface, <-chan error) + Get(resourceGroupName string, networkInterfaceName string, expand string) (result network.Interface, err error) + GetVirtualMachineScaleSetNetworkInterface(resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result network.Interface, err error) +} + +// 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) + Delete(resourceGroupName string, loadBalancerName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) + Get(resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error) + List(resourceGroupName string) (result network.LoadBalancerListResult, err error) + ListNextResults(lastResult network.LoadBalancerListResult) (result network.LoadBalancerListResult, 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) + Delete(resourceGroupName string, publicIPAddressName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) + Get(resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error) + List(resourceGroupName string) (result network.PublicIPAddressListResult, err error) + ListNextResults(lastResults network.PublicIPAddressListResult) (result network.PublicIPAddressListResult, err error) +} + +// SubnetsClient defines needed functions for azure network.SubnetsClient +type SubnetsClient interface { + CreateOrUpdate(resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters network.Subnet, cancel <-chan struct{}) (<-chan network.Subnet, <-chan error) + Delete(resourceGroupName string, virtualNetworkName string, subnetName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) + Get(resourceGroupName string, virtualNetworkName string, subnetName string, expand string) (result network.Subnet, err error) + List(resourceGroupName string, virtualNetworkName string) (result network.SubnetListResult, err error) +} + +// SecurityGroupsClient defines needed functions for azure network.SecurityGroupsClient +type SecurityGroupsClient interface { + CreateOrUpdate(resourceGroupName string, networkSecurityGroupName string, parameters network.SecurityGroup, cancel <-chan struct{}) (<-chan network.SecurityGroup, <-chan error) + Delete(resourceGroupName string, networkSecurityGroupName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) + Get(resourceGroupName string, networkSecurityGroupName string, expand string) (result network.SecurityGroup, err error) + List(resourceGroupName string) (result network.SecurityGroupListResult, err error) +} + +// VirtualMachineScaleSetsClient defines needed functions for azure compute.VirtualMachineScaleSetsClient +type VirtualMachineScaleSetsClient interface { + CreateOrUpdate(resourceGroupName string, VMScaleSetName string, parameters compute.VirtualMachineScaleSet, cancel <-chan struct{}) (<-chan compute.VirtualMachineScaleSet, <-chan error) + Get(resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSet, err error) + List(resourceGroupName string) (result compute.VirtualMachineScaleSetListResult, err error) + ListNextResults(lastResults compute.VirtualMachineScaleSetListResult) (result compute.VirtualMachineScaleSetListResult, err error) + UpdateInstances(resourceGroupName string, VMScaleSetName string, VMInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs, cancel <-chan struct{}) (<-chan compute.OperationStatusResponse, <-chan error) +} + +// VirtualMachineScaleSetVMsClient defines needed functions for azure compute.VirtualMachineScaleSetVMsClient +type VirtualMachineScaleSetVMsClient interface { + Get(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVM, err error) + GetInstanceView(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMInstanceView, err error) + List(resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result compute.VirtualMachineScaleSetVMListResult, err error) + ListNextResults(lastResults compute.VirtualMachineScaleSetVMListResult) (result compute.VirtualMachineScaleSetVMListResult, err error) +} + +// RoutesClient defines needed functions for azure network.RoutesClient +type RoutesClient interface { + CreateOrUpdate(resourceGroupName string, routeTableName string, routeName string, routeParameters network.Route, cancel <-chan struct{}) (<-chan network.Route, <-chan error) + Delete(resourceGroupName string, routeTableName string, routeName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) +} + +// RouteTablesClient defines needed functions for azure network.RouteTablesClient +type RouteTablesClient interface { + CreateOrUpdate(resourceGroupName string, routeTableName string, parameters network.RouteTable, cancel <-chan struct{}) (<-chan network.RouteTable, <-chan error) + Get(resourceGroupName string, routeTableName string, expand string) (result network.RouteTable, err error) +} + +// StorageAccountClient defines needed functions for azure storage.AccountsClient +type StorageAccountClient interface { + Create(resourceGroupName string, accountName string, parameters storage.AccountCreateParameters, cancel <-chan struct{}) (<-chan storage.Account, <-chan error) + Delete(resourceGroupName string, accountName string) (result autorest.Response, err error) + ListKeys(resourceGroupName string, accountName string) (result storage.AccountListKeysResult, err error) + ListByResourceGroup(resourceGroupName string) (result storage.AccountListResult, err error) + GetProperties(resourceGroupName string, accountName string) (result storage.Account, err error) +} + +// DisksClient defines needed functions for azure disk.DisksClient +type DisksClient interface { + CreateOrUpdate(resourceGroupName string, diskName string, diskParameter disk.Model, cancel <-chan struct{}) (<-chan disk.Model, <-chan error) + Delete(resourceGroupName string, diskName string, cancel <-chan struct{}) (<-chan disk.OperationStatusResponse, <-chan error) + Get(resourceGroupName string, diskName string) (result disk.Model, err error) +} + +// azClientConfig contains all essential information to create an Azure client. +type azClientConfig struct { + subscriptionID string + resourceManagerEndpoint string + servicePrincipalToken *adal.ServicePrincipalToken + rateLimiter flowcontrol.RateLimiter +} + +// azVirtualMachinesClient implements VirtualMachinesClient. +type azVirtualMachinesClient struct { + client compute.VirtualMachinesClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzVirtualMachinesClient(config *azClientConfig) *azVirtualMachinesClient { + virtualMachinesClient := compute.NewVirtualMachinesClient(config.subscriptionID) + virtualMachinesClient.BaseURI = config.resourceManagerEndpoint + virtualMachinesClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + virtualMachinesClient.PollingDelay = 5 * time.Second + configureUserAgent(&virtualMachinesClient.Client) + + return &azVirtualMachinesClient{ + rateLimiter: config.rateLimiter, + client: virtualMachinesClient, + } +} + +func (az *azVirtualMachinesClient) CreateOrUpdate(resourceGroupName string, VMName string, parameters compute.VirtualMachine, cancel <-chan struct{}) (<-chan compute.VirtualMachine, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachinesClient.CreateOrUpdate(%q, %q): start", resourceGroupName, VMName) + defer func() { + glog.V(10).Infof("azVirtualMachinesClient.CreateOrUpdate(%q, %q): end", resourceGroupName, VMName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, VMName, parameters, cancel) +} + +func (az *azVirtualMachinesClient) Get(resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (result compute.VirtualMachine, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachinesClient.Get(%q, %q): start", resourceGroupName, VMName) + defer func() { + glog.V(10).Infof("azVirtualMachinesClient.Get(%q, %q): end", resourceGroupName, VMName) + }() + + return az.client.Get(resourceGroupName, VMName, expand) +} + +func (az *azVirtualMachinesClient) List(resourceGroupName string) (result compute.VirtualMachineListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachinesClient.List(%q): start", resourceGroupName) + defer func() { + glog.V(10).Infof("azVirtualMachinesClient.List(%q): end", resourceGroupName) + }() + + return az.client.List(resourceGroupName) +} + +func (az *azVirtualMachinesClient) ListNextResults(lastResults compute.VirtualMachineListResult) (result compute.VirtualMachineListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachinesClient.ListNextResults(%q): start", lastResults) + defer func() { + glog.V(10).Infof("azVirtualMachinesClient.ListNextResults(%q): end", lastResults) + }() + + return az.client.ListNextResults(lastResults) +} + +// azInterfacesClient implements InterfacesClient. +type azInterfacesClient struct { + client network.InterfacesClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzInterfacesClient(config *azClientConfig) *azInterfacesClient { + interfacesClient := network.NewInterfacesClient(config.subscriptionID) + interfacesClient.BaseURI = config.resourceManagerEndpoint + interfacesClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + interfacesClient.PollingDelay = 5 * time.Second + configureUserAgent(&interfacesClient.Client) + + return &azInterfacesClient{ + rateLimiter: config.rateLimiter, + client: interfacesClient, + } +} + +func (az *azInterfacesClient) CreateOrUpdate(resourceGroupName string, networkInterfaceName string, parameters network.Interface, cancel <-chan struct{}) (<-chan network.Interface, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azInterfacesClient.CreateOrUpdate(%q,%q): start", resourceGroupName, networkInterfaceName) + defer func() { + glog.V(10).Infof("azInterfacesClient.CreateOrUpdate(%q,%q): end", resourceGroupName, networkInterfaceName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, networkInterfaceName, parameters, cancel) +} + +func (az *azInterfacesClient) Get(resourceGroupName string, networkInterfaceName string, expand string) (result network.Interface, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azInterfacesClient.Get(%q,%q): start", resourceGroupName, networkInterfaceName) + defer func() { + glog.V(10).Infof("azInterfacesClient.Get(%q,%q): end", resourceGroupName, networkInterfaceName) + }() + + return az.client.Get(resourceGroupName, networkInterfaceName, expand) +} + +func (az *azInterfacesClient) GetVirtualMachineScaleSetNetworkInterface(resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result network.Interface, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azInterfacesClient.GetVirtualMachineScaleSetNetworkInterface(%q,%q,%q,%q): start", resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName) + defer func() { + glog.V(10).Infof("azInterfacesClient.GetVirtualMachineScaleSetNetworkInterface(%q,%q,%q,%q): end", resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName) + }() + + return az.client.GetVirtualMachineScaleSetNetworkInterface(resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand) +} + +// azLoadBalancersClient implements LoadBalancersClient. +type azLoadBalancersClient struct { + client network.LoadBalancersClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzLoadBalancersClient(config *azClientConfig) *azLoadBalancersClient { + loadBalancerClient := network.NewLoadBalancersClient(config.subscriptionID) + loadBalancerClient.BaseURI = config.resourceManagerEndpoint + loadBalancerClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + loadBalancerClient.PollingDelay = 5 * time.Second + configureUserAgent(&loadBalancerClient.Client) + + return &azLoadBalancersClient{ + rateLimiter: config.rateLimiter, + client: loadBalancerClient, + } +} + +func (az *azLoadBalancersClient) CreateOrUpdate(resourceGroupName string, loadBalancerName string, parameters network.LoadBalancer, cancel <-chan struct{}) (<-chan network.LoadBalancer, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azLoadBalancersClient.CreateOrUpdate(%q,%q): start", resourceGroupName, loadBalancerName) + defer func() { + glog.V(10).Infof("azLoadBalancersClient.CreateOrUpdate(%q,%q): end", resourceGroupName, loadBalancerName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, loadBalancerName, parameters, cancel) +} + +func (az *azLoadBalancersClient) Delete(resourceGroupName string, loadBalancerName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azLoadBalancersClient.Delete(%q,%q): start", resourceGroupName, loadBalancerName) + defer func() { + glog.V(10).Infof("azLoadBalancersClient.Delete(%q,%q): end", resourceGroupName, loadBalancerName) + }() + + return az.client.Delete(resourceGroupName, loadBalancerName, cancel) +} + +func (az *azLoadBalancersClient) Get(resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azLoadBalancersClient.Get(%q,%q): start", resourceGroupName, loadBalancerName) + defer func() { + glog.V(10).Infof("azLoadBalancersClient.Get(%q,%q): end", resourceGroupName, loadBalancerName) + }() + + return az.client.Get(resourceGroupName, loadBalancerName, expand) +} + +func (az *azLoadBalancersClient) List(resourceGroupName string) (result network.LoadBalancerListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azLoadBalancersClient.List(%q): start", resourceGroupName) + defer func() { + glog.V(10).Infof("azLoadBalancersClient.List(%q): end", resourceGroupName) + }() + + return az.client.List(resourceGroupName) +} + +func (az *azLoadBalancersClient) ListNextResults(lastResult network.LoadBalancerListResult) (result network.LoadBalancerListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azLoadBalancersClient.ListNextResults(%q): start", lastResult) + defer func() { + glog.V(10).Infof("azLoadBalancersClient.ListNextResults(%q): end", lastResult) + }() + + return az.client.ListNextResults(lastResult) +} + +// azPublicIPAddressesClient implements PublicIPAddressesClient. +type azPublicIPAddressesClient struct { + client network.PublicIPAddressesClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzPublicIPAddressesClient(config *azClientConfig) *azPublicIPAddressesClient { + publicIPAddressClient := network.NewPublicIPAddressesClient(config.subscriptionID) + publicIPAddressClient.BaseURI = config.resourceManagerEndpoint + publicIPAddressClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + publicIPAddressClient.PollingDelay = 5 * time.Second + configureUserAgent(&publicIPAddressClient.Client) + + return &azPublicIPAddressesClient{ + rateLimiter: config.rateLimiter, + client: publicIPAddressClient, + } +} + +func (az *azPublicIPAddressesClient) CreateOrUpdate(resourceGroupName string, publicIPAddressName string, parameters network.PublicIPAddress, cancel <-chan struct{}) (<-chan network.PublicIPAddress, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azPublicIPAddressesClient.CreateOrUpdate(%q,%q): start", resourceGroupName, publicIPAddressName) + defer func() { + glog.V(10).Infof("azPublicIPAddressesClient.CreateOrUpdate(%q,%q): end", resourceGroupName, publicIPAddressName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, publicIPAddressName, parameters, cancel) +} + +func (az *azPublicIPAddressesClient) Delete(resourceGroupName string, publicIPAddressName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azPublicIPAddressesClient.Delete(%q,%q): start", resourceGroupName, publicIPAddressName) + defer func() { + glog.V(10).Infof("azPublicIPAddressesClient.Delete(%q,%q): end", resourceGroupName, publicIPAddressName) + }() + + return az.client.Delete(resourceGroupName, publicIPAddressName, cancel) +} + +func (az *azPublicIPAddressesClient) Get(resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azPublicIPAddressesClient.Get(%q,%q): start", resourceGroupName, publicIPAddressName) + defer func() { + glog.V(10).Infof("azPublicIPAddressesClient.Get(%q,%q): end", resourceGroupName, publicIPAddressName) + }() + + return az.client.Get(resourceGroupName, publicIPAddressName, expand) +} + +func (az *azPublicIPAddressesClient) List(resourceGroupName string) (result network.PublicIPAddressListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azPublicIPAddressesClient.List(%q): start", resourceGroupName) + defer func() { + glog.V(10).Infof("azPublicIPAddressesClient.List(%q): end", resourceGroupName) + }() + + return az.client.List(resourceGroupName) +} + +func (az *azPublicIPAddressesClient) ListNextResults(lastResults network.PublicIPAddressListResult) (result network.PublicIPAddressListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azPublicIPAddressesClient.ListNextResults(%q): start", lastResults) + defer func() { + glog.V(10).Infof("azPublicIPAddressesClient.ListNextResults(%q): end", lastResults) + }() + + return az.client.ListNextResults(lastResults) +} + +// azSubnetsClient implements SubnetsClient. +type azSubnetsClient struct { + client network.SubnetsClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzSubnetsClient(config *azClientConfig) *azSubnetsClient { + subnetsClient := network.NewSubnetsClient(config.subscriptionID) + subnetsClient.BaseURI = config.resourceManagerEndpoint + subnetsClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + subnetsClient.PollingDelay = 5 * time.Second + configureUserAgent(&subnetsClient.Client) + + return &azSubnetsClient{ + client: subnetsClient, + rateLimiter: config.rateLimiter, + } +} + +func (az *azSubnetsClient) CreateOrUpdate(resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters network.Subnet, cancel <-chan struct{}) (<-chan network.Subnet, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSubnetsClient.CreateOrUpdate(%q,%q,%q): start", resourceGroupName, virtualNetworkName, subnetName) + defer func() { + glog.V(10).Infof("azSubnetsClient.CreateOrUpdate(%q,%q,%q): end", resourceGroupName, virtualNetworkName, subnetName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, virtualNetworkName, subnetName, subnetParameters, cancel) +} + +func (az *azSubnetsClient) Delete(resourceGroupName string, virtualNetworkName string, subnetName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSubnetsClient.Delete(%q,%q,%q): start", resourceGroupName, virtualNetworkName, subnetName) + defer func() { + glog.V(10).Infof("azSubnetsClient.Delete(%q,%q,%q): end", resourceGroupName, virtualNetworkName, subnetName) + }() + + return az.client.Delete(resourceGroupName, virtualNetworkName, subnetName, cancel) +} + +func (az *azSubnetsClient) Get(resourceGroupName string, virtualNetworkName string, subnetName string, expand string) (result network.Subnet, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSubnetsClient.Get(%q,%q,%q): start", resourceGroupName, virtualNetworkName, subnetName) + defer func() { + glog.V(10).Infof("azSubnetsClient.Get(%q,%q,%q): end", resourceGroupName, virtualNetworkName, subnetName) + }() + + return az.client.Get(resourceGroupName, virtualNetworkName, subnetName, expand) +} + +func (az *azSubnetsClient) List(resourceGroupName string, virtualNetworkName string) (result network.SubnetListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSubnetsClient.List(%q,%q): start", resourceGroupName, virtualNetworkName) + defer func() { + glog.V(10).Infof("azSubnetsClient.List(%q,%q): end", resourceGroupName, virtualNetworkName) + }() + + return az.client.List(resourceGroupName, virtualNetworkName) +} + +// azSecurityGroupsClient implements SecurityGroupsClient. +type azSecurityGroupsClient struct { + client network.SecurityGroupsClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzSecurityGroupsClient(config *azClientConfig) *azSecurityGroupsClient { + securityGroupsClient := network.NewSecurityGroupsClient(config.subscriptionID) + securityGroupsClient.BaseURI = config.resourceManagerEndpoint + securityGroupsClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + securityGroupsClient.PollingDelay = 5 * time.Second + configureUserAgent(&securityGroupsClient.Client) + + return &azSecurityGroupsClient{ + rateLimiter: config.rateLimiter, + client: securityGroupsClient, + } +} + +func (az *azSecurityGroupsClient) CreateOrUpdate(resourceGroupName string, networkSecurityGroupName string, parameters network.SecurityGroup, cancel <-chan struct{}) (<-chan network.SecurityGroup, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSecurityGroupsClient.CreateOrUpdate(%q,%q): start", resourceGroupName, networkSecurityGroupName) + defer func() { + glog.V(10).Infof("azSecurityGroupsClient.CreateOrUpdate(%q,%q): end", resourceGroupName, networkSecurityGroupName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, networkSecurityGroupName, parameters, cancel) +} + +func (az *azSecurityGroupsClient) Delete(resourceGroupName string, networkSecurityGroupName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSecurityGroupsClient.Delete(%q,%q): start", resourceGroupName, networkSecurityGroupName) + defer func() { + glog.V(10).Infof("azSecurityGroupsClient.Delete(%q,%q): end", resourceGroupName, networkSecurityGroupName) + }() + + return az.client.Delete(resourceGroupName, networkSecurityGroupName, cancel) +} + +func (az *azSecurityGroupsClient) Get(resourceGroupName string, networkSecurityGroupName string, expand string) (result network.SecurityGroup, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSecurityGroupsClient.Get(%q,%q): start", resourceGroupName, networkSecurityGroupName) + defer func() { + glog.V(10).Infof("azSecurityGroupsClient.Get(%q,%q): end", resourceGroupName, networkSecurityGroupName) + }() + + return az.client.Get(resourceGroupName, networkSecurityGroupName, expand) +} + +func (az *azSecurityGroupsClient) List(resourceGroupName string) (result network.SecurityGroupListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azSecurityGroupsClient.List(%q): start", resourceGroupName) + defer func() { + glog.V(10).Infof("azSecurityGroupsClient.List(%q): end", resourceGroupName) + }() + + return az.client.List(resourceGroupName) +} + +// azVirtualMachineScaleSetsClient implements VirtualMachineScaleSetsClient. +type azVirtualMachineScaleSetsClient struct { + client compute.VirtualMachineScaleSetsClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzVirtualMachineScaleSetsClient(config *azClientConfig) *azVirtualMachineScaleSetsClient { + virtualMachineScaleSetsClient := compute.NewVirtualMachineScaleSetsClient(config.subscriptionID) + virtualMachineScaleSetsClient.BaseURI = config.resourceManagerEndpoint + virtualMachineScaleSetsClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + virtualMachineScaleSetsClient.PollingDelay = 5 * time.Second + configureUserAgent(&virtualMachineScaleSetsClient.Client) + + return &azVirtualMachineScaleSetsClient{ + client: virtualMachineScaleSetsClient, + rateLimiter: config.rateLimiter, + } +} + +func (az *azVirtualMachineScaleSetsClient) CreateOrUpdate(resourceGroupName string, VMScaleSetName string, parameters compute.VirtualMachineScaleSet, cancel <-chan struct{}) (<-chan compute.VirtualMachineScaleSet, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetsClient.CreateOrUpdate(%q,%q): start", resourceGroupName, VMScaleSetName) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetsClient.CreateOrUpdate(%q,%q): end", resourceGroupName, VMScaleSetName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, VMScaleSetName, parameters, cancel) +} + +func (az *azVirtualMachineScaleSetsClient) Get(resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSet, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetsClient.Get(%q,%q): start", resourceGroupName, VMScaleSetName) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetsClient.Get(%q,%q): end", resourceGroupName, VMScaleSetName) + }() + + return az.client.Get(resourceGroupName, VMScaleSetName) +} + +func (az *azVirtualMachineScaleSetsClient) List(resourceGroupName string) (result compute.VirtualMachineScaleSetListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetsClient.List(%q,%q): start", resourceGroupName) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetsClient.List(%q,%q): end", resourceGroupName) + }() + + return az.client.List(resourceGroupName) +} + +func (az *azVirtualMachineScaleSetsClient) ListNextResults(lastResults compute.VirtualMachineScaleSetListResult) (result compute.VirtualMachineScaleSetListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetsClient.ListNextResults(%q): start", lastResults) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetsClient.ListNextResults(%q): end", lastResults) + }() + + return az.client.ListNextResults(lastResults) +} + +func (az *azVirtualMachineScaleSetsClient) UpdateInstances(resourceGroupName string, VMScaleSetName string, VMInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs, cancel <-chan struct{}) (<-chan compute.OperationStatusResponse, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetsClient.UpdateInstances(%q,%q,%q): start", resourceGroupName, VMScaleSetName, VMInstanceIDs) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetsClient.UpdateInstances(%q,%q,%q): end", resourceGroupName, VMScaleSetName, VMInstanceIDs) + }() + + return az.client.UpdateInstances(resourceGroupName, VMScaleSetName, VMInstanceIDs, cancel) +} + +// azVirtualMachineScaleSetVMsClient implements VirtualMachineScaleSetVMsClient. +type azVirtualMachineScaleSetVMsClient struct { + client compute.VirtualMachineScaleSetVMsClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzVirtualMachineScaleSetVMsClient(config *azClientConfig) *azVirtualMachineScaleSetVMsClient { + virtualMachineScaleSetVMsClient := compute.NewVirtualMachineScaleSetVMsClient(config.subscriptionID) + virtualMachineScaleSetVMsClient.BaseURI = config.resourceManagerEndpoint + virtualMachineScaleSetVMsClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + virtualMachineScaleSetVMsClient.PollingDelay = 5 * time.Second + configureUserAgent(&virtualMachineScaleSetVMsClient.Client) + + return &azVirtualMachineScaleSetVMsClient{ + client: virtualMachineScaleSetVMsClient, + rateLimiter: config.rateLimiter, + } +} + +func (az *azVirtualMachineScaleSetVMsClient) Get(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVM, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.Get(%q,%q,%q): start", resourceGroupName, VMScaleSetName, instanceID) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.Get(%q,%q,%q): end", resourceGroupName, VMScaleSetName, instanceID) + }() + + return az.client.Get(resourceGroupName, VMScaleSetName, instanceID) +} + +func (az *azVirtualMachineScaleSetVMsClient) GetInstanceView(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMInstanceView, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.GetInstanceView(%q,%q,%q): start", resourceGroupName, VMScaleSetName, instanceID) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.GetInstanceView(%q,%q,%q): end", resourceGroupName, VMScaleSetName, instanceID) + }() + + return az.client.GetInstanceView(resourceGroupName, VMScaleSetName, instanceID) +} + +func (az *azVirtualMachineScaleSetVMsClient) List(resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result compute.VirtualMachineScaleSetVMListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.List(%q,%q,%q): start", resourceGroupName, virtualMachineScaleSetName, filter) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.List(%q,%q,%q): end", resourceGroupName, virtualMachineScaleSetName, filter) + }() + + return az.client.List(resourceGroupName, virtualMachineScaleSetName, filter, selectParameter, expand) +} + +func (az *azVirtualMachineScaleSetVMsClient) ListNextResults(lastResults compute.VirtualMachineScaleSetVMListResult) (result compute.VirtualMachineScaleSetVMListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.ListNextResults(%q,%q,%q): start", lastResults) + defer func() { + glog.V(10).Infof("azVirtualMachineScaleSetVMsClient.ListNextResults(%q,%q,%q): end", lastResults) + }() + + return az.client.ListNextResults(lastResults) +} + +// azRoutesClient implements RoutesClient. +type azRoutesClient struct { + client network.RoutesClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzRoutesClient(config *azClientConfig) *azRoutesClient { + routesClient := network.NewRoutesClient(config.subscriptionID) + routesClient.BaseURI = config.resourceManagerEndpoint + routesClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + routesClient.PollingDelay = 5 * time.Second + configureUserAgent(&routesClient.Client) + + return &azRoutesClient{ + client: routesClient, + rateLimiter: config.rateLimiter, + } +} + +func (az *azRoutesClient) CreateOrUpdate(resourceGroupName string, routeTableName string, routeName string, routeParameters network.Route, cancel <-chan struct{}) (<-chan network.Route, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azRoutesClient.CreateOrUpdate(%q,%q,%q): start", resourceGroupName, routeTableName, routeName) + defer func() { + glog.V(10).Infof("azRoutesClient.CreateOrUpdate(%q,%q,%q): end", resourceGroupName, routeTableName, routeName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, routeTableName, routeName, routeParameters, cancel) +} + +func (az *azRoutesClient) Delete(resourceGroupName string, routeTableName string, routeName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azRoutesClient.Delete(%q,%q,%q): start", resourceGroupName, routeTableName, routeName) + defer func() { + glog.V(10).Infof("azRoutesClient.Delete(%q,%q,%q): end", resourceGroupName, routeTableName, routeName) + }() + + return az.client.Delete(resourceGroupName, routeTableName, routeName, cancel) +} + +// azRouteTablesClient implements RouteTablesClient. +type azRouteTablesClient struct { + client network.RouteTablesClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzRouteTablesClient(config *azClientConfig) *azRouteTablesClient { + routeTablesClient := network.NewRouteTablesClient(config.subscriptionID) + routeTablesClient.BaseURI = config.resourceManagerEndpoint + routeTablesClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + routeTablesClient.PollingDelay = 5 * time.Second + configureUserAgent(&routeTablesClient.Client) + + return &azRouteTablesClient{ + client: routeTablesClient, + rateLimiter: config.rateLimiter, + } +} + +func (az *azRouteTablesClient) CreateOrUpdate(resourceGroupName string, routeTableName string, parameters network.RouteTable, cancel <-chan struct{}) (<-chan network.RouteTable, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azRouteTablesClient.CreateOrUpdate(%q,%q): start", resourceGroupName, routeTableName) + defer func() { + glog.V(10).Infof("azRouteTablesClient.CreateOrUpdate(%q,%q): end", resourceGroupName, routeTableName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, routeTableName, parameters, cancel) +} + +func (az *azRouteTablesClient) Get(resourceGroupName string, routeTableName string, expand string) (result network.RouteTable, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azRouteTablesClient.Get(%q,%q): start", resourceGroupName, routeTableName) + defer func() { + glog.V(10).Infof("azRouteTablesClient.Get(%q,%q): end", resourceGroupName, routeTableName) + }() + + return az.client.Get(resourceGroupName, routeTableName, expand) +} + +// azStorageAccountClient implements StorageAccountClient. +type azStorageAccountClient struct { + client storage.AccountsClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzStorageAccountClient(config *azClientConfig) *azStorageAccountClient { + storageAccountClient := storage.NewAccountsClientWithBaseURI(config.resourceManagerEndpoint, config.subscriptionID) + storageAccountClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + storageAccountClient.PollingDelay = 5 * time.Second + configureUserAgent(&storageAccountClient.Client) + + return &azStorageAccountClient{ + client: storageAccountClient, + rateLimiter: config.rateLimiter, + } +} + +func (az *azStorageAccountClient) Create(resourceGroupName string, accountName string, parameters storage.AccountCreateParameters, cancel <-chan struct{}) (<-chan storage.Account, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azStorageAccountClient.Create(%q,%q): start", resourceGroupName, accountName) + defer func() { + glog.V(10).Infof("azStorageAccountClient.Create(%q,%q): end", resourceGroupName, accountName) + }() + + return az.client.Create(resourceGroupName, accountName, parameters, cancel) +} + +func (az *azStorageAccountClient) Delete(resourceGroupName string, accountName string) (result autorest.Response, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azStorageAccountClient.Delete(%q,%q): start", resourceGroupName, accountName) + defer func() { + glog.V(10).Infof("azStorageAccountClient.Delete(%q,%q): end", resourceGroupName, accountName) + }() + + return az.client.Delete(resourceGroupName, accountName) +} + +func (az *azStorageAccountClient) ListKeys(resourceGroupName string, accountName string) (result storage.AccountListKeysResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azStorageAccountClient.ListKeys(%q,%q): start", resourceGroupName, accountName) + defer func() { + glog.V(10).Infof("azStorageAccountClient.ListKeys(%q,%q): end", resourceGroupName, accountName) + }() + + return az.client.ListKeys(resourceGroupName, accountName) +} + +func (az *azStorageAccountClient) ListByResourceGroup(resourceGroupName string) (result storage.AccountListResult, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azStorageAccountClient.ListByResourceGroup(%q): start", resourceGroupName) + defer func() { + glog.V(10).Infof("azStorageAccountClient.ListByResourceGroup(%q): end", resourceGroupName) + }() + + return az.client.ListByResourceGroup(resourceGroupName) +} + +func (az *azStorageAccountClient) GetProperties(resourceGroupName string, accountName string) (result storage.Account, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azStorageAccountClient.GetProperties(%q,%q): start", resourceGroupName, accountName) + defer func() { + glog.V(10).Infof("azStorageAccountClient.GetProperties(%q,%q): end", resourceGroupName, accountName) + }() + + return az.client.GetProperties(resourceGroupName, accountName) +} + +// azDisksClient implements DisksClient. +type azDisksClient struct { + client disk.DisksClient + rateLimiter flowcontrol.RateLimiter +} + +func newAzDisksClient(config *azClientConfig) *azDisksClient { + disksClient := disk.NewDisksClientWithBaseURI(config.resourceManagerEndpoint, config.subscriptionID) + disksClient.Authorizer = autorest.NewBearerAuthorizer(config.servicePrincipalToken) + disksClient.PollingDelay = 5 * time.Second + configureUserAgent(&disksClient.Client) + + return &azDisksClient{ + client: disksClient, + rateLimiter: config.rateLimiter, + } +} + +func (az *azDisksClient) CreateOrUpdate(resourceGroupName string, diskName string, diskParameter disk.Model, cancel <-chan struct{}) (<-chan disk.Model, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azDisksClient.CreateOrUpdate(%q,%q): start", resourceGroupName, diskName) + defer func() { + glog.V(10).Infof("azDisksClient.CreateOrUpdate(%q,%q): end", resourceGroupName, diskName) + }() + + return az.client.CreateOrUpdate(resourceGroupName, diskName, diskParameter, cancel) +} + +func (az *azDisksClient) Delete(resourceGroupName string, diskName string, cancel <-chan struct{}) (<-chan disk.OperationStatusResponse, <-chan error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azDisksClient.Delete(%q,%q): start", resourceGroupName, diskName) + defer func() { + glog.V(10).Infof("azDisksClient.Delete(%q,%q): end", resourceGroupName, diskName) + }() + + return az.client.Delete(resourceGroupName, diskName, cancel) +} + +func (az *azDisksClient) Get(resourceGroupName string, diskName string) (result disk.Model, err error) { + az.rateLimiter.Accept() + glog.V(10).Infof("azDisksClient.Get(%q,%q): start", resourceGroupName, diskName) + defer func() { + glog.V(10).Infof("azDisksClient.Get(%q,%q): end", resourceGroupName, diskName) + }() + + return az.client.Get(resourceGroupName, diskName) +} diff --git a/pkg/cloudprovider/providers/azure/azure_controllerCommon.go b/pkg/cloudprovider/providers/azure/azure_controllerCommon.go index ea32f3f477f..ad40f3c5b85 100644 --- a/pkg/cloudprovider/providers/azure/azure_controllerCommon.go +++ b/pkg/cloudprovider/providers/azure/azure_controllerCommon.go @@ -110,7 +110,6 @@ func (c *controllerCommon) AttachDisk(isManagedDisk bool, diskName, diskURI stri } vmName := mapNodeNameToVMName(nodeName) glog.V(2).Infof("azureDisk - update(%s): vm(%s) - attach disk", c.resourceGroup, vmName) - c.cloud.operationPollRateLimiter.Accept() respChan, errChan := c.cloud.VirtualMachinesClient.CreateOrUpdate(c.resourceGroup, vmName, newVM, nil) resp := <-respChan err = <-errChan @@ -176,7 +175,6 @@ func (c *controllerCommon) DetachDiskByName(diskName, diskURI string, nodeName t } vmName := mapNodeNameToVMName(nodeName) glog.V(2).Infof("azureDisk - update(%s): vm(%s) - detach disk", c.resourceGroup, vmName) - c.cloud.operationPollRateLimiter.Accept() respChan, errChan := c.cloud.VirtualMachinesClient.CreateOrUpdate(c.resourceGroup, vmName, newVM, nil) resp := <-respChan err = <-errChan diff --git a/pkg/cloudprovider/providers/azure/azure_loadbalancer.go b/pkg/cloudprovider/providers/azure/azure_loadbalancer.go index 46e594ae9ce..2492b9f1cd4 100644 --- a/pkg/cloudprovider/providers/azure/azure_loadbalancer.go +++ b/pkg/cloudprovider/providers/azure/azure_loadbalancer.go @@ -415,7 +415,6 @@ func (az *Cloud) ensurePublicIPExists(service *v1.Service, pipName string, domai } pip.Tags = &map[string]*string{"service": &serviceName} glog.V(3).Infof("ensure(%s): pip(%s) - creating", serviceName, *pip.Name) - az.operationPollRateLimiter.Accept() glog.V(10).Infof("CreateOrUpdatePIPWithRetry(%s, %q): start", pipResourceGroup, *pip.Name) err = az.CreateOrUpdatePIPWithRetry(pipResourceGroup, pip) if err != nil { @@ -424,10 +423,7 @@ func (az *Cloud) ensurePublicIPExists(service *v1.Service, pipName string, domai } glog.V(10).Infof("CreateOrUpdatePIPWithRetry(%s, %q): end", pipResourceGroup, *pip.Name) - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("PublicIPAddressesClient.Get(%s, %q): start", pipResourceGroup, *pip.Name) pip, err = az.PublicIPAddressesClient.Get(pipResourceGroup, *pip.Name, "") - glog.V(10).Infof("PublicIPAddressesClient.Get(%s, %q): end", pipResourceGroup, *pip.Name) if err != nil { return nil, err } @@ -762,14 +758,13 @@ func (az *Cloud) reconcileLoadBalancer(clusterName string, service *v1.Service, glog.V(10).Infof("EnsureBackendPoolDeleted(%s, %s): end", lbBackendPoolID, vmSetName) // Remove the LB. - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("LoadBalancerClient.Delete(%q): start", lbName) + glog.V(10).Infof("az.DeleteLBWithRetry(%q): start", lbName) err = az.DeleteLBWithRetry(lbName) if err != nil { glog.V(2).Infof("delete(%s) abort backoff: lb(%s) - deleting; no remaining frontendipconfigs", serviceName, lbName) return nil, err } - glog.V(10).Infof("LoadBalancerClient.Delete(%q): end", lbName) + glog.V(10).Infof("az.DeleteLBWithRetry(%q): end", lbName) } else { glog.V(3).Infof("ensure(%s): lb(%s) - updating", serviceName, lbName) err := az.CreateOrUpdateLBWithRetry(*lb) @@ -808,10 +803,7 @@ func (az *Cloud) reconcileSecurityGroup(clusterName string, service *v1.Service, ports = []v1.ServicePort{} } - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("SecurityGroupsClient.Get(%q): start", az.SecurityGroupName) sg, err := az.SecurityGroupsClient.Get(az.ResourceGroup, az.SecurityGroupName, "") - glog.V(10).Infof("SecurityGroupsClient.Get(%q): end", az.SecurityGroupName) if err != nil { return nil, err } @@ -980,7 +972,6 @@ func (az *Cloud) reconcileSecurityGroup(clusterName string, service *v1.Service, if dirtySg { sg.SecurityRules = &updatedRules glog.V(3).Infof("ensure(%s): sg(%s) - updating", serviceName, *sg.Name) - az.operationPollRateLimiter.Accept() glog.V(10).Infof("CreateOrUpdateSGWithRetry(%q): start", *sg.Name) err := az.CreateOrUpdateSGWithRetry(sg) if err != nil { @@ -1169,7 +1160,6 @@ func (az *Cloud) reconcilePublicIP(clusterName string, service *v1.Service, want // Public ip resource with match service tag } else { glog.V(2).Infof("ensure(%s): pip(%s) - deleting", serviceName, pipName) - az.operationPollRateLimiter.Accept() glog.V(10).Infof("DeletePublicIPWithRetry(%s, %q): start", pipResourceGroup, pipName) err = az.DeletePublicIPWithRetry(pipResourceGroup, pipName) if err != nil { diff --git a/pkg/cloudprovider/providers/azure/azure_routes.go b/pkg/cloudprovider/providers/azure/azure_routes.go index 60c5049b052..eef61003ff8 100644 --- a/pkg/cloudprovider/providers/azure/azure_routes.go +++ b/pkg/cloudprovider/providers/azure/azure_routes.go @@ -77,8 +77,6 @@ func (az *Cloud) CreateRoute(clusterName string, nameHint string, kubeRoute *clo } glog.V(3).Infof("create: creating routetable. routeTableName=%q", az.RouteTableName) - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("RouteTablesClient.CreateOrUpdate(%q): start", az.RouteTableName) respChan, errChan := az.RouteTablesClient.CreateOrUpdate(az.ResourceGroup, az.RouteTableName, routeTable, nil) resp := <-respChan err := <-errChan @@ -119,8 +117,6 @@ func (az *Cloud) CreateRoute(clusterName string, nameHint string, kubeRoute *clo } glog.V(3).Infof("create: creating route: instance=%q cidr=%q", kubeRoute.TargetNode, kubeRoute.DestinationCIDR) - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("RoutesClient.CreateOrUpdate(%q): start", az.RouteTableName) respChan, errChan := az.RoutesClient.CreateOrUpdate(az.ResourceGroup, az.RouteTableName, *route.Name, route, nil) resp := <-respChan err = <-errChan @@ -147,8 +143,6 @@ func (az *Cloud) DeleteRoute(clusterName string, kubeRoute *cloudprovider.Route) glog.V(2).Infof("delete: deleting route. clusterName=%q instance=%q cidr=%q", clusterName, kubeRoute.TargetNode, kubeRoute.DestinationCIDR) routeName := mapNodeNameToRouteName(kubeRoute.TargetNode) - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("RoutesClient.Delete(%q): start", az.RouteTableName) respChan, errChan := az.RoutesClient.Delete(az.ResourceGroup, az.RouteTableName, routeName, nil) resp := <-respChan err := <-errChan diff --git a/pkg/cloudprovider/providers/azure/azure_storageaccount.go b/pkg/cloudprovider/providers/azure/azure_storageaccount.go index ad69c0a532f..4d33fb21e66 100644 --- a/pkg/cloudprovider/providers/azure/azure_storageaccount.go +++ b/pkg/cloudprovider/providers/azure/azure_storageaccount.go @@ -19,8 +19,6 @@ package azure import ( "fmt" "strings" - - "github.com/golang/glog" ) type accountWithLocation struct { @@ -29,10 +27,7 @@ type accountWithLocation struct { // getStorageAccounts gets the storage accounts' name, type, location in a resource group func (az *Cloud) getStorageAccounts() ([]accountWithLocation, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("StorageAccountClient.ListByResourceGroup(%v): start", az.ResourceGroup) result, err := az.StorageAccountClient.ListByResourceGroup(az.ResourceGroup) - glog.V(10).Infof("StorageAccountClient.ListByResourceGroup(%v): end", az.ResourceGroup) if err != nil { return nil, err } @@ -61,10 +56,7 @@ func (az *Cloud) getStorageAccounts() ([]accountWithLocation, error) { // getStorageAccesskey gets the storage account access key func (az *Cloud) getStorageAccesskey(account string) (string, error) { - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("StorageAccountClient.ListKeys(%q): start", account) result, err := az.StorageAccountClient.ListKeys(az.ResourceGroup, account) - glog.V(10).Infof("StorageAccountClient.ListKeys(%q): end", account) if err != nil { return "", err } diff --git a/pkg/cloudprovider/providers/azure/azure_test.go b/pkg/cloudprovider/providers/azure/azure_test.go index 47181bb0d3f..40a1153680b 100644 --- a/pkg/cloudprovider/providers/azure/azure_test.go +++ b/pkg/cloudprovider/providers/azure/azure_test.go @@ -25,7 +25,6 @@ import ( "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/client-go/util/flowcontrol" serviceapi "k8s.io/kubernetes/pkg/api/v1/service" "k8s.io/kubernetes/pkg/cloudprovider/providers/azure/auth" kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis" @@ -862,7 +861,6 @@ func getTestCloud() (az *Cloud) { MaximumLoadBalancerRuleCount: 250, }, } - az.operationPollRateLimiter = flowcontrol.NewTokenBucketRateLimiter(100, 100) az.LoadBalancerClient = newFakeAzureLBClient() az.PublicIPAddressesClient = newFakeAzurePIPClient(az.Config.SubscriptionID) az.SubnetsClient = newFakeAzureSubnetsClient() diff --git a/pkg/cloudprovider/providers/azure/azure_util.go b/pkg/cloudprovider/providers/azure/azure_util.go index c7fcef10ebd..7a42ab52cd6 100644 --- a/pkg/cloudprovider/providers/azure/azure_util.go +++ b/pkg/cloudprovider/providers/azure/azure_util.go @@ -389,7 +389,6 @@ func (as *availabilitySet) GetInstanceIDByNodeName(name string) (string, error) var machine compute.VirtualMachine var err error - as.operationPollRateLimiter.Accept() machine, err = as.getVirtualMachine(types.NodeName(name)) if err != nil { if as.CloudProviderBackoff { @@ -563,7 +562,6 @@ func (as *availabilitySet) GetVMSetNames(service *v1.Service, nodes []*v1.Node) func (as *availabilitySet) GetPrimaryInterface(nodeName, vmSetName string) (network.Interface, error) { var machine compute.VirtualMachine - as.operationPollRateLimiter.Accept() machine, err := as.GetVirtualMachineWithRetry(types.NodeName(nodeName)) if err != nil { glog.V(2).Infof("GetPrimaryInterface(%s, %s) abort backoff", nodeName, vmSetName) @@ -589,10 +587,7 @@ func (as *availabilitySet) GetPrimaryInterface(nodeName, vmSetName string) (netw } } - as.operationPollRateLimiter.Accept() - glog.V(10).Infof("InterfacesClient.Get(%q): start", nicName) nic, err := as.InterfacesClient.Get(as.ResourceGroup, nicName, "") - glog.V(10).Infof("InterfacesClient.Get(%q): end", nicName) if err != nil { return network.Interface{}, err } @@ -642,8 +637,6 @@ func (as *availabilitySet) ensureHostInPool(serviceName string, nodeName types.N nicName := *nic.Name glog.V(3).Infof("nicupdate(%s): nic(%s) - updating", serviceName, nicName) - as.operationPollRateLimiter.Accept() - glog.V(10).Infof("InterfacesClient.CreateOrUpdate(%q): start", *nic.Name) respChan, errChan := as.InterfacesClient.CreateOrUpdate(as.ResourceGroup, *nic.Name, nic, nil) resp := <-respChan err := <-errChan diff --git a/pkg/cloudprovider/providers/azure/azure_util_vmss.go b/pkg/cloudprovider/providers/azure/azure_util_vmss.go index c9b827c308e..2116e4f0dc7 100644 --- a/pkg/cloudprovider/providers/azure/azure_util_vmss.go +++ b/pkg/cloudprovider/providers/azure/azure_util_vmss.go @@ -401,10 +401,7 @@ func (ss *scaleSet) listScaleSetsWithRetry() ([]string, error) { allScaleSets := make([]string, 0) backoffError := wait.ExponentialBackoff(ss.requestBackoff(), func() (bool, error) { - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.List start for %v", ss.ResourceGroup) result, err = ss.VirtualMachineScaleSetsClient.List(ss.ResourceGroup) - glog.V(10).Infof("VirtualMachineScaleSetsClient.List end for %v", ss.ResourceGroup) if err != nil { glog.Errorf("VirtualMachineScaleSetsClient.List for %v failed: %v", ss.ResourceGroup, err) return false, err @@ -425,10 +422,7 @@ func (ss *scaleSet) listScaleSetsWithRetry() ([]string, error) { if result.NextLink != nil { backoffError := wait.ExponentialBackoff(ss.requestBackoff(), func() (bool, error) { - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.ListNextResults start for %v", ss.ResourceGroup) result, err = ss.VirtualMachineScaleSetsClient.ListNextResults(result) - glog.V(10).Infof("VirtualMachineScaleSetsClient.ListNextResults end for %v", ss.ResourceGroup) if err != nil { glog.Errorf("VirtualMachineScaleSetsClient.ListNextResults for %v failed: %v", ss.ResourceGroup, err) return false, err @@ -455,10 +449,7 @@ func (ss *scaleSet) listScaleSetVMsWithRetry(scaleSetName string) ([]compute.Vir allVMs := make([]compute.VirtualMachineScaleSetVM, 0) backoffError := wait.ExponentialBackoff(ss.requestBackoff(), func() (bool, error) { - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetVMsClient.List start for %v", scaleSetName) result, err = ss.VirtualMachineScaleSetVMsClient.List(ss.ResourceGroup, scaleSetName, "", "", string(compute.InstanceView)) - glog.V(10).Infof("VirtualMachineScaleSetVMsClient.List end for %v", scaleSetName) if err != nil { glog.Errorf("VirtualMachineScaleSetVMsClient.List for %v failed: %v", scaleSetName, err) return false, err @@ -477,10 +468,7 @@ func (ss *scaleSet) listScaleSetVMsWithRetry(scaleSetName string) ([]compute.Vir if result.NextLink != nil { backoffError := wait.ExponentialBackoff(ss.requestBackoff(), func() (bool, error) { - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetVMsClient.ListNextResults start for %v", scaleSetName) result, err = ss.VirtualMachineScaleSetVMsClient.ListNextResults(result) - glog.V(10).Infof("VirtualMachineScaleSetVMsClient.ListNextResults end for %v", ss.ResourceGroup) if err != nil { glog.Errorf("VirtualMachineScaleSetVMsClient.ListNextResults for %v failed: %v", scaleSetName, err) return false, err @@ -622,10 +610,7 @@ func (ss *scaleSet) GetPrimaryInterface(nodeName, vmSetName string) (network.Int return network.Interface{}, err } - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("InterfacesClient.Get(%q): start", nicName) nic, err := ss.InterfacesClient.GetVirtualMachineScaleSetNetworkInterface(ss.ResourceGroup, vm.ScaleSetName, vm.InstanceID, nicName, "") - glog.V(10).Infof("InterfacesClient.Get(%q): end", nicName) if err != nil { glog.Errorf("error: ss.GetPrimaryInterface(%s), ss.GetVirtualMachineScaleSetNetworkInterface.Get(%s, %s, %s), err=%v", nodeName, ss.ResourceGroup, vm.ScaleSetName, nicName, err) return network.Interface{}, err @@ -642,11 +627,7 @@ func (ss *scaleSet) GetPrimaryInterface(nodeName, vmSetName string) (network.Int // getScaleSet gets a scale set by name. func (ss *scaleSet) getScaleSet(name string) (compute.VirtualMachineScaleSet, bool, error) { - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.Get(%s): start", name) result, err := ss.VirtualMachineScaleSetsClient.Get(ss.ResourceGroup, name) - glog.V(10).Infof("VirtualMachineScaleSetsClient.Get(%s): end", name) - exists, realErr := checkResourceExistsFromError(err) if realErr != nil { return result, false, realErr @@ -714,8 +695,6 @@ func (ss *scaleSet) getPrimaryIPConfigForScaleSet(config *compute.VirtualMachine // createOrUpdateVMSSWithRetry invokes ss.VirtualMachineScaleSetsClient.CreateOrUpdate with exponential backoff retry. func (ss *scaleSet) createOrUpdateVMSSWithRetry(virtualMachineScaleSet compute.VirtualMachineScaleSet) error { return wait.ExponentialBackoff(ss.requestBackoff(), func() (bool, error) { - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.CreateOrUpdate(%s): start", *virtualMachineScaleSet.Name) respChan, errChan := ss.VirtualMachineScaleSetsClient.CreateOrUpdate(ss.ResourceGroup, *virtualMachineScaleSet.Name, virtualMachineScaleSet, nil) resp := <-respChan err := <-errChan @@ -727,8 +706,6 @@ func (ss *scaleSet) createOrUpdateVMSSWithRetry(virtualMachineScaleSet compute.V // updateVMSSInstancesWithRetry invokes ss.VirtualMachineScaleSetsClient.UpdateInstances with exponential backoff retry. func (ss *scaleSet) updateVMSSInstancesWithRetry(scaleSetName string, vmInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) error { return wait.ExponentialBackoff(ss.requestBackoff(), func() (bool, error) { - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.UpdateInstances(%s): start", scaleSetName) respChan, errChan := ss.VirtualMachineScaleSetsClient.UpdateInstances(ss.ResourceGroup, scaleSetName, vmInstanceIDs, nil) resp := <-respChan err := <-errChan @@ -784,8 +761,6 @@ func (ss *scaleSet) EnsureHostsInPool(serviceName string, nodes []*v1.Node, back primaryIPConfiguration.LoadBalancerBackendAddressPools = &newBackendPools glog.V(3).Infof("VirtualMachineScaleSetsClient.CreateOrUpdate for service (%s): scale set (%s) - updating", serviceName, vmSetName) - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.CreateOrUpdate(%q): start", vmSetName) respChan, errChan := ss.VirtualMachineScaleSetsClient.CreateOrUpdate(ss.ResourceGroup, vmSetName, virtualMachineScaleSet, nil) resp := <-respChan err := <-errChan @@ -829,8 +804,6 @@ func (ss *scaleSet) EnsureHostsInPool(serviceName string, nodes []*v1.Node, back vmInstanceIDs := compute.VirtualMachineScaleSetVMInstanceRequiredIDs{ InstanceIds: &instanceIDs, } - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.UpdateInstances(%q): start", vmSetName) respChan, errChan := ss.VirtualMachineScaleSetsClient.UpdateInstances(ss.ResourceGroup, vmSetName, vmInstanceIDs, nil) resp := <-respChan err = <-errChan @@ -898,8 +871,6 @@ func (ss *scaleSet) EnsureBackendPoolDeleted(poolID, vmSetName string) error { // Update scale set with backoff. primaryIPConfiguration.LoadBalancerBackendAddressPools = &newBackendPools glog.V(3).Infof("VirtualMachineScaleSetsClient.CreateOrUpdate: scale set (%s) - updating", vmSetName) - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.CreateOrUpdate(%q): start", vmSetName) respChan, errChan := ss.VirtualMachineScaleSetsClient.CreateOrUpdate(ss.ResourceGroup, vmSetName, virtualMachineScaleSet, nil) resp := <-respChan err = <-errChan @@ -921,8 +892,6 @@ func (ss *scaleSet) EnsureBackendPoolDeleted(poolID, vmSetName string) error { vmInstanceIDs := compute.VirtualMachineScaleSetVMInstanceRequiredIDs{ InstanceIds: &instanceIDs, } - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.UpdateInstances(%q): start", vmSetName) updateRespChan, errChan := ss.VirtualMachineScaleSetsClient.UpdateInstances(ss.ResourceGroup, vmSetName, vmInstanceIDs, nil) updateResp := <-updateRespChan err = <-errChan @@ -943,8 +912,6 @@ func (ss *scaleSet) EnsureBackendPoolDeleted(poolID, vmSetName string) error { // TODO: remove this workaround when figuring out the root cause. if len(newBackendPools) == 0 { glog.V(3).Infof("VirtualMachineScaleSetsClient.CreateOrUpdate: scale set (%s) - updating second time", vmSetName) - ss.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachineScaleSetsClient.CreateOrUpdate(%q): start", vmSetName) respChan, errChan = ss.VirtualMachineScaleSetsClient.CreateOrUpdate(ss.ResourceGroup, vmSetName, virtualMachineScaleSet, nil) resp = <-respChan err = <-errChan diff --git a/pkg/cloudprovider/providers/azure/azure_wrap.go b/pkg/cloudprovider/providers/azure/azure_wrap.go index 7b0c2f7f73c..144cdc0aaa1 100644 --- a/pkg/cloudprovider/providers/azure/azure_wrap.go +++ b/pkg/cloudprovider/providers/azure/azure_wrap.go @@ -96,11 +96,7 @@ func (az *Cloud) getVirtualMachine(nodeName types.NodeName) (vm compute.VirtualM // case we do get instance view every time to fulfill the azure_zones requirement without hitting // throttling. // Consider adding separate parameter for controlling 'InstanceView' once node update issue #56276 is fixed - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("VirtualMachinesClient.Get(%s): start", vmName) vm, err = az.VirtualMachinesClient.Get(az.ResourceGroup, vmName, compute.InstanceView) - glog.V(10).Infof("VirtualMachinesClient.Get(%s): end", vmName) - exists, realErr := checkResourceExistsFromError(err) if realErr != nil { return vm, realErr @@ -122,11 +118,7 @@ func (az *Cloud) getVirtualMachine(nodeName types.NodeName) (vm compute.VirtualM func (az *Cloud) getRouteTable() (routeTable network.RouteTable, exists bool, err error) { var realErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("RouteTablesClient.Get(%s): start", az.RouteTableName) routeTable, err = az.RouteTablesClient.Get(az.ResourceGroup, az.RouteTableName, "") - glog.V(10).Infof("RouteTablesClient.Get(%s): end", az.RouteTableName) - exists, realErr = checkResourceExistsFromError(err) if realErr != nil { return routeTable, false, realErr @@ -142,11 +134,7 @@ func (az *Cloud) getRouteTable() (routeTable network.RouteTable, exists bool, er func (az *Cloud) getSecurityGroup() (sg network.SecurityGroup, exists bool, err error) { var realErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("SecurityGroupsClient.Get(%s): start", az.SecurityGroupName) sg, err = az.SecurityGroupsClient.Get(az.ResourceGroup, az.SecurityGroupName, "") - glog.V(10).Infof("SecurityGroupsClient.Get(%s): end", az.SecurityGroupName) - exists, realErr = checkResourceExistsFromError(err) if realErr != nil { return sg, false, realErr @@ -161,11 +149,8 @@ func (az *Cloud) getSecurityGroup() (sg network.SecurityGroup, exists bool, err func (az *Cloud) getAzureLoadBalancer(name string) (lb network.LoadBalancer, exists bool, err error) { var realErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("LoadBalancerClient.Get(%s): start", name) - lb, err = az.LoadBalancerClient.Get(az.ResourceGroup, name, "") - glog.V(10).Infof("LoadBalancerClient.Get(%s): end", name) + lb, err = az.LoadBalancerClient.Get(az.ResourceGroup, name, "") exists, realErr = checkResourceExistsFromError(err) if realErr != nil { return lb, false, realErr @@ -181,10 +166,7 @@ func (az *Cloud) getAzureLoadBalancer(name string) (lb network.LoadBalancer, exi func (az *Cloud) listLoadBalancers() (lbListResult network.LoadBalancerListResult, exists bool, err error) { var realErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("LoadBalancerClient.List(%s): start", az.ResourceGroup) lbListResult, err = az.LoadBalancerClient.List(az.ResourceGroup) - glog.V(10).Infof("LoadBalancerClient.List(%s): end", az.ResourceGroup) exists, realErr = checkResourceExistsFromError(err) if realErr != nil { return lbListResult, false, realErr @@ -204,11 +186,7 @@ func (az *Cloud) getPublicIPAddress(pipResourceGroup string, pipName string) (pi } var realErr error - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("PublicIPAddressesClient.Get(%s, %s): start", resourceGroup, pipName) pip, err = az.PublicIPAddressesClient.Get(resourceGroup, pipName, "") - glog.V(10).Infof("PublicIPAddressesClient.Get(%s, %s): end", resourceGroup, pipName) - exists, realErr = checkResourceExistsFromError(err) if realErr != nil { return pip, false, realErr @@ -231,11 +209,7 @@ func (az *Cloud) getSubnet(virtualNetworkName string, subnetName string) (subnet rg = az.ResourceGroup } - az.operationPollRateLimiter.Accept() - glog.V(10).Infof("SubnetsClient.Get(%s): start", subnetName) subnet, err = az.SubnetsClient.Get(rg, virtualNetworkName, subnetName, "") - glog.V(10).Infof("SubnetsClient.Get(%s): end", subnetName) - exists, realErr = checkResourceExistsFromError(err) if realErr != nil { return subnet, false, realErr